@powerlines/deepkit 0.6.167 → 0.7.0

package/dist/vendor/core.cjs

@@ -1,516 +1,1243 @@
-'use strict';
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_string = require('./string-BoXo0wS7.cjs');
 
-var chunkEPQZMVJO_cjs = require('./chunk-EPQZMVJO.cjs');
-var chunkIFK6AU6M_cjs = require('./chunk-IFK6AU6M.cjs');
+//#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(require_string.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;
+				require_string.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;
+				require_string.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\"/!"];
 
-// src/vendor/core.ts
-chunkIFK6AU6M_cjs.init_cjs_shims();
+//#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 require_string.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#\"/$"
+];
 
-Object.defineProperty(exports, "AsyncEventEmitter", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.AsyncEventEmitter; }
-});
-Object.defineProperty(exports, "AsyncFunction", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.AsyncFunction; }
-});
-Object.defineProperty(exports, "CompilerContext", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.CompilerContext; }
-});
-Object.defineProperty(exports, "CustomError", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.CustomError; }
-});
-Object.defineProperty(exports, "EmitterEvent", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.EmitterEvent; }
-});
-Object.defineProperty(exports, "EventEmitter", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.EventEmitter; }
-});
-Object.defineProperty(exports, "Mutex", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.Mutex; }
-});
-Object.defineProperty(exports, "ParsedHost", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.ParsedHost; }
-});
-Object.defineProperty(exports, "ProcessLock", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.ProcessLock; }
-});
-Object.defineProperty(exports, "ProcessLocker", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.ProcessLocker; }
-});
-Object.defineProperty(exports, "Timer", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.Timer; }
-});
-Object.defineProperty(exports, "__ΩAbstractClassType", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.__ΩAbstractClassType; }
-});
-Object.defineProperty(exports, "__ΩAsyncEventSubscription", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.__ΩAsyncEventSubscription; }
-});
-Object.defineProperty(exports, "__ΩClassType", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.__ΩClassType; }
-});
-Object.defineProperty(exports, "__ΩCustomError", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.__ΩCustomError; }
-});
-Object.defineProperty(exports, "__ΩEventSubscription", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.__ΩEventSubscription; }
-});
-Object.defineProperty(exports, "__ΩExtractClassType", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.__ΩExtractClassType; }
-});
-Object.defineProperty(exports, "__ΩInject", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.__ΩInject; }
-});
-Object.defineProperty(exports, "__ΩInjectMeta", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.__ΩInjectMeta; }
-});
-Object.defineProperty(exports, "__ΩTypeAnnotation", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.__ΩTypeAnnotation; }
-});
-Object.defineProperty(exports, "appendObject", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.appendObject; }
-});
-Object.defineProperty(exports, "applyDefaults", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.applyDefaults; }
-});
-Object.defineProperty(exports, "arrayClear", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.arrayClear; }
-});
-Object.defineProperty(exports, "arrayHasItem", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.arrayHasItem; }
-});
-Object.defineProperty(exports, "arrayMoveItem", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.arrayMoveItem; }
-});
-Object.defineProperty(exports, "arrayRemoveItem", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.arrayRemoveItem; }
-});
-Object.defineProperty(exports, "assertDefined", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.assertDefined; }
-});
-Object.defineProperty(exports, "assertInstanceOf", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.assertInstanceOf; }
-});
-Object.defineProperty(exports, "asyncOperation", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.asyncOperation; }
-});
-Object.defineProperty(exports, "average", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.average; }
-});
-Object.defineProperty(exports, "base64ToUint8Array", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.base64ToUint8Array; }
-});
-Object.defineProperty(exports, "bufferConcat", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.bufferConcat; }
-});
-Object.defineProperty(exports, "bufferToString", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.bufferToString; }
-});
-Object.defineProperty(exports, "bufferedGate", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.bufferedGate; }
-});
-Object.defineProperty(exports, "capitalize", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.capitalize; }
-});
-Object.defineProperty(exports, "changeClass", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.changeClass; }
-});
-Object.defineProperty(exports, "clearTick", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.clearTick; }
-});
-Object.defineProperty(exports, "collectForMicrotask", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.collectForMicrotask; }
-});
-Object.defineProperty(exports, "copy", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.copy; }
-});
-Object.defineProperty(exports, "createBuffer", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.createBuffer; }
-});
-Object.defineProperty(exports, "createDynamicClass", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.createDynamicClass; }
-});
-Object.defineProperty(exports, "createStack", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.createStack; }
-});
-Object.defineProperty(exports, "deletePathValue", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.deletePathValue; }
-});
-Object.defineProperty(exports, "each", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.each; }
-});
-Object.defineProperty(exports, "eachKey", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.eachKey; }
-});
-Object.defineProperty(exports, "eachPair", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.eachPair; }
-});
-Object.defineProperty(exports, "empty", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.empty; }
-});
-Object.defineProperty(exports, "ensureError", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.ensureError; }
-});
-Object.defineProperty(exports, "escapeRegExp", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.escapeRegExp; }
-});
-Object.defineProperty(exports, "extractMethodBody", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.extractMethodBody; }
-});
-Object.defineProperty(exports, "extractParameters", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.extractParameters; }
-});
-Object.defineProperty(exports, "first", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.first; }
-});
-Object.defineProperty(exports, "firstKey", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.firstKey; }
-});
-Object.defineProperty(exports, "fixAsyncOperation", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.fixAsyncOperation; }
-});
-Object.defineProperty(exports, "formatError", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.formatError; }
-});
-Object.defineProperty(exports, "forwardTypeArguments", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.forwardTypeArguments; }
-});
-Object.defineProperty(exports, "getClassName", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.getClassName; }
-});
-Object.defineProperty(exports, "getClassPropertyName", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.getClassPropertyName; }
-});
-Object.defineProperty(exports, "getClassTypeFromInstance", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.getClassTypeFromInstance; }
-});
-Object.defineProperty(exports, "getCurrentFileName", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.getCurrentFileName; }
-});
-Object.defineProperty(exports, "getEnumKeyLabelMap", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.getEnumKeyLabelMap; }
-});
-Object.defineProperty(exports, "getEnumLabel", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.getEnumLabel; }
-});
-Object.defineProperty(exports, "getEnumLabels", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.getEnumLabels; }
-});
-Object.defineProperty(exports, "getEnumValues", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.getEnumValues; }
-});
-Object.defineProperty(exports, "getInheritanceChain", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.getInheritanceChain; }
-});
-Object.defineProperty(exports, "getObjectKeysSize", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.getObjectKeysSize; }
-});
-Object.defineProperty(exports, "getParentClass", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.getParentClass; }
-});
-Object.defineProperty(exports, "getPathValue", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.getPathValue; }
-});
-Object.defineProperty(exports, "getValidEnumValue", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.getValidEnumValue; }
-});
-Object.defineProperty(exports, "hasProperty", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.hasProperty; }
-});
-Object.defineProperty(exports, "humanBytes", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.humanBytes; }
-});
-Object.defineProperty(exports, "identifyType", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.identifyType; }
-});
-Object.defineProperty(exports, "inDebugMode", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.inDebugMode; }
-});
-Object.defineProperty(exports, "indent", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.indent; }
-});
-Object.defineProperty(exports, "indexOf", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.indexOf; }
-});
-Object.defineProperty(exports, "isArray", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.isArray; }
-});
-Object.defineProperty(exports, "isAsyncFunction", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.isAsyncFunction; }
-});
-Object.defineProperty(exports, "isClass", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.isClass; }
-});
-Object.defineProperty(exports, "isClassInstance", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.isClassInstance; }
-});
-Object.defineProperty(exports, "isConstructable", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.isConstructable; }
-});
-Object.defineProperty(exports, "isFunction", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.isFunction; }
-});
-Object.defineProperty(exports, "isGlobalClass", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.isGlobalClass; }
-});
-Object.defineProperty(exports, "isInteger", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.isInteger; }
-});
-Object.defineProperty(exports, "isIterable", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.isIterable; }
-});
-Object.defineProperty(exports, "isNull", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.isNull; }
-});
-Object.defineProperty(exports, "isNumber", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.isNumber; }
-});
-Object.defineProperty(exports, "isNumeric", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.isNumeric; }
-});
-Object.defineProperty(exports, "isObject", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.isObject; }
-});
-Object.defineProperty(exports, "isObjectLiteral", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.isObjectLiteral; }
-});
-Object.defineProperty(exports, "isPlainObject", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.isPlainObject; }
-});
-Object.defineProperty(exports, "isPromise", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.isPromise; }
-});
-Object.defineProperty(exports, "isPrototypeOfBase", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.isPrototypeOfBase; }
-});
-Object.defineProperty(exports, "isSet", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.isSet; }
-});
-Object.defineProperty(exports, "isString", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.isString; }
-});
-Object.defineProperty(exports, "isUndefined", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.isUndefined; }
-});
-Object.defineProperty(exports, "isValidEnumValue", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.isValidEnumValue; }
-});
-Object.defineProperty(exports, "iterableSize", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.iterableSize; }
-});
-Object.defineProperty(exports, "last", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.last; }
-});
-Object.defineProperty(exports, "lastKey", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.lastKey; }
-});
-Object.defineProperty(exports, "log", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.log; }
-});
-Object.defineProperty(exports, "mergePromiseStack", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.mergePromiseStack; }
-});
-Object.defineProperty(exports, "mergeStack", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.mergeStack; }
-});
-Object.defineProperty(exports, "nativeBase64ToUint8Array", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.nativeBase64ToUint8Array; }
-});
-Object.defineProperty(exports, "nextTick", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.nextTick; }
-});
-Object.defineProperty(exports, "parseHost", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.parseHost; }
-});
-Object.defineProperty(exports, "pathBasename", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.pathBasename; }
-});
-Object.defineProperty(exports, "pathDirectory", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.pathDirectory; }
-});
-Object.defineProperty(exports, "pathExtension", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.pathExtension; }
-});
-Object.defineProperty(exports, "pathJoin", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.pathJoin; }
-});
-Object.defineProperty(exports, "pathNormalize", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.pathNormalize; }
-});
-Object.defineProperty(exports, "prependObjectKeys", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.prependObjectKeys; }
-});
-Object.defineProperty(exports, "prettyPrintObject", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.prettyPrintObject; }
-});
-Object.defineProperty(exports, "range", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.range; }
-});
-Object.defineProperty(exports, "rangeArray", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.rangeArray; }
-});
-Object.defineProperty(exports, "removeStrings", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.removeStrings; }
-});
-Object.defineProperty(exports, "setPathValue", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.setPathValue; }
-});
-Object.defineProperty(exports, "singleStack", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.singleStack; }
-});
-Object.defineProperty(exports, "size", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.size; }
-});
-Object.defineProperty(exports, "sleep", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.sleep; }
-});
-Object.defineProperty(exports, "stack", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.stack; }
-});
-Object.defineProperty(exports, "stringifyValueWithType", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.stringifyValueWithType; }
-});
-Object.defineProperty(exports, "throttleTime", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.throttleTime; }
-});
-Object.defineProperty(exports, "time", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.time; }
-});
-Object.defineProperty(exports, "toFastProperties", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.toFastProperties; }
-});
-Object.defineProperty(exports, "uint8ArrayToUtf8", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.uint8ArrayToUtf8; }
-});
-Object.defineProperty(exports, "urlJoin", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.urlJoin; }
-});
-Object.defineProperty(exports, "zip", {
-  enumerable: true,
-  get: function () { return chunkEPQZMVJO_cjs.zip; }
-});
+//#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]) require_string.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: () => {
+			require_string.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: () => {
+			require_string.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,
+	() => require_string.__Ω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
+exports.AsyncEventEmitter = AsyncEventEmitter;
+exports.AsyncFunction = require_string.AsyncFunction;
+exports.CompilerContext = require_string.CompilerContext;
+exports.CustomError = require_string.CustomError;
+exports.EmitterEvent = EmitterEvent;
+exports.EventEmitter = EventEmitter;
+exports.Mutex = Mutex;
+exports.ParsedHost = ParsedHost;
+exports.ProcessLock = ProcessLock;
+exports.ProcessLocker = ProcessLocker;
+exports.Timer = Timer;
+exports.__ΩAbstractClassType = require_string.__ΩAbstractClassType;
+exports.__ΩAsyncEventSubscription = __ΩAsyncEventSubscription;
+exports.__ΩClassType = require_string.__ΩClassType;
+exports.__ΩCustomError = require_string.__ΩCustomError;
+exports.__ΩEventSubscription = __ΩEventSubscription;
+exports.__ΩExtractClassType = require_string.__ΩExtractClassType;
+exports.__ΩInject = __ΩInject;
+exports.__ΩInjectMeta = __ΩInjectMeta;
+exports.__ΩTypeAnnotation = __ΩTypeAnnotation;
+exports.appendObject = require_string.appendObject;
+exports.applyDefaults = require_string.applyDefaults;
+exports.arrayClear = require_string.arrayClear;
+exports.arrayHasItem = require_string.arrayHasItem;
+exports.arrayMoveItem = require_string.arrayMoveItem;
+exports.arrayRemoveItem = require_string.arrayRemoveItem;
+exports.assertDefined = require_string.assertDefined;
+exports.assertInstanceOf = require_string.assertInstanceOf;
+exports.asyncOperation = require_string.asyncOperation;
+exports.average = require_string.average;
+exports.base64ToUint8Array = base64ToUint8Array;
+exports.bufferConcat = bufferConcat;
+exports.bufferToString = bufferToString;
+exports.bufferedGate = bufferedGate;
+exports.capitalize = require_string.capitalize;
+exports.changeClass = require_string.changeClass;
+exports.clearTick = clearTick;
+exports.collectForMicrotask = require_string.collectForMicrotask;
+exports.copy = require_string.copy;
+exports.createBuffer = createBuffer;
+exports.createDynamicClass = require_string.createDynamicClass;
+exports.createStack = require_string.createStack;
+exports.deletePathValue = require_string.deletePathValue;
+exports.each = require_string.each;
+exports.eachKey = require_string.eachKey;
+exports.eachPair = require_string.eachPair;
+exports.empty = require_string.empty;
+exports.ensureError = require_string.ensureError;
+exports.escapeRegExp = require_string.escapeRegExp;
+exports.extractMethodBody = extractMethodBody;
+exports.extractParameters = extractParameters;
+exports.first = require_string.first;
+exports.firstKey = require_string.firstKey;
+exports.fixAsyncOperation = require_string.fixAsyncOperation;
+exports.formatError = require_string.formatError;
+exports.forwardTypeArguments = require_string.forwardTypeArguments;
+exports.getClassName = require_string.getClassName;
+exports.getClassPropertyName = require_string.getClassPropertyName;
+exports.getClassTypeFromInstance = require_string.getClassTypeFromInstance;
+exports.getCurrentFileName = require_string.getCurrentFileName;
+exports.getEnumKeyLabelMap = getEnumKeyLabelMap;
+exports.getEnumLabel = getEnumLabel;
+exports.getEnumLabels = getEnumLabels;
+exports.getEnumValues = getEnumValues;
+exports.getInheritanceChain = require_string.getInheritanceChain;
+exports.getObjectKeysSize = require_string.getObjectKeysSize;
+exports.getParentClass = require_string.getParentClass;
+exports.getPathValue = require_string.getPathValue;
+exports.getValidEnumValue = getValidEnumValue;
+exports.hasProperty = require_string.hasProperty;
+exports.humanBytes = require_string.humanBytes;
+exports.identifyType = require_string.identifyType;
+exports.inDebugMode = require_string.inDebugMode;
+exports.indent = require_string.indent;
+exports.indexOf = require_string.indexOf;
+exports.isArray = require_string.isArray;
+exports.isAsyncFunction = require_string.isAsyncFunction;
+exports.isClass = require_string.isClass;
+exports.isClassInstance = require_string.isClassInstance;
+exports.isConstructable = require_string.isConstructable;
+exports.isFunction = require_string.isFunction;
+exports.isGlobalClass = require_string.isGlobalClass;
+exports.isInteger = require_string.isInteger;
+exports.isIterable = require_string.isIterable;
+exports.isNull = require_string.isNull;
+exports.isNumber = require_string.isNumber;
+exports.isNumeric = require_string.isNumeric;
+exports.isObject = require_string.isObject;
+exports.isObjectLiteral = require_string.isObjectLiteral;
+exports.isPlainObject = require_string.isPlainObject;
+exports.isPromise = require_string.isPromise;
+exports.isPrototypeOfBase = require_string.isPrototypeOfBase;
+exports.isSet = require_string.isSet;
+exports.isString = require_string.isString;
+exports.isUndefined = require_string.isUndefined;
+exports.isValidEnumValue = isValidEnumValue;
+exports.iterableSize = require_string.iterableSize;
+exports.last = require_string.last;
+exports.lastKey = require_string.lastKey;
+exports.log = log;
+exports.mergePromiseStack = require_string.mergePromiseStack;
+exports.mergeStack = require_string.mergeStack;
+exports.nativeBase64ToUint8Array = nativeBase64ToUint8Array;
+exports.nextTick = nextTick;
+exports.parseHost = parseHost;
+exports.pathBasename = pathBasename;
+exports.pathDirectory = pathDirectory;
+exports.pathExtension = pathExtension;
+exports.pathJoin = pathJoin;
+exports.pathNormalize = pathNormalize;
+exports.prependObjectKeys = require_string.prependObjectKeys;
+exports.prettyPrintObject = require_string.prettyPrintObject;
+exports.range = require_string.range;
+exports.rangeArray = require_string.rangeArray;
+exports.removeStrings = removeStrings;
+exports.setPathValue = require_string.setPathValue;
+exports.singleStack = singleStack;
+exports.size = require_string.size;
+exports.sleep = require_string.sleep;
+exports.stack = stack;
+exports.stringifyValueWithType = require_string.stringifyValueWithType;
+exports.throttleTime = throttleTime;
+exports.time = require_string.time;
+exports.toFastProperties = require_string.toFastProperties;
+exports.uint8ArrayToUtf8 = uint8ArrayToUtf8;
+exports.urlJoin = urlJoin;
+exports.zip = require_string.zip;