@powerlines/deepkit 0.6.167 → 0.7.1

package/dist/vendor/core.mjs

@@ -0,0 +1,1116 @@
+import { $ as isFunction, A as first, At as eachKey, B as getObjectKeysSize, C as copy, Ct as setPathValue, D as empty, Dt as time, E as deletePathValue, Et as stringifyValueWithType, F as getClassName, G as identifyType, H as getPathValue, I as getClassPropertyName, J as isArray, K as inDebugMode, L as getClassTypeFromInstance, M as fixAsyncOperation, N as formatError, O as ensureError, Ot as zip, P as forwardTypeArguments, Q as isConstructable, R as getCurrentFileName, S as collectForMicrotask, St as rangeArray, T as createStack, Tt as sleep, U as hasProperty, V as getParentClass, W as humanBytes, X as isClass, Y as isAsyncFunction, Z as isClassInstance, _ as assertDefined, _t as mergePromiseStack, a as arrayHasItem, at as isNumeric, b as average, bt as prettyPrintObject, c as toFastProperties, ct as isPlainObject, d as __ΩAbstractClassType, dt as isSet, et as isGlobalClass, f as __ΩClassType, ft as isString, g as applyDefaults, gt as lastKey, h as appendObject, ht as last, i as arrayClear, it as isNumber, j as firstKey, jt as eachPair, k as escapeRegExp, kt as each, l as AsyncFunction, lt as isPromise, m as __ΩExtractClassType, mt as iterableSize, n as indent, nt as isIterable, o as arrayMoveItem, ot as isObject, p as __ΩCustomError, pt as isUndefined, q as indexOf, r as CompilerContext, rt as isNull, s as arrayRemoveItem, st as isObjectLiteral, t as capitalize, tt as isInteger, u as CustomError, ut as isPrototypeOfBase, v as assertInstanceOf, vt as mergeStack, w as createDynamicClass, wt as size, x as changeClass, xt as range, y as asyncOperation, yt as prependObjectKeys, z as getInheritanceChain } from "./string-BuMgdahD.mjs";
+
+//#region ../../node_modules/.pnpm/@deepkit+core@1.0.5_patch_hash=8c3beca4372c6a8941162780ddd0f977ef3d461c2018f0809f86f416260ba440/node_modules/@deepkit/core/dist/esm/src/decorators.js
+const __ΩPropertyDescriptor = [
+	"configurable",
+	"enumerable",
+	"value",
+	"writable",
+	"get",
+	"v",
+	"set",
+	"PropertyDescriptor",
+	"P)4!8)4\"8\"4#8)4$8P\"1%P\"2&$1'Mw(y"
+];
+const __ΩTypedPropertyDescriptor = [
+	"T",
+	"enumerable",
+	"configurable",
+	"writable",
+	"value",
+	"",
+	"get",
+	"set",
+	"TypedPropertyDescriptor",
+	"b!P)4\"8)4#8)4$8e\"!4%8Pe#!/&4'8Pe#!2%$/&4(8Mw)y"
+];
+function __assignType$6(fn, args) {
+	fn.__type = args;
+	return fn;
+}
+/**
+* Logs every call to this method on stdout.
+*
+* @public
+*/
+function log() {
+	return __assignType$6(function(target, propertyKey, descriptor) {
+		const orig = descriptor.value;
+		descriptor.value = __assignType$6(function(...args) {
+			const a = args.map(__assignType$6((v) => typeof v, [
+				"v",
+				"",
+				"P\"2!\"/\""
+			])).join(",");
+			console.info(getClassName(target) + "::" + String(propertyKey) + "(" + a + ")");
+			return orig.apply(this, args);
+		}, [
+			"args",
+			"",
+			"P\"@2!\"/\""
+		]);
+		return descriptor;
+	}, [
+		"target",
+		"propertyKey",
+		() => __ΩPropertyDescriptor,
+		"descriptor",
+		"",
+		"P%2!P&+J2\"n#2$\"/%"
+	]);
+}
+log.__type = ["log", "P\"/!"];
+/**
+* Makes sure that calls to this async method are stacked up and are called one after another and not parallel.
+*
+* @public
+*/
+function stack() {
+	return __assignType$6(function(target, propertyKey, descriptor) {
+		const orig = descriptor.value;
+		descriptor.value = __assignType$6(async function(...args) {
+			const name = "__c_" + propertyKey;
+			if (this[name] === void 0) {
+				this[name] = null;
+				toFastProperties(this);
+			}
+			while (this[name]) await this[name];
+			this[name] = orig.apply(this, args);
+			try {
+				return await this[name];
+			} finally {
+				this[name] = null;
+			}
+		}, [
+			"args",
+			"",
+			"P\"@2!\"/\""
+		]);
+	}, [
+		"target",
+		"propertyKey",
+		() => __ΩTypedPropertyDescriptor,
+		"args",
+		"",
+		"descriptor",
+		"P%2!&2\"P\"@2$\"`/%o#\"2&\"/%"
+	]);
+}
+stack.__type = ["stack", "P\"/!"];
+/**
+* Makes sure that this async method is only running once at a time. When this method is running and it is tried
+* to call it another times, that call is "dropped" and it returns simply the result of the previous running call (waiting for it to complete first).
+*
+* @public
+*/
+function singleStack() {
+	return __assignType$6(function(target, propertyKey, descriptor) {
+		const orig = descriptor.value;
+		descriptor.value = __assignType$6(async function(...args) {
+			const name = "__sc_" + propertyKey;
+			if (this[name] === void 0) {
+				this[name] = null;
+				toFastProperties(this);
+			}
+			if (this[name]) return await this[name];
+			this[name] = orig.apply(this, args);
+			try {
+				return await this[name];
+			} finally {
+				this[name] = null;
+			}
+		}, [
+			"args",
+			"",
+			"P\"@2!\"/\""
+		]);
+	}, [
+		"target",
+		"propertyKey",
+		() => __ΩTypedPropertyDescriptor,
+		"args",
+		"",
+		"descriptor",
+		"P%2!&2\"P\"@2$\"`/%o#\"2&\"/%"
+	]);
+}
+singleStack.__type = ["singleStack", "P\"/!"];
+
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+core@1.0.5_patch_hash=8c3beca4372c6a8941162780ddd0f977ef3d461c2018f0809f86f416260ba440/node_modules/@deepkit/core/dist/esm/src/enum.js
+const __ΩObject = [
+	() => Function,
+	"constructor",
+	"toString",
+	"toLocaleString",
+	0,
+	"valueOf",
+	() => __ΩPropertyKey,
+	"v",
+	"hasOwnProperty",
+	0,
+	"isPrototypeOf",
+	() => __ΩPropertyKey,
+	"propertyIsEnumerable",
+	"Object",
+	"PPu!4\"P&1#P&1$Pn%1&Pn'2()1)Pn*2()1+Pn,2()1-Mw.y"
+];
+const __ΩPropertyKey = ["PropertyKey", "P&'+Jw!y"];
+function __assignType$5(fn, args) {
+	fn.__type = args;
+	return fn;
+}
+const cacheEnumLabels = (Map.Ω = [[() => __ΩObject, "n!"], ["&F"]], /* @__PURE__ */ new Map());
+/**
+* Returns the enum label for a given enum value.
+*
+* @public
+*/
+function getEnumLabel(enumType, id) {
+	for (const i of eachKey(enumType)) if (id === enumType[i]) return i;
+}
+getEnumLabel.__type = [
+	"enumType",
+	"id",
+	"getEnumLabel",
+	"PP&\"LM2!\"2\"\"/#"
+];
+/**
+* Returns all possible enum labels.
+*
+* @public
+*/
+function getEnumLabels(enumDefinition) {
+	let value = cacheEnumLabels.get(enumDefinition);
+	if (!value) {
+		value = Object.keys(enumDefinition).filter(__assignType$5((v) => !Number.isFinite(parseInt(v, 10)), [
+			"v",
+			"",
+			"P\"2!\"/\""
+		]));
+		cacheEnumLabels.set(enumDefinition, value);
+	}
+	return value;
+}
+getEnumLabels.__type = [
+	"enumDefinition",
+	"getEnumLabels",
+	"P\"2!\"/\""
+];
+const cacheEnumKeys = (Map.Ω = [[() => __ΩObject, "n!"], ["&F"]], /* @__PURE__ */ new Map());
+/**
+* Returns all possible enum keys.
+*
+* @public
+*/
+function getEnumValues(enumDefinition) {
+	let value = cacheEnumKeys.get(enumDefinition);
+	if (!value) {
+		value = Object.values(enumDefinition).filter(__assignType$5((v) => {
+			return "number" !== typeof enumDefinition[v];
+		}, [
+			"v",
+			"",
+			"P\"2!\"/\""
+		]));
+		cacheEnumKeys.set(enumDefinition, value);
+	}
+	return value;
+}
+getEnumValues.__type = [
+	"enumDefinition",
+	"getEnumValues",
+	"P\"2!\"F/\""
+];
+function getEnumKeyLabelMap(enumDefinition) {
+	const map = (Map.Ω = [["\""], ["&"]], /* @__PURE__ */ new Map());
+	const keys = getEnumValues(enumDefinition);
+	const labels = getEnumLabels(enumDefinition);
+	for (let i = 0; i < keys.length; i++) map.set(keys[i], labels[i]);
+	return map;
+}
+getEnumKeyLabelMap.__type = [
+	"enumDefinition",
+	"getEnumKeyLabelMap",
+	"P\"2!\"&E/\""
+];
+/**
+* Checks whether given enum value is valid.
+*
+* @public
+*/
+function isValidEnumValue(enumDefinition, value, allowLabelsAsValue = false) {
+	if (allowLabelsAsValue) {
+		if (-1 !== getEnumLabels(enumDefinition).indexOf(String(value))) return true;
+	}
+	const values = getEnumValues(enumDefinition);
+	return -1 !== values.indexOf(+value) || -1 !== values.indexOf(value) || -1 !== values.indexOf(String(value));
+}
+isValidEnumValue.__type = [
+	"enumDefinition",
+	"value",
+	"allowLabelsAsValue",
+	"isValidEnumValue",
+	"P\"2!\"2\"\"2#\"/$"
+];
+/**
+* @public
+*/
+function getValidEnumValue(enumDefinition, value, allowLabelsAsValue = false) {
+	if (allowLabelsAsValue) {
+		if (-1 !== getEnumLabels(enumDefinition).indexOf(String(value))) return enumDefinition[String(value)];
+	}
+	const values = getEnumValues(enumDefinition);
+	if (-1 !== values.indexOf(value)) return value;
+	if (-1 !== values.indexOf(+value)) return +value;
+	if (-1 !== values.indexOf(String(value))) return String(value);
+}
+getValidEnumValue.__type = [
+	"enumDefinition",
+	"value",
+	"allowLabelsAsValue",
+	"getValidEnumValue",
+	"P\"2!\"2\"\"2#\"/$"
+];
+
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+core@1.0.5_patch_hash=8c3beca4372c6a8941162780ddd0f977ef3d461c2018f0809f86f416260ba440/node_modules/@deepkit/core/dist/esm/src/timer.js
+var Timer = class {
+	constructor() {
+		this.timeoutTimers = [];
+	}
+	setTimeout(cb, timeout) {
+		const timer = setTimeout(cb, timeout);
+		this.timeoutTimers.push(timer);
+		return timer;
+	}
+	/**
+	* Clears all timers at once.
+	*/
+	clear() {
+		for (const timeout of this.timeoutTimers) clearTimeout(timeout);
+	}
+};
+Timer.__type = [
+	"timeoutTimers",
+	function() {
+		return [];
+	},
+	"",
+	"cb",
+	"timeout",
+	"setTimeout",
+	"clear",
+	"Timer",
+	"\"F3!<>\"PP$/#2$'2%\"0&P\"0'5w("
+];
+
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+core@1.0.5_patch_hash=8c3beca4372c6a8941162780ddd0f977ef3d461c2018f0809f86f416260ba440/node_modules/@deepkit/core/dist/esm/src/process-locker.js
+function __assignType$4(fn, args) {
+	fn.__type = args;
+	return fn;
+}
+const LOCKS = {};
+/**
+* This lock mechanism works only for one process (worker).
+*
+* live-mutex: has horrible API and doesn't allow to check if an key is currently locked.
+* proper-filelock: No way to do a correct mutex locking with event-driven blocking acquire() method.
+* redislock: Very bad performance on high-load (when multiple locks on the same key `wait`, since it loops)
+* mongodb lock: even worse performance than redis. Jesus.
+*/
+var ProcessLock = class {
+	constructor(id) {
+		this.id = id;
+		this.holding = false;
+	}
+	async acquire(ttl = 0, timeout = 0) {
+		if (this.holding) throw new Error("Lock already acquired");
+		return Promise.Ω = [["$"]], new Promise(__assignType$4((resolve, reject) => {
+			if (LOCKS[this.id]) {
+				let timeoutId;
+				const ourTake = () => {
+					LOCKS[this.id].time = Date.now() / 1e3;
+					clearTimeout(timeoutId);
+					this.holding = true;
+					resolve();
+					if (ttl) this.ttlTimeout = setTimeout(() => {
+						this.unlock();
+					}, ttl * 1e3);
+				};
+				if (timeout > 0) timeoutId = setTimeout(() => {
+					if (LOCKS[this.id]) arrayRemoveItem(LOCKS[this.id].queue, ourTake);
+					reject("Lock timed out " + this.id);
+				}, timeout * 1e3);
+				LOCKS[this.id].queue.push(ourTake);
+			} else {
+				LOCKS[this.id] = {
+					time: Date.now() / 1e3,
+					queue: []
+				};
+				this.holding = true;
+				resolve();
+				if (ttl) this.ttlTimeout = setTimeout(() => {
+					this.unlock();
+				}, ttl * 1e3);
+			}
+		}, [
+			"resolve",
+			"reject",
+			"",
+			"P\"2!\"2\"\"/#"
+		]));
+	}
+	isLocked() {
+		return this.holding;
+	}
+	tryLock(ttl = 0) {
+		this.holding = false;
+		if (!LOCKS[this.id]) {
+			LOCKS[this.id] = {
+				time: Date.now() / 1e3,
+				queue: []
+			};
+			this.holding = true;
+			if (ttl) this.ttlTimeout = setTimeout(() => {
+				this.unlock();
+			}, ttl * 1e3);
+		}
+		return this.holding;
+	}
+	unlock() {
+		clearTimeout(this.ttlTimeout);
+		if (!this.holding) return;
+		this.holding = false;
+		if (LOCKS[this.id].queue.length) LOCKS[this.id].queue.shift()();
+		else delete LOCKS[this.id];
+	}
+};
+ProcessLock.__type = [
+	"holding",
+	function() {
+		return false;
+	},
+	"ttlTimeout",
+	"id",
+	"constructor",
+	"ttl",
+	() => 0,
+	"timeout",
+	() => 0,
+	"acquire",
+	"isLocked",
+	() => 0,
+	"tryLock",
+	"unlock",
+	"ProcessLock",
+	")3!;>\"\"3#<P&2$:9\"0%P'2&>''2(>)\"0*P\"0+P'2&>,\"0-P\"0.5w/"
+];
+var ProcessLocker = class {
+	/**
+	*
+	* @param id
+	* @param ttl optional defines when the times automatically unlocks.
+	* @param timeout if after `timeout` seconds the lock isn't acquired, it throws an error.
+	*/
+	async acquireLock(id, ttl = 0, timeout = 0) {
+		const lock = new ProcessLock(id);
+		await lock.acquire(ttl, timeout);
+		return lock;
+	}
+	async tryLock(id, ttl = 0) {
+		const lock = new ProcessLock(id);
+		if (lock.tryLock(ttl)) return lock;
+	}
+	isLocked(id) {
+		return !!LOCKS[id];
+	}
+};
+ProcessLocker.__type = [
+	"id",
+	"ttl",
+	() => 0,
+	"timeout",
+	() => 0,
+	() => ProcessLock,
+	"acquireLock",
+	() => 0,
+	() => ProcessLock,
+	"tryLock",
+	"isLocked",
+	"ProcessLocker",
+	"P&2!'2\">#'2$>%P7&`0'P&2!'2\">(PP7)-J`0*P&2!)0+5w,"
+];
+var Mutex = class {
+	unlock() {
+		if (this.resolver) this.resolver();
+		this.promise = void 0;
+	}
+	async lock() {
+		while (this.promise) await this.promise;
+		this.promise = new Promise(__assignType$4((resolver) => {
+			this.resolver = resolver;
+		}, [
+			"resolver",
+			"",
+			"P\"2!\"/\""
+		]));
+	}
+};
+Mutex.__type = [
+	"promise",
+	() => Function,
+	"resolver",
+	"unlock",
+	"lock",
+	"Mutex",
+	"$`3!8<Pu\"3#8<P$0$P$`0%5w&"
+];
+
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+core@1.0.5_patch_hash=8c3beca4372c6a8941162780ddd0f977ef3d461c2018f0809f86f416260ba440/node_modules/@deepkit/core/dist/esm/src/network.js
+var ParsedHost = class {
+	constructor() {
+		this.host = "127.0.0.1";
+		this.port = 0;
+		this.unixSocket = "";
+	}
+	get isUnixSocket() {
+		return this.unixSocket !== "";
+	}
+	get isHostname() {
+		return this.unixSocket === "";
+	}
+	get hostWithIp() {
+		return this.host + (this.port ? (this.host && ":") + this.port : "");
+	}
+	toString() {
+		return this.isUnixSocket ? this.unixSocket : this.hostWithIp;
+	}
+	getWebSocketUrl(secure = false) {
+		const protocol = secure ? "wss" : "ws";
+		if (this.isUnixSocket) return `${protocol}+unix://${this.unixSocket}`;
+		return `${protocol}://${this.hostWithIp}`;
+	}
+	getHttpUrl(secure = false) {
+		if (this.isUnixSocket) return `file://${this.unixSocket}`;
+		return `${secure ? "https" : "http"}://${this.hostWithIp}`;
+	}
+};
+ParsedHost.__type = [
+	"host",
+	function() {
+		return "127.0.0.1";
+	},
+	"port",
+	function() {
+		return 0;
+	},
+	"unixSocket",
+	function() {
+		return "";
+	},
+	"toString",
+	"secure",
+	() => false,
+	"getWebSocketUrl",
+	() => false,
+	"getHttpUrl",
+	"ParsedHost",
+	"&3!>\"'3#>$&3%>&!!!P&0'P)2(>)\"0*P)2(>+\"0,5w-"
+];
+function parseHost(hostWithIpOrUnixPath) {
+	const parsedHost = new ParsedHost();
+	if (hostWithIpOrUnixPath.includes("/") || hostWithIpOrUnixPath.includes("\\") || hostWithIpOrUnixPath.endsWith(".sock")) parsedHost.unixSocket = hostWithIpOrUnixPath;
+	else if (hostWithIpOrUnixPath.includes(":")) {
+		const [host, port] = hostWithIpOrUnixPath.split(":");
+		if (host) parsedHost.host = host;
+		if (port) parsedHost.port = parseInt(port, 10);
+	} else if (hostWithIpOrUnixPath) parsedHost.host = hostWithIpOrUnixPath;
+	return parsedHost;
+}
+parseHost.__type = [
+	"hostWithIpOrUnixPath",
+	() => ParsedHost,
+	"parseHost",
+	"P&2!P7\"/#"
+];
+
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+core@1.0.5_patch_hash=8c3beca4372c6a8941162780ddd0f977ef3d461c2018f0809f86f416260ba440/node_modules/@deepkit/core/dist/esm/src/emitter.js
+const __ΩAsyncSubscriber = [
+	"T",
+	"event",
+	"",
+	"AsyncSubscriber",
+	"b!Pe\"!2\"P$`$J/#w$y"
+];
+const __ΩSubscriber = [
+	"T",
+	"event",
+	"",
+	"Subscriber",
+	"b!Pe\"!2\"P$`$J/#w$y"
+];
+const __ΩAsyncEventSubscription = [
+	"",
+	"unsubscribe",
+	"AsyncEventSubscription",
+	"PP$/!4\"Mw#y"
+];
+const __ΩEventSubscription = [
+	"",
+	"unsubscribe",
+	"EventSubscription",
+	"PP$/!4\"Mw#y"
+];
+let asyncId = 0;
+var EmitterEvent = class {
+	constructor() {
+		this.id = asyncId++;
+		this.stopped = false;
+		this.propagationStopped = false;
+	}
+	/**
+	* Stop propagating the event to subsequent event listeners.
+	*/
+	stopPropagation() {
+		this.propagationStopped = true;
+	}
+	/**
+	* Signal the emitter that you want to abort.
+	* Subsequent event listeners will still be called.
+	*/
+	stop() {
+		this.stopped = true;
+	}
+};
+EmitterEvent.__type = [
+	"id",
+	function() {
+		return asyncId++;
+	},
+	"stopped",
+	function() {
+		return false;
+	},
+	"propagationStopped",
+	function() {
+		return false;
+	},
+	"stopPropagation",
+	"stop",
+	"EmitterEvent",
+	"!3!9>\")3#>$)3%>&P\"0'P\"0(5w)"
+];
+var EventEmitter = class {
+	constructor(parent) {
+		this.parent = parent;
+		this.subscribers = [];
+	}
+	subscribe(callback) {
+		this.subscribers.push(callback);
+		return { unsubscribe: () => {
+			arrayRemoveItem(this.subscribers, callback);
+		} };
+	}
+	emit(event) {
+		if (this.parent) this.parent.emit(event);
+		if (event.propagationStopped) return;
+		for (const subscriber of this.subscribers) {
+			subscriber(event);
+			if (event.propagationStopped) return;
+		}
+	}
+	hasSubscriptions() {
+		return this.subscribers.length > 0;
+	}
+};
+EventEmitter.__type = [
+	"T",
+	() => __ΩSubscriber,
+	"subscribers",
+	function() {
+		return [];
+	},
+	() => EventEmitter,
+	"parent",
+	"constructor",
+	() => __ΩSubscriber,
+	"callback",
+	() => __ΩEventSubscription,
+	"subscribe",
+	"event",
+	"emit",
+	"hasSubscriptions",
+	"EventEmitter",
+	"b!e!!o\"\"F3#<>$PP\"7%2&8<\"0'Pe\"!o(\"2)n*0+Pe\"!2,$0-P)0.5w/"
+];
+var AsyncEventEmitter = class {
+	constructor(parent) {
+		this.parent = parent;
+		this.subscribers = [];
+	}
+	subscribe(callback) {
+		this.subscribers.push(callback);
+		return { unsubscribe: () => {
+			arrayRemoveItem(this.subscribers, callback);
+		} };
+	}
+	async emit(event) {
+		if (this.parent) await this.parent.emit(event);
+		if (event.propagationStopped) return;
+		for (const subscriber of this.subscribers) {
+			await subscriber(event);
+			if (event.propagationStopped) return;
+		}
+	}
+	hasSubscriptions() {
+		return this.subscribers.length > 0;
+	}
+};
+AsyncEventEmitter.__type = [
+	"T",
+	() => __ΩAsyncSubscriber,
+	"subscribers",
+	function() {
+		return [];
+	},
+	() => AsyncEventEmitter,
+	"parent",
+	"constructor",
+	() => __ΩAsyncSubscriber,
+	"callback",
+	() => __ΩAsyncEventSubscription,
+	"subscribe",
+	"event",
+	"emit",
+	"hasSubscriptions",
+	"AsyncEventEmitter",
+	"b!e!!o\"\"F3#<>$PP\"7%2&8<\"0'Pe\"!o(\"2)n*0+Pe\"!2,$`0-P)0.5w/"
+];
+
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+core@1.0.5_patch_hash=8c3beca4372c6a8941162780ddd0f977ef3d461c2018f0809f86f416260ba440/node_modules/@deepkit/core/dist/esm/src/reactive.js
+function __assignType$3(fn, args) {
+	fn.__type = args;
+	return fn;
+}
+const nextTick = typeof requestAnimationFrame !== "undefined" ? __assignType$3((cb) => requestAnimationFrame(cb), [
+	"",
+	"cb",
+	"PP$/!2\"\"/!"
+]) : __assignType$3((cb) => setTimeout(cb), [
+	"",
+	"cb",
+	"PP$/!2\"\"/!"
+]);
+const clearTick = typeof requestAnimationFrame !== "undefined" ? __assignType$3((id) => cancelAnimationFrame(id), [
+	"id",
+	"",
+	"P\"2!\"/\""
+]) : __assignType$3((id) => clearTick(id), [
+	"id",
+	"",
+	"P\"2!\"/\""
+]);
+/**
+* Wraps a function and calls it only `cps` times per frame.
+*
+* This is handy to throttle all kind of rapid calls, like mouse move events or other kind of events.
+*
+* @example
+* ```typescript
+* function expensiveFunction() {
+*     //...
+* }
+*
+* const throttled = throttleTime(expensiveFunction, 5); //5 calls per second max
+*
+* throttled();
+* throttled();
+* throttled();
+* //throttled will here only be called once
+* ```
+*/
+function throttleTime(call, cps = 5) {
+	let last = Date.now();
+	let dirty = false;
+	let lastArgs = [];
+	let execution = false;
+	function tick() {
+		if (!execution && Date.now() - last > 1e3 / cps) {
+			execution = true;
+			call(...lastArgs);
+			dirty = false;
+			last = Date.now();
+			execution = false;
+		}
+		if (dirty) nextTick(tick);
+	}
+	tick.__type = ["tick", "P\"/!"];
+	return __assignType$3((...args) => {
+		dirty = true;
+		lastArgs = args;
+		tick();
+	}, [
+		"args",
+		"",
+		"P\"@2!\"/\""
+	]);
+}
+throttleTime.__type = [
+	() => Function,
+	"call",
+	"cps",
+	"args",
+	"",
+	"throttleTime",
+	"PPu!2\"\"2#P\"@2$$/%/&"
+];
+/**
+* This functions returns a stack that is filled as long as the gate is not activated.
+* Once activated all recorded calls go to given callback and subsequent calls go directly to given callback.
+*/
+function bufferedGate(callback) {
+	const q = [];
+	let activated = false;
+	const throttled = throttleTime(async () => {
+		if (q.length === 0) return;
+		for (const t of q) {
+			const result = callback(t);
+			if (result instanceof Promise) await result;
+		}
+		q.splice(0, q.length);
+	});
+	return {
+		activate: () => {
+			activated = true;
+			throttled();
+		},
+		call: __assignType$3((i) => {
+			q.push(i);
+			if (activated) throttled();
+		}, [
+			() => callback,
+			"arg",
+			"",
+			"i",
+			"PPdi!Ph\"!2\"\"/#qe!!!j2$\"/#"
+		])
+	};
+}
+bufferedGate.__type = [
+	"arg",
+	"",
+	"callback",
+	"bufferedGate",
+	"PP\"2!\"/\"2#\"/$"
+];
+
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+core@1.0.5_patch_hash=8c3beca4372c6a8941162780ddd0f977ef3d461c2018f0809f86f416260ba440/node_modules/@deepkit/core/dist/esm/src/reflection.js
+const COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm;
+const DEFAULT_PARAMS = /=[^,]+/gm;
+const FAT_ARROWS = /=>.*$/gm;
+function extractParameters(fn) {
+	fn = typeof fn === "string" ? fn : fn.toString();
+	fn = removeStrings(fn);
+	if (fn.startsWith("class")) {
+		const start = fn.match(/* @__PURE__ */ new RegExp("[	 \n{]constructor\\("));
+		if (!start) return [];
+		fn = fn.substr((start.index || 0) + start[0].length);
+		fn = fn.replace(COMMENTS, "").replace(FAT_ARROWS, "").replace(DEFAULT_PARAMS, "");
+		return fn.slice(0, fn.indexOf("{")).match(/([^\(\){\s,]+)/g) || [];
+	} else {
+		fn = fn.replace(COMMENTS, "").replace(FAT_ARROWS, "").replace(DEFAULT_PARAMS, "");
+		return fn.slice(fn.indexOf("(") + 1, fn.indexOf("{")).match(/([^\(\)\{\}\s,]+)/g) || [];
+	}
+}
+extractParameters.__type = [
+	() => Function,
+	() => __ΩClassType,
+	"fn",
+	"extractParameters",
+	"PP&Pu!n\"J2#&F/$"
+];
+function extractMethodBody(classCode, name) {
+	let methodCode = "";
+	classCode = removeStrings(classCode);
+	const start = classCode.match(new RegExp("[	 \n]" + name + "\\("));
+	if (!start) return "";
+	classCode = classCode.substr((start.index || 0) + start[0].length);
+	let blockDepth = 1;
+	classCode = classCode.substr(classCode.indexOf("{") + 1);
+	for (let i = 0; i < classCode.length; i++) {
+		const char = classCode[i];
+		if (char === "{") blockDepth++;
+		if (char === "}") blockDepth--;
+		if (blockDepth === 0) return methodCode;
+		if (char === "\n" || char === "	" || char === " ") continue;
+		methodCode += char;
+	}
+	return methodCode;
+}
+extractMethodBody.__type = [
+	"classCode",
+	"name",
+	"extractMethodBody",
+	"P&2!&2\"&/#"
+];
+function removeStrings(code) {
+	let result = "";
+	let inString = false;
+	for (let i = 0; i < code.length; i++) {
+		const char = code[i];
+		if (inString && char === "\\") {
+			i++;
+			continue;
+		}
+		if (char === "\"") {
+			if (inString === "\"") {
+				inString = false;
+				continue;
+			}
+			if (!inString) {
+				inString = "\"";
+				continue;
+			}
+		}
+		if (char === "'") {
+			if (inString === "'") {
+				inString = false;
+				continue;
+			}
+			if (!inString) {
+				inString = "'";
+				continue;
+			}
+		}
+		if (!inString) result += char;
+	}
+	return result;
+}
+removeStrings.__type = [
+	"code",
+	"removeStrings",
+	"P&2!\"/\""
+];
+
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+core@1.0.5_patch_hash=8c3beca4372c6a8941162780ddd0f977ef3d461c2018f0809f86f416260ba440/node_modules/@deepkit/core/dist/esm/src/url.js
+function __assignType$2(fn, args) {
+	fn.__type = args;
+	return fn;
+}
+function removeSlash(v) {
+	return v.replace(/(^\/+)|(\/+$)/g, "");
+}
+removeSlash.__type = [
+	"v",
+	"removeSlash",
+	"P&2!&/\""
+];
+function urlJoin(...path) {
+	const leadingSlash = path[0] && path[0] !== "/" && path[0][0] === "/";
+	const last = path[path.length - 1];
+	const trailingSlash = last && last !== "/" && last[last.length - 1] === "/";
+	return (leadingSlash ? "/" : "") + path.filter(__assignType$2((v) => !!v, [
+		"v",
+		"",
+		"P\"2!\"/\""
+	])).map(__assignType$2((v) => v === "/" ? "" : removeSlash(v.trim()), [
+		"v",
+		"",
+		"P\"2!\"/\""
+	])).join("/") + (trailingSlash ? "/" : "");
+}
+urlJoin.__type = [
+	"path",
+	"urlJoin",
+	"P&@2!&/\""
+];
+
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+core@1.0.5_patch_hash=8c3beca4372c6a8941162780ddd0f977ef3d461c2018f0809f86f416260ba440/node_modules/@deepkit/core/dist/esm/src/types.js
+const __ΩTypeAnnotation = [
+	"T",
+	"Options",
+	"TypeAnnotation",
+	"b!!c\"#w#y"
+];
+const __ΩInjectMeta = [
+	"T",
+	() => __ΩTypeAnnotation,
+	"inject",
+	"InjectMeta",
+	"!c!.#e!!o\"#w$y"
+];
+const __ΩInject = [
+	"Type",
+	"Token",
+	() => __ΩInjectMeta,
+	"Inject",
+	"b!!c\"Pe\"!e\"\"o#\"Kw$y"
+];
+
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+core@1.0.5_patch_hash=8c3beca4372c6a8941162780ddd0f977ef3d461c2018f0809f86f416260ba440/node_modules/@deepkit/core/dist/esm/src/buffer.js
+function __assignType$1(fn, args) {
+	fn.__type = args;
+	return fn;
+}
+/**
+* Create a buffer of the given size (uninitialized, so it may contain random data).
+*
+* Note that the result is either Uin8Array or Buffer, depending on the environment.
+* Buffer from NodeJS works slightly different than Uint8Array.
+*/
+const createBuffer = "undefined" !== typeof Buffer && "function" === typeof Buffer.allocUnsafe ? Buffer.allocUnsafe : __assignType$1((size) => new Uint8Array(size), [
+	"size",
+	"",
+	"P\"2!\"/\""
+]);
+/**
+* Concat multiple buffers into one.
+*/
+function bufferConcat(chunks, length) {
+	if (void 0 === length) {
+		length = 0;
+		for (const chunk of chunks) length += chunk.length;
+	}
+	const result = createBuffer(length);
+	let offset = 0;
+	for (const chunk of chunks) {
+		result.set(chunk, offset);
+		offset += chunk.length;
+	}
+	return result;
+}
+bufferConcat.__type = [
+	"chunks",
+	"length",
+	"bufferConcat",
+	"PWF2!'2\"8W/#"
+];
+const textEncoder = new TextDecoder();
+const uint8ArrayToUtf8 = "undefined" !== typeof Buffer ? __assignType$1((buffer) => Buffer.from(buffer).toString("utf8"), [
+	"buffer",
+	"",
+	"PW2!\"/\""
+]) : __assignType$1((buffer) => textEncoder.decode(buffer), [
+	"buffer",
+	"",
+	"PW2!\"/\""
+]);
+/**
+* Convert a buffer to a string.
+*/
+function bufferToString(buffer) {
+	if ("string" === typeof buffer) return buffer;
+	return uint8ArrayToUtf8(buffer);
+}
+bufferToString.__type = [
+	"buffer",
+	"bufferToString",
+	"PP&WJ2!&/\""
+];
+function nativeBase64ToUint8Array(base64) {
+	const raw = atob(base64);
+	const rawLength = raw.length;
+	const array = createBuffer(rawLength);
+	for (let i = 0; i < rawLength; i++) array[i] = raw.charCodeAt(i);
+	return array;
+}
+nativeBase64ToUint8Array.__type = [
+	"base64",
+	"nativeBase64ToUint8Array",
+	"P&2!W/\""
+];
+/**
+* Converts a base64 string to a Uint8Array.
+*/
+const base64ToUint8Array = "undefined" === typeof Buffer ? nativeBase64ToUint8Array : __assignType$1((base64) => Buffer.from(base64, "base64"), [
+	"base64",
+	"",
+	"P&2!\"/\""
+]);
+
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+core@1.0.5_patch_hash=8c3beca4372c6a8941162780ddd0f977ef3d461c2018f0809f86f416260ba440/node_modules/@deepkit/core/dist/esm/src/path.js
+function __assignType(fn, args) {
+	fn.__type = args;
+	return fn;
+}
+/**
+* Normalizes the given path.
+* Removes duplicate slashes, removes trailing slashes, adds a leading slash.
+*/
+function pathNormalize(path) {
+	path = path[0] !== "/" ? "/" + path : path;
+	path = path.length > 1 && path[path.length - 1] === "/" ? path.slice(0, -1) : path;
+	return path.replace(/\/+/g, "/");
+}
+pathNormalize.__type = [
+	"path",
+	"pathNormalize",
+	"P&2!&/\""
+];
+/**
+* Returns the directory (dirname) of the given path.
+*/
+function pathDirectory(path) {
+	if (path === "/") return "/";
+	const lastSlash = path.lastIndexOf("/");
+	return lastSlash <= 0 ? "/" : path.slice(0, lastSlash);
+}
+pathDirectory.__type = [
+	"path",
+	"pathDirectory",
+	"P&2!&/\""
+];
+/**
+* Returns the basename of the given path.
+*/
+function pathBasename(path) {
+	const lastSlash = path.lastIndexOf("/");
+	return lastSlash === -1 ? path : path.slice(lastSlash + 1);
+}
+pathBasename.__type = [
+	"path",
+	"pathBasename",
+	"P&2!&/\""
+];
+/**
+* Returns the extension of the given path.
+*/
+function pathExtension(path) {
+	const basename = pathBasename(path);
+	const lastDot = basename.lastIndexOf(".");
+	return lastDot === -1 ? "" : basename.slice(lastDot + 1);
+}
+pathExtension.__type = [
+	"path",
+	"pathExtension",
+	"P&2!&/\""
+];
+function pathJoin(...paths) {
+	return "/" + paths.map(__assignType((v) => pathNormalize(v).slice(1), [
+		"v",
+		"",
+		"P\"2!\"/\""
+	])).filter(__assignType((v) => !!v, [
+		"v",
+		"",
+		"P\"2!\"/\""
+	])).join("/");
+}
+pathJoin.__type = [
+	"paths",
+	"pathJoin",
+	"P&@2!&/\""
+];
+
+//#endregion
+export { AsyncEventEmitter, AsyncFunction, CompilerContext, CustomError, EmitterEvent, EventEmitter, Mutex, ParsedHost, ProcessLock, ProcessLocker, Timer, __ΩAbstractClassType, __ΩAsyncEventSubscription, __ΩClassType, __ΩCustomError, __ΩEventSubscription, __ΩExtractClassType, __ΩInject, __ΩInjectMeta, __ΩTypeAnnotation, appendObject, applyDefaults, arrayClear, arrayHasItem, arrayMoveItem, arrayRemoveItem, assertDefined, assertInstanceOf, asyncOperation, average, base64ToUint8Array, bufferConcat, bufferToString, bufferedGate, capitalize, changeClass, clearTick, collectForMicrotask, copy, createBuffer, createDynamicClass, createStack, deletePathValue, each, eachKey, eachPair, empty, ensureError, escapeRegExp, extractMethodBody, extractParameters, first, firstKey, fixAsyncOperation, formatError, forwardTypeArguments, getClassName, getClassPropertyName, getClassTypeFromInstance, getCurrentFileName, getEnumKeyLabelMap, getEnumLabel, getEnumLabels, getEnumValues, getInheritanceChain, getObjectKeysSize, getParentClass, getPathValue, getValidEnumValue, hasProperty, humanBytes, identifyType, inDebugMode, indent, indexOf, isArray, isAsyncFunction, isClass, isClassInstance, isConstructable, isFunction, isGlobalClass, isInteger, isIterable, isNull, isNumber, isNumeric, isObject, isObjectLiteral, isPlainObject, isPromise, isPrototypeOfBase, isSet, isString, isUndefined, isValidEnumValue, iterableSize, last, lastKey, log, mergePromiseStack, mergeStack, nativeBase64ToUint8Array, nextTick, parseHost, pathBasename, pathDirectory, pathExtension, pathJoin, pathNormalize, prependObjectKeys, prettyPrintObject, range, rangeArray, removeStrings, setPathValue, singleStack, size, sleep, stack, stringifyValueWithType, throttleTime, time, toFastProperties, uint8ArrayToUtf8, urlJoin, zip };