@powerlines/deepkit 0.6.166 → 0.7.0

package/dist/vendor/string-BuMgdahD.mjs

@@ -0,0 +1,2467 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+//#region ../../node_modules/.pnpm/is-obj@2.0.0/node_modules/is-obj/index.js
+var require_is_obj = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = (value) => {
+		const type = typeof value;
+		return value !== null && (type === "object" || type === "function");
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/dot-prop@5.3.0/node_modules/dot-prop/index.js
+var require_dot_prop = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const isObj = require_is_obj();
+	const disallowedKeys = [
+		"__proto__",
+		"prototype",
+		"constructor"
+	];
+	const isValidPath = (pathSegments) => !pathSegments.some((segment) => disallowedKeys.includes(segment));
+	function getPathSegments(path) {
+		const pathArray = path.split(".");
+		const parts = [];
+		for (let i = 0; i < pathArray.length; i++) {
+			let p = pathArray[i];
+			while (p[p.length - 1] === "\\" && pathArray[i + 1] !== void 0) {
+				p = p.slice(0, -1) + ".";
+				p += pathArray[++i];
+			}
+			parts.push(p);
+		}
+		if (!isValidPath(parts)) return [];
+		return parts;
+	}
+	module.exports = {
+		get(object, path, value) {
+			if (!isObj(object) || typeof path !== "string") return value === void 0 ? object : value;
+			const pathArray = getPathSegments(path);
+			if (pathArray.length === 0) return;
+			for (let i = 0; i < pathArray.length; i++) {
+				if (!Object.prototype.propertyIsEnumerable.call(object, pathArray[i])) return value;
+				object = object[pathArray[i]];
+				if (object === void 0 || object === null) {
+					if (i !== pathArray.length - 1) return value;
+					break;
+				}
+			}
+			return object;
+		},
+		set(object, path, value) {
+			if (!isObj(object) || typeof path !== "string") return object;
+			const root = object;
+			const pathArray = getPathSegments(path);
+			for (let i = 0; i < pathArray.length; i++) {
+				const p = pathArray[i];
+				if (!isObj(object[p])) object[p] = {};
+				if (i === pathArray.length - 1) object[p] = value;
+				object = object[p];
+			}
+			return root;
+		},
+		delete(object, path) {
+			if (!isObj(object) || typeof path !== "string") return false;
+			const pathArray = getPathSegments(path);
+			for (let i = 0; i < pathArray.length; i++) {
+				const p = pathArray[i];
+				if (i === pathArray.length - 1) {
+					delete object[p];
+					return true;
+				}
+				object = object[p];
+				if (!isObj(object)) return false;
+			}
+		},
+		has(object, path) {
+			if (!isObj(object) || typeof path !== "string") return false;
+			const pathArray = getPathSegments(path);
+			if (pathArray.length === 0) return false;
+			for (let i = 0; i < pathArray.length; i++) if (isObj(object)) {
+				if (!(pathArray[i] in object)) return false;
+				object = object[pathArray[i]];
+			} else return false;
+			return true;
+		}
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+core@1.0.5_patch_hash=8c3beca4372c6a8941162780ddd0f977ef3d461c2018f0809f86f416260ba440/node_modules/@deepkit/core/dist/esm/src/iterators.js
+const __ΩArrayLike = [
+	"T",
+	"length",
+	"ArrayLike",
+	"b!P'4\"9'e\"!LMw#y"
+];
+const __ΩIterableIterator$1 = [
+	"T",
+	"TReturn",
+	"TNext",
+	() => __ΩIterator$1,
+	0,
+	() => Symbol.iterator,
+	"IterableIterator",
+	"b!\"c\"\"c#Pe\"!e\"\"e\"#o$$Pe#!e#\"e##o%$1&Mw'y"
+];
+const __ΩIterator$1 = [
+	"T",
+	"TReturn",
+	"TNext",
+	"param0",
+	() => __ΩIteratorResult$1,
+	"next",
+	"value",
+	() => __ΩIteratorResult$1,
+	"return",
+	"e",
+	() => __ΩIteratorResult$1,
+	"throw",
+	"Iterator",
+	"b!\"c\"\"c#PPPPGPe%#GJ@2$e#!e#\"o%#1&Pe#\"2'8e#!e#\"o(#1)P\"2*8e#!e#\"o+#1,Mw-y"
+];
+const __ΩIteratorResult$1 = [
+	"T",
+	"TReturn",
+	() => __ΩIteratorYieldResult$1,
+	() => __ΩIteratorReturnResult$1,
+	"IteratorResult",
+	"b!\"c\"Pe\"!o#\"e\"\"o$\"Jw%y"
+];
+const __ΩIteratorYieldResult$1 = [
+	"TYield",
+	false,
+	"done",
+	"value",
+	"IteratorYieldResult",
+	"b!P.\"4#8e\"!4$Mw%y"
+];
+const __ΩIteratorReturnResult$1 = [
+	"TReturn",
+	true,
+	"done",
+	"value",
+	"IteratorReturnResult",
+	"b!P.\"4#e\"!4$Mw%y"
+];
+eachKey.__type = [
+	() => __ΩArrayLike,
+	"object",
+	() => __ΩIterableIterator$1,
+	"eachKey",
+	"P\"o!\"2\"'o#\"/$"
+];
+eachKey.__type = [
+	"object",
+	() => __ΩIterableIterator$1,
+	"eachKey",
+	"P\"2!&o\"\"/#"
+];
+/** @public */
+function* eachKey(object) {
+	if (Array.isArray(object)) for (let i = 0; i < object.length; i++) yield i;
+	else for (const i in object) if (object.hasOwnProperty(i)) yield i;
+}
+eachKey.__type = [
+	() => __ΩArrayLike,
+	"object",
+	() => __ΩIterableIterator$1,
+	"eachKey",
+	"PP\"\"o!\"J2\"P&'Jo#\"/$"
+];
+/**
+* Iterator for each value of an array or object.
+*
+* @example
+* ```
+* for (const v of each(['a', 'b']) {
+*    console.log(v); //a, b
+* }
+* ```
+*
+* @public
+* @category iterator
+*/
+function* each(object) {
+	if (Array.isArray(object)) for (let i = 0; i < object.length; i++) yield object[i];
+	else for (const i in object) if (object.hasOwnProperty(i)) yield object[i];
+}
+each.__type = [
+	() => __ΩArrayLike,
+	"object",
+	() => __ΩIterableIterator$1,
+	"each",
+	"PPP&\"LM\"o!\"J2\"\"o#\"/$"
+];
+eachPair.__type = [
+	() => __ΩArrayLike,
+	"object",
+	() => __ΩIterableIterator$1,
+	"eachPair",
+	"P\"o!\"2\"P'\"Go#\"/$"
+];
+eachPair.__type = [
+	"object",
+	() => __ΩIterableIterator$1,
+	"eachPair",
+	"PP&\"LM2!P&\"Go\"\"/#"
+];
+/** @public */
+function* eachPair(object) {
+	if (Array.isArray(object)) for (let i = 0; i < object.length; i++) yield [i, object[i]];
+	else for (const i in object) if (object.hasOwnProperty(i)) yield [i, object[i]];
+}
+eachPair.__type = [
+	() => __ΩArrayLike,
+	"object",
+	() => __ΩIterableIterator$1,
+	"eachPair",
+	"PPP&\"LM\"o!\"J2\"PP&\"GP'\"GJo#\"/$"
+];
+
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+core@1.0.5_patch_hash=8c3beca4372c6a8941162780ddd0f977ef3d461c2018f0809f86f416260ba440/node_modules/@deepkit/core/dist/esm/src/core.js
+var import_dot_prop = /* @__PURE__ */ __toESM(require_dot_prop(), 1);
+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 __ΩError = [
+	"name",
+	"message",
+	"stack",
+	"Error",
+	"P&4!&4\"&4#8Mw$y"
+];
+const __ΩIterableIterator = [
+	"T",
+	"TReturn",
+	"TNext",
+	() => __ΩIterator,
+	0,
+	() => Symbol.iterator,
+	"IterableIterator",
+	"b!\"c\"\"c#Pe\"!e\"\"e\"#o$$Pe#!e#\"e##o%$1&Mw'y"
+];
+const __ΩPropertyKey = ["PropertyKey", "P&'+Jw!y"];
+const __ΩIterator = [
+	"T",
+	"TReturn",
+	"TNext",
+	"param0",
+	() => __ΩIteratorResult,
+	"next",
+	"value",
+	() => __ΩIteratorResult,
+	"return",
+	"e",
+	() => __ΩIteratorResult,
+	"throw",
+	"Iterator",
+	"b!\"c\"\"c#PPPPGPe%#GJ@2$e#!e#\"o%#1&Pe#\"2'8e#!e#\"o(#1)P\"2*8e#!e#\"o+#1,Mw-y"
+];
+const __ΩIteratorResult = [
+	"T",
+	"TReturn",
+	() => __ΩIteratorYieldResult,
+	() => __ΩIteratorReturnResult,
+	"IteratorResult",
+	"b!\"c\"Pe\"!o#\"e\"\"o$\"Jw%y"
+];
+const __ΩIteratorYieldResult = [
+	"TYield",
+	false,
+	"done",
+	"value",
+	"IteratorYieldResult",
+	"b!P.\"4#8e\"!4$Mw%y"
+];
+const __ΩIteratorReturnResult = [
+	"TReturn",
+	true,
+	"done",
+	"value",
+	"IteratorReturnResult",
+	"b!P.\"4#e\"!4$Mw%y"
+];
+function __assignType$2(fn, args) {
+	fn.__type = args;
+	return fn;
+}
+/**
+* Makes sure the error once printed using console.log contains the actual class name.
+*
+* @example
+* ```
+* class MyApiError extends CustomerError {}
+*
+* throw MyApiError() // prints MyApiError instead of simply "Error".
+* ```
+*
+* @public
+*/
+var CustomError = class extends Error {
+	constructor(...args) {
+		super(...args);
+		this.name = this.constructor.name;
+	}
+};
+CustomError.__type = [
+	() => Error,
+	"name",
+	"args",
+	"constructor",
+	"CustomError",
+	"P7!&3\"P\"@2#\"0$5w%"
+];
+const __ΩCustomError = [
+	"cause",
+	"CustomError",
+	"P#4!8Mw\"y"
+];
+const __ΩClassType = [
+	"T",
+	"args",
+	"new",
+	"ClassType",
+	"\"c!PP\"@2\"e#!1#Mw$y"
+];
+const __ΩAbstractClassType = [
+	"T",
+	"args",
+	"new",
+	"AbstractClassType",
+	"\"c!P\"@2\"e\"!/#w$y"
+];
+const __ΩExtractClassType = [
+	"T",
+	() => __ΩAbstractClassType,
+	"ExtractClassType",
+	"l:e\"!R!RPde#!h!!o\"\"qk#'QRb!Pde\"!p)w#y"
+];
+/**
+* Returns the class name either of the class definition or of the class of an instance.
+*
+* Note when code is minimized/uglified this output will change. You should disable in your compile the
+* className modification.
+*
+* @example
+* ```typescript
+* class User {}
+*
+* expect(getClassName(User)).toBe('User');
+* expect(getClassName(new User())).toBe('User');
+* ```
+*
+* @public
+*/
+function getClassName(classTypeOrInstance) {
+	if (!classTypeOrInstance) return "undefined";
+	return (classTypeOrInstance["prototype"] ? classTypeOrInstance["prototype"] : classTypeOrInstance).constructor.name || "anonymous class";
+}
+getClassName.__type = [
+	() => __ΩClassType,
+	() => __ΩObject,
+	"classTypeOrInstance",
+	"getClassName",
+	"PP\"o!\"n\"J2#&/$"
+];
+/**
+* Same as getClassName but appends the propertyName.
+* @public
+*/
+function getClassPropertyName(classType, propertyName) {
+	return `${getClassName(classType)}.${propertyName}`;
+}
+getClassPropertyName.__type = [
+	() => __ΩClassType,
+	() => __ΩObject,
+	"classType",
+	"propertyName",
+	"getClassPropertyName",
+	"PP\"o!\"n\"J2#&2$&/%"
+];
+/**
+* @public
+*/
+function applyDefaults(classType, target) {
+	const classInstance = new classType();
+	for (const [i, v] of eachPair(target)) classInstance[i] = v;
+	return classInstance;
+}
+applyDefaults.__type = [
+	() => __ΩClassType,
+	"classType",
+	"target",
+	"applyDefaults",
+	"P\"o!\"2\"P&\"LM2#\"/$"
+];
+/**
+* Tries to identify the object by normalised result of Object.toString(obj).
+*/
+function identifyType(obj) {
+	return (({}.toString.call(obj).match(/\s([a-zA-Z]+)/) || [])[1] || "").toLowerCase();
+}
+identifyType.__type = [
+	"obj",
+	"identifyType",
+	"P\"2!\"/\""
+];
+/**
+* Returns true if the given obj is a plain object, and no class instance.
+*
+* isPlainObject(\{\}) === true
+* isPlainObject(new ClassXY) === false
+*
+* @public
+*/
+function isPlainObject(obj) {
+	return Boolean(obj && typeof obj === "object" && obj.constructor instanceof obj.constructor);
+}
+isPlainObject.__type = [
+	"obj",
+	"isPlainObject",
+	"P\"2!!/\""
+];
+/**
+* Returns the ClassType for a given instance.
+*/
+function getClassTypeFromInstance(target) {
+	if (!isClassInstance(target)) throw new Error(`Value is not a class instance. Got ${stringifyValueWithType(target)}`);
+	return target["constructor"];
+}
+getClassTypeFromInstance.__type = [
+	"target",
+	() => __ΩClassType,
+	"getClassTypeFromInstance",
+	"P\"2!\"o\"\"/#"
+];
+/**
+* Returns true when target is a class instance.
+*/
+function isClassInstance(target) {
+	return target !== void 0 && target !== null && target["constructor"] && Object.getPrototypeOf(target) === target["constructor"].prototype && !isPlainObject(target) && isObject(target);
+}
+isClassInstance.__type = [
+	"target",
+	"isClassInstance",
+	"P\"2!)/\""
+];
+/**
+* Returns a human-readable string representation from the given value.
+*/
+function stringifyValueWithType(value, depth = 0) {
+	if ("string" === typeof value) return `string(${value})`;
+	if ("number" === typeof value) return `number(${value})`;
+	if ("boolean" === typeof value) return `boolean(${value})`;
+	if ("bigint" === typeof value) return `bigint(${value})`;
+	if (isPlainObject(value)) return `object ${depth < 2 ? prettyPrintObject(value, depth) : ""}`;
+	if (isArray(value)) return `Array`;
+	if (isClass(value)) return `${getClassName(value)}`;
+	if (isObject(value)) return `${getClassName(getClassTypeFromInstance(value))} ${depth < 2 ? prettyPrintObject(value, depth) : ""}`;
+	if ("function" === typeof value) return `function ${value.name}`;
+	if (null === value) return `null`;
+	return "undefined";
+}
+stringifyValueWithType.__type = [
+	"value",
+	"depth",
+	() => 0,
+	"stringifyValueWithType",
+	"P\"2!'2\">#&/$"
+];
+/**
+* Changes the class of a given instance and returns the new object.
+*
+* @example
+* ```typescript
+*
+*  class Model1 {
+*    id: number = 0;
+*  }
+*
+*  class Model2 {
+*    id: number = 0;
+*  }
+*
+*  const model1 = new Model1();
+*  const model2 = changeClass(model1, Model2);
+*  model2 instanceof Model2; //true
+* ```
+*/
+function changeClass(value, newClass) {
+	return Object.assign(Object.create(newClass.prototype), value);
+}
+changeClass.__type = [
+	"value",
+	() => __ΩClassType,
+	"newClass",
+	"changeClass",
+	"P%2!\"o\"\"2#\"/$"
+];
+function prettyPrintObject(object, depth = 0) {
+	const res = [];
+	for (const i in object) res.push(i + ": " + stringifyValueWithType(object[i], depth + 1));
+	return "{" + res.join(",") + "}";
+}
+prettyPrintObject.__type = [
+	"object",
+	"depth",
+	() => 0,
+	"prettyPrintObject",
+	"P%2!'2\">#&/$"
+];
+/**
+* Returns true if given obj is a function.
+*
+* @public
+*/
+function isFunction(obj) {
+	if ("function" === typeof obj) return !obj.toString().startsWith("class ") && !obj.toString().startsWith("class{");
+	return false;
+}
+isFunction.__type = [
+	"obj",
+	"isFunction",
+	"P\"2!!/\""
+];
+const AsyncFunction = (async () => {}).constructor;
+/**
+* Returns true if given obj is a async function.
+*
+* @public
+*/
+function isAsyncFunction(obj) {
+	return obj instanceof AsyncFunction;
+}
+isAsyncFunction.__type = [
+	"obj",
+	"isAsyncFunction",
+	"P\"2!!/\""
+];
+/**
+* Returns true if given obj is a promise like object.
+*
+* Note: There's not way to check if it's actually a Promise using instanceof since
+* there are a lot of different implementations around.
+*
+* @public
+*/
+function isPromise(obj) {
+	return obj !== null && typeof obj === "object" && typeof obj.then === "function" && typeof obj.catch === "function" && typeof obj.finally === "function";
+}
+isPromise.__type = [
+	"obj",
+	"isPromise",
+	"PP\"\"`J2!!/\""
+];
+/**
+* Returns true if given obj is a ES6 class (ES5 fake classes are not supported).
+*
+* @public
+*/
+function isClass(obj) {
+	if ("function" === typeof obj) return obj.toString().startsWith("class ") || obj.toString().startsWith("class{");
+	return false;
+}
+isClass.__type = [
+	"obj",
+	"isClass",
+	"P\"2!!/\""
+];
+function isGlobalClass(obj) {
+	if ("function" !== typeof obj) return false;
+	if ("undefined" !== typeof window) return window[getClassName(obj)] === obj;
+	if ("undefined" !== typeof global) return global[getClassName(obj)] === obj;
+	return false;
+}
+isGlobalClass.__type = [
+	"obj",
+	"isGlobalClass",
+	"P\"2!!/\""
+];
+/**
+* Returns true for real objects: object literals ({}) or class instances (new MyClass).
+*
+* @public
+*/
+function isObject(obj) {
+	if (obj === null) return false;
+	return typeof obj === "object" && !isArray(obj);
+}
+isObject.__type = [
+	"obj",
+	"isObject",
+	"P\"2!!/\""
+];
+/**
+* Returns true if given obj is a plain object, and no Date, Array, Map, Set, etc.
+*
+* This is different to isObject and used in the type system to differentiate
+* between JS objects in general and what we define as ReflectionKind.objectLiteral.
+* Since we have Date, Set, Map, etc. in the type system, we need to differentiate
+* between them and all other object literals.
+*/
+function isObjectLiteral(obj) {
+	return isObject(obj) && !(obj instanceof Date) && !(obj instanceof Map) && !(obj instanceof Set);
+}
+isObjectLiteral.__type = [
+	"obj",
+	"isObjectLiteral",
+	"P\"2!!/\""
+];
+/**
+* @public
+*/
+const isArray = Array.isArray;
+/**
+* @public
+*/
+function isNull(obj) {
+	return null === obj;
+}
+isNull.__type = [
+	"obj",
+	"isNull",
+	"P\"2!!/\""
+];
+/**
+* @public
+*/
+function isUndefined(obj) {
+	return void 0 === obj;
+}
+isUndefined.__type = [
+	"obj",
+	"isUndefined",
+	"P\"2!!/\""
+];
+/**
+* Checks if obj is not null and not undefined.
+*
+* @public
+*/
+function isSet(obj) {
+	return !isNull(obj) && !isUndefined(obj);
+}
+isSet.__type = [
+	"obj",
+	"isSet",
+	"P\"2!)/\""
+];
+/**
+* @public
+*/
+function isNumber(obj) {
+	return "number" === identifyType(obj);
+}
+isNumber.__type = [
+	"obj",
+	"isNumber",
+	"P\"2!!/\""
+];
+/**
+* Returns true if given value is strictly a numeric string value (or a number).
+*
+* ```typescript
+* isNumeric(12); //true
+* isNumeric('12'); //true
+* isNumeric('12.3'); //true
+* isNumeric('12.3 '); //false
+* isNumeric('12px'); //false
+* ```
+* @public
+*/
+function isNumeric(s) {
+	if ("number" === typeof s) return true;
+	let points = 0;
+	for (let i = s.length - 1; i >= 0; i--) {
+		const d = s.charCodeAt(i);
+		if (d === 46) {
+			if (points++ > 0) return false;
+			continue;
+		}
+		if (d < 48 || d > 57) return false;
+	}
+	return true;
+}
+isNumeric.__type = [
+	"s",
+	"isNumeric",
+	"PP&'J2!)/\""
+];
+const isInteger = Number.isInteger || __assignType$2(function(obj) {
+	return obj % 1 === 0;
+}, [
+	"obj",
+	"",
+	"P\"2!\"/\""
+]);
+/**
+* @public
+*/
+function isString(obj) {
+	return "string" === identifyType(obj);
+}
+isString.__type = [
+	"obj",
+	"isString",
+	"P\"2!!/\""
+];
+/**
+* @public
+*/
+function indexOf(array, item) {
+	if (!array) return -1;
+	return array.indexOf(item);
+}
+indexOf.__type = [
+	"array",
+	"item",
+	"indexOf",
+	"P\"F2!\"2\"'/#"
+];
+/**
+* @public
+*/
+async function sleep(seconds) {
+	return Promise.Ω = [["$"]], new Promise(__assignType$2((resolve) => setTimeout(resolve, seconds * 1e3), [
+		"resolve",
+		"",
+		"P\"2!\"/\""
+	]));
+}
+sleep.__type = [
+	"seconds",
+	"sleep",
+	"P'2!$`/\""
+];
+/**
+* Creates a shallow copy of given array.
+*
+* @public
+*/
+function copy(v) {
+	if (isArray(v)) return v.slice(0);
+	return v;
+}
+copy.__type = [
+	"v",
+	"copy",
+	"P\"F2!\"F/\""
+];
+/**
+* Checks whether given array or object is empty (no keys). If given object is falsy, returns false.
+*
+* @public
+*/
+function empty(value) {
+	if (!value) return true;
+	if (isArray(value)) return value.length === 0;
+	else {
+		for (const i in value) if (value.hasOwnProperty(i)) return false;
+		return true;
+	}
+}
+empty.__type = [
+	"value",
+	"empty",
+	"PP\"F%PMJ2!8)/\""
+];
+/**
+* Returns the size of given array or object.
+*
+* @public
+*/
+function size(array) {
+	if (!array) return 0;
+	if (isArray(array)) return array.length;
+	else return getObjectKeysSize(array);
+}
+size.__type = [
+	"array",
+	"size",
+	"PP\"FP&\"LMJ2!'/\""
+];
+/**
+* Returns the first key of a given object.
+*
+* @public
+*/
+function firstKey(v) {
+	return Object.keys(v)[0];
+}
+firstKey.__type = [
+	"v",
+	"firstKey",
+	"PPP&\"LM%J2!P&-J/\""
+];
+/**
+* Returns the last key of a given object.
+*
+* @public
+*/
+function lastKey(v) {
+	const keys = Object.keys(v);
+	if (keys.length) return;
+	return keys[keys.length - 1];
+}
+lastKey.__type = [
+	"v",
+	"lastKey",
+	"PPP&\"LM%J2!P&-J/\""
+];
+/**
+* Returns the first value of given array or object.
+*
+* @public
+*/
+function first(v) {
+	if (isArray(v)) return v[0];
+	const key = firstKey(v);
+	if (key) return v[key];
+}
+first.__type = [
+	"v",
+	"first",
+	"PPP&\"LM\"FJ2!P\"-J/\""
+];
+/**
+* Returns the last value of given array or object.
+*
+* @public
+*/
+function last(v) {
+	if (isArray(v)) {
+		if (v.length > 0) return v[v.length - 1];
+		return;
+	}
+	const key = firstKey(v);
+	if (key) return v[key];
+}
+last.__type = [
+	"v",
+	"last",
+	"PPP&\"LM\"FJ2!P\"-J/\""
+];
+/**
+* Returns the average of a number array.
+*
+* @public
+*/
+function average(array) {
+	let sum = 0;
+	for (const n of array) sum += n;
+	return sum / array.length;
+}
+average.__type = [
+	"array",
+	"average",
+	"P'F2!'/\""
+];
+/**
+* @public
+*/
+function prependObjectKeys(o, prependText) {
+	const converted = {};
+	for (const i in o) {
+		if (!o.hasOwnProperty(i)) continue;
+		converted[prependText + i] = o[i];
+	}
+	return converted;
+}
+prependObjectKeys.__type = [
+	"o",
+	"prependText",
+	"prependObjectKeys",
+	"PP&\"LM2!&2\"P&\"LM/#"
+];
+/**
+* @public
+*/
+function appendObject(origin, extend, prependKeyName = "") {
+	const no = prependObjectKeys(extend, prependKeyName);
+	for (const [i, v] of eachPair(no)) origin[i] = v;
+}
+appendObject.__type = [
+	"origin",
+	"extend",
+	"prependKeyName",
+	() => "",
+	"appendObject",
+	"PP&\"LM2!P&\"LM2\"&2#>$\"/%"
+];
+/**
+* A better alternative to "new Promise()" that supports error handling and maintains the stack trace for Error.stack.
+*
+* When you use `new Promise()` you need to wrap your code inside a try-catch to call `reject` on error.
+* asyncOperation() does this automatically.
+*
+* When you use `new Promise()` you will lose the stack trace when `reject(new Error())` is called.
+* asyncOperation() makes sure the error stack trace is the correct one.
+*
+* @example
+* ```typescript
+* await asyncOperation(async (resolve, reject) => {
+*     await doSomething(); //if this fails, reject() will automatically be called
+*     stream.on('data', (data) => {
+*         resolve(data); //at some point you MUST call resolve(data)
+*     });
+* });
+* ```
+*
+* @public
+* @reflection never
+*/
+async function asyncOperation(executor) {
+	try {
+		return await (Promise.Ω = [void 0], new Promise(async (resolve, reject) => {
+			try {
+				await executor(resolve, reject);
+			} catch (e) {
+				reject(e);
+			}
+		}));
+	} catch (error) {
+		mergeStack(error, createStack());
+		throw error;
+	}
+}
+/**
+* When an API is called that returns a promise that loses the stack trace on error, you can use fixAsyncOperation().
+*
+* ```typescript
+* cons storage = new BrokenPromiseStorage();
+* const files = await fixAsyncOperation(storage.files('/'));
+* ```
+*/
+function fixAsyncOperation(promise) {
+	return asyncOperation(__assignType$2(async (resolve, reject) => {
+		resolve(await promise);
+	}, [
+		"resolve",
+		"reject",
+		"",
+		"P\"2!\"2\"\"/#"
+	]));
+}
+fixAsyncOperation.__type = [
+	"promise",
+	"fixAsyncOperation",
+	"P\"`2!\"`/\""
+];
+/**
+* @public
+*/
+function mergePromiseStack(promise, stack) {
+	stack = stack || createStack();
+	promise.then(() => {}, __assignType$2((error) => {
+		mergeStack(error, stack || "");
+	}, [
+		"error",
+		"",
+		"P\"2!\"/\""
+	]));
+	return promise;
+}
+mergePromiseStack.__type = [
+	"promise",
+	"stack",
+	"mergePromiseStack",
+	"P\"`2!&2\"8\"`/#"
+];
+/**
+* @beta
+*/
+function createStack(removeCallee = true) {
+	if (Error.stackTraceLimit === 10) Error.stackTraceLimit = 100;
+	let stack = (/* @__PURE__ */ new Error()).stack || "";
+	stack = stack.slice(stack.indexOf("   at ") + 6);
+	stack = stack.slice(stack.indexOf("   at ") - 1);
+	if (removeCallee) {
+		stack = stack.slice(stack.indexOf("   at ") + 6);
+		stack = stack.slice(stack.indexOf("   at ") - 1);
+	}
+	return stack;
+}
+createStack.__type = [
+	"removeCallee",
+	() => true,
+	"createStack",
+	"P)2!>\"&/#"
+];
+/**
+* @beta
+*/
+function mergeStack(error, stack) {
+	if (error instanceof Error && error.stack) error.stack += "\n" + stack;
+}
+mergeStack.__type = [
+	() => __ΩError,
+	"error",
+	"stack",
+	"mergeStack",
+	"Pn!2\"&2#\"/$"
+];
+/**
+* Makes sure the given value is an error. If it's not an error, it creates a new error with the given value as message.
+*/
+function ensureError(error, classType = Error) {
+	return error instanceof Error || error instanceof AggregateError ? error : new classType(error);
+}
+ensureError.__type = [
+	"error",
+	() => __ΩClassType,
+	"classType",
+	() => Error,
+	() => __ΩError,
+	"ensureError",
+	"P\"2!8n\"2#>$n%/&"
+];
+function collectForMicrotask(callback) {
+	let items = [];
+	let taskScheduled = false;
+	return __assignType$2((arg) => {
+		items.push(arg);
+		if (!taskScheduled) {
+			taskScheduled = true;
+			queueMicrotask(() => {
+				taskScheduled = false;
+				callback(items);
+				items.length = 0;
+			});
+		}
+	}, [
+		() => callback,
+		"args",
+		"",
+		"arg",
+		"PPdi!Ph\"!F2\"$/#qe!!!j2$\"/#"
+	]);
+}
+collectForMicrotask.__type = [
+	"args",
+	"",
+	"callback",
+	"arg",
+	"collectForMicrotask",
+	"PP\"F2!$/\"2#P\"2$$/\"/%"
+];
+/**
+* Returns the current time as seconds.
+*
+* @public
+*/
+function time() {
+	return Date.now() / 1e3;
+}
+time.__type = ["time", "P'/!"];
+/**
+* @public
+*/
+function getPathValue(bag, parameterPath, defaultValue) {
+	if (parameterPath === "" || parameterPath === void 0) return bag;
+	if (isSet(bag[parameterPath])) return bag[parameterPath];
+	const result = import_dot_prop.default.get(bag, parameterPath);
+	return isSet(result) ? result : defaultValue;
+}
+getPathValue.__type = [
+	"bag",
+	"parameterPath",
+	"defaultValue",
+	"getPathValue",
+	"PP&\"LM2!&2\"\"2#8\"/$"
+];
+/**
+* @public
+*/
+function setPathValue(bag, parameterPath, value) {
+	import_dot_prop.default.set(bag, parameterPath, value);
+}
+setPathValue.__type = [
+	"bag",
+	"parameterPath",
+	"value",
+	"setPathValue",
+	"P%2!&2\"\"2#\"/$"
+];
+/**
+* @public
+*/
+function deletePathValue(bag, parameterPath) {
+	import_dot_prop.default.delete(bag, parameterPath);
+}
+deletePathValue.__type = [
+	"bag",
+	"parameterPath",
+	"deletePathValue",
+	"P%2!&2\"\"/#"
+];
+/**
+* Returns the human-readable byte representation.
+*
+* @public
+*/
+function humanBytes(bytes, si = false) {
+	const thresh = si ? 1e3 : 1024;
+	if (Math.abs(bytes) < thresh) return bytes + " B";
+	const units = si ? [
+		"kB",
+		"MB",
+		"GB",
+		"TB",
+		"PB",
+		"EB",
+		"ZB",
+		"YB"
+	] : [
+		"KiB",
+		"MiB",
+		"GiB",
+		"TiB",
+		"PiB",
+		"EiB",
+		"ZiB",
+		"YiB"
+	];
+	let u = -1;
+	do {
+		bytes /= thresh;
+		++u;
+	} while (Math.abs(bytes) >= thresh && u < units.length - 1);
+	return bytes.toFixed(2) + " " + units[u];
+}
+humanBytes.__type = [
+	"bytes",
+	"si",
+	() => false,
+	"humanBytes",
+	"P'2!)2\">#&/$"
+];
+/**
+* Returns the number of properties on `obj`. This is 20x faster than Object.keys(obj).length.
+*/
+function getObjectKeysSize(obj) {
+	let size = 0;
+	for (let i in obj) if (obj.hasOwnProperty(i)) size++;
+	return size;
+}
+getObjectKeysSize.__type = [
+	"obj",
+	"getObjectKeysSize",
+	"P%2!'/\""
+];
+function isConstructable(fn) {
+	try {
+		new new Proxy(fn, { construct: () => ({}) })();
+		return true;
+	} catch (err) {
+		return false;
+	}
+}
+isConstructable.__type = [
+	"fn",
+	"isConstructable",
+	"P\"2!)/\""
+];
+function isPrototypeOfBase(prototype, base) {
+	if (!prototype) return false;
+	if (prototype === base) return true;
+	let currentProto = Object.getPrototypeOf(prototype);
+	while (currentProto && currentProto !== Object.prototype) {
+		if (currentProto === base) return true;
+		currentProto = Object.getPrototypeOf(currentProto);
+	}
+	return false;
+}
+isPrototypeOfBase.__type = [
+	() => __ΩAbstractClassType,
+	"prototype",
+	() => __ΩClassType,
+	"base",
+	"isPrototypeOfBase",
+	"PPn!-J2\"n#2$)/%"
+];
+function getParentClass(classType) {
+	const parent = Object.getPrototypeOf(classType);
+	if (parent === Object.prototype || Object.getPrototypeOf(parent) === Object.prototype) return;
+	return parent;
+}
+getParentClass.__type = [
+	() => __ΩClassType,
+	"classType",
+	() => __ΩClassType,
+	"getParentClass",
+	"Pn!2\"Pn#-J/$"
+];
+function getInheritanceChain(classType) {
+	const chain = [classType];
+	let current = classType;
+	while (current = getParentClass(current)) chain.push(current);
+	return chain;
+}
+getInheritanceChain.__type = [
+	() => __ΩClassType,
+	"classType",
+	() => __ΩClassType,
+	"getInheritanceChain",
+	"Pn!2\"n#F/$"
+];
+function inDebugMode() {
+	return typeof v8debug === "object" || typeof process !== "undefined" && /--debug|--inspect/.test(process.execArgv.join(" "));
+}
+inDebugMode.__type = ["inDebugMode", "P\"/!"];
+/**
+* Create a new class with the given name.
+* This is currently the only know way to make it workable in browsers too.
+*/
+function createDynamicClass(name, base) {
+	if (base) {
+		let baseName = getClassName(base);
+		if (baseName === name) baseName += "Base";
+		return new Function(baseName, `return class ${name} extends ${baseName} {}`)(base);
+	}
+	return new Function(`return class ${name} {}`)();
+}
+createDynamicClass.__type = [
+	"name",
+	() => __ΩClassType,
+	"base",
+	() => __ΩClassType,
+	"createDynamicClass",
+	"P&2!n\"2#8n$/%"
+];
+function isIterable(value) {
+	return isArray(value) || value instanceof Set || value instanceof Map;
+}
+isIterable.__type = [
+	"value",
+	"isIterable",
+	"P\"2!)/\""
+];
+function iterableSize(value) {
+	return isArray(value) ? value.length : value.size || 0;
+}
+iterableSize.__type = [
+	"value",
+	"iterableSize",
+	"PP#F#D##EJ2!'/\""
+];
+/**
+* Returns __filename, works in both cjs and esm.
+*/
+function getCurrentFileName() {
+	const initiator = (/* @__PURE__ */ new Error()).stack.split("\n").slice(2, 3)[0];
+	let path = /(?<path>[^(\s]+):[0-9]+:[0-9]+/.exec(initiator).groups.path;
+	if (path.indexOf("file") >= 0) path = new URL(path).pathname;
+	if (path[0] === "/" && process.platform === "win32") path = path.slice(1);
+	return path;
+}
+getCurrentFileName.__type = ["getCurrentFileName", "P&/!"];
+/**
+* Escape special characters in a regex string, so it can be used as a literal string.
+*/
+function escapeRegExp(string) {
+	return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+escapeRegExp.__type = [
+	"string",
+	"escapeRegExp",
+	"P&2!&/\""
+];
+function hasProperty(object, property) {
+	return Object.prototype.hasOwnProperty.call(object, property);
+}
+hasProperty.__type = [
+	"object",
+	"property",
+	"hasProperty",
+	"P\"2!\"2\")/#"
+];
+/**
+* Returns an iterator of numbers from start (inclusive) to stop (exclusive) by step.
+*/
+function* range(startOrLength, stop = 0, step = 1) {
+	let i = startOrLength;
+	let end = stop;
+	if (stop === 0) {
+		i = 0;
+		end = startOrLength;
+	}
+	for (; i < end; i += step) yield i;
+}
+range.__type = [
+	"startOrLength",
+	"stop",
+	() => 0,
+	"step",
+	() => 1,
+	() => __ΩIterableIterator,
+	"range",
+	"P'2!'2\">#'2$>%'o&\"/'"
+];
+/**
+* Returns an array of numbers from start (inclusive) to stop (exclusive) by step.
+*
+* Works the same as python's range function.
+*/
+function rangeArray(startOrLength, stop = 0, step = 1) {
+	return [...range(startOrLength, stop, step)];
+}
+rangeArray.__type = [
+	"startOrLength",
+	"stop",
+	() => 0,
+	"step",
+	() => 1,
+	"rangeArray",
+	"P'2!'2\">#'2$>%'F/&"
+];
+/**
+* Returns a combined array of the given arrays.
+*
+* Works the same as python's zip function.
+*/
+function zip(...args) {
+	const minLength = Math.min(...args.map(__assignType$2((arr) => arr.length, [
+		"arr",
+		"",
+		"P\"2!\"/\""
+	])));
+	return Array.from({ length: minLength }).map(__assignType$2((_, i) => args.map(__assignType$2((arr) => arr[i], [
+		"arr",
+		"",
+		"P\"2!\"/\""
+	])), [
+		"_",
+		"i",
+		"",
+		"P\"2!\"2\"\"/#"
+	]));
+}
+zip.__type = [
+	"args",
+	"zip",
+	"l:e\"!R!RPd\"e#!fh!!Fqk#'QRP\"@2!Pd\"gN)!F/\""
+];
+/**
+* Forwards the runtime type arguments from function x to function y.
+* This is necessary when a generic function is overridden and forwarded to something else.
+*
+* ```typescript
+* let generic = <T>(type?: ReceiveType<T>) => undefined;
+*
+* let forwarded<T> = () => {
+*     forwardTypeArguments(forwarded, generic); //all type arguments are forwarded to generic()
+*     generic(); //call as usual
+* }
+*
+* forwarded<any>(); //generic receives any in runtime.
+* ```
+*
+* Note that generic.bind(this) will not work, as bind() creates a new function and forwarded type arguments can not
+* reach the original function anymore.
+*
+* ```typescript
+* let forwarded<T> = () => {
+*     const bound = generic.bind(this);
+*     forwardTypeArguments(forwarded, bound); //can not be forwarded anymore
+*     bound(); //fails
+* }
+* ```
+*
+*  This is a limitation of JavaScript. In this case you have to manually forward type arguments.
+*
+*  ```typescript
+*  let forwarded<T> = (type?: ReceiveType<T>) => {
+*     const bound = generic.bind(this);
+*     bound(type);
+*  }
+*  ```
+*/
+function forwardTypeArguments(x, y) {
+	y.Ω = x.Ω;
+	x.Ω = void 0;
+}
+forwardTypeArguments.__type = [
+	"x",
+	"y",
+	"forwardTypeArguments",
+	"P\"2!\"2\"$/#"
+];
+function formatError(error, withStack = false) {
+	if (error && error.name === "AggregateError" && "errors" in error) return `${withStack && error.stack || `AggregateError: ${error.message}`}\nErrors:\n${error.errors.map(__assignType$2((v) => formatError(v), [
+		"v",
+		"",
+		"P\"2!\"/\""
+	])).join("\n")}`;
+	if (error instanceof Error) {
+		let current = error.cause;
+		let errors = [withStack && error.stack || error.message || "Error"];
+		while (current) {
+			errors.push(`cause by ${formatError(current)}`);
+			current = current.cause;
+		}
+		return errors.join("\n");
+	}
+	if (withStack && error.stack) return error.stack;
+	return String(error);
+}
+formatError.__type = [
+	"error",
+	"withStack",
+	() => false,
+	"formatError",
+	"P\"2!)2\">#&/$"
+];
+/**
+* Asserts that the given object is an instance of the given class.
+*/
+function assertInstanceOf(object, constructor) {
+	if (!(object instanceof constructor)) throw new Error(`Object ${getClassName(object)} is not an instance of the expected class ${getClassName(constructor)}`);
+}
+assertInstanceOf.__type = [
+	"object",
+	"args",
+	"new",
+	"constructor",
+	"assertInstanceOf",
+	"P\"2!PP\"@2\"\"1#M2$!/%"
+];
+/**
+* Asserts that the given value is defined (not null and not undefined).
+*/
+function assertDefined(value) {
+	if (value === null || value === void 0) throw new Error(`Value is not defined`);
+}
+assertDefined.__type = [
+	"value",
+	"assertDefined",
+	"P\"2!!/\""
+];
+
+//#endregion
+//#region ../../node_modules/.pnpm/to-fast-properties@3.0.1/node_modules/to-fast-properties/index.js
+var require_to_fast_properties = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	let fastProto = null;
+	function FastObject(o) {
+		if (fastProto !== null && typeof fastProto.property) {
+			const result = fastProto;
+			fastProto = FastObject.prototype = null;
+			return result;
+		}
+		fastProto = FastObject.prototype = o == null ? Object.create(null) : o;
+		return new FastObject();
+	}
+	const inlineCacheCutoff = 10;
+	for (let i = 0; i <= inlineCacheCutoff; i++) FastObject();
+	module.exports = function toFastproperties(o) {
+		return FastObject(o);
+	};
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+core@1.0.5_patch_hash=8c3beca4372c6a8941162780ddd0f977ef3d461c2018f0809f86f416260ba440/node_modules/@deepkit/core/dist/esm/src/perf.js
+var import_to_fast_properties = /* @__PURE__ */ __toESM(require_to_fast_properties(), 1);
+function toFastProperties(obj) {
+	(0, import_to_fast_properties.default)(obj);
+}
+toFastProperties.__type = [
+	"obj",
+	"toFastProperties",
+	"P\"2!\"/\""
+];
+
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+core@1.0.5_patch_hash=8c3beca4372c6a8941162780ddd0f977ef3d461c2018f0809f86f416260ba440/node_modules/@deepkit/core/dist/esm/src/array.js
+/**
+* @public
+*/
+function arrayHasItem(array, item) {
+	return -1 !== array.indexOf(item);
+}
+arrayHasItem.__type = [
+	"array",
+	"item",
+	"arrayHasItem",
+	"P\"F2!\"2\")/#"
+];
+/**
+* Clears the array so its empty. Returns the amount of removed items.
+*
+* @public
+*/
+function arrayClear(array) {
+	const found = array.length;
+	array.length = 0;
+	return found;
+}
+arrayClear.__type = [
+	"array",
+	"arrayClear",
+	"P\"F2!'/\""
+];
+/**
+* Removes on particular item by reference of an array.
+*
+* @public
+*/
+function arrayRemoveItem(array, item) {
+	const index = array.indexOf(item);
+	if (-1 !== index) {
+		array.splice(index, 1);
+		return true;
+	}
+	return false;
+}
+arrayRemoveItem.__type = [
+	"array",
+	"item",
+	"arrayRemoveItem",
+	"P\"F2!\"2\")/#"
+];
+/**
+* Moves a particular item in an array up or down (move>0=down, move<0=up).
+* Changes the array itself.
+*
+* ```typescript
+* const array = ['a', 'b', 'c'];
+*
+* arrayMoveItem(array, 'a', +1); //['b', 'a', 'c']
+* arrayMoveItem(array, 'a', -1); //['a', 'b', 'c']
+*
+* arrayMoveItem(array, 'b', -1); //['b', 'a', 'c']
+* arrayMoveItem(array, 'b', +1); //['a', 'c', 'b']
+*
+* arrayMoveItem(array, 'c', -1); //['b', 'c', 'b']
+* arrayMoveItem(array, 'c', +1); //['a', 'b', 'c']
+*
+* ```
+*
+* @public
+*/
+function arrayMoveItem(array, item, move) {
+	if (move === 0) return array;
+	const index = array.indexOf(item);
+	if (-1 !== index) {
+		const newIndex = index + move;
+		array.splice(index, 1);
+		if (newIndex <= 0) array.unshift(item);
+		else if (newIndex >= array.length) array.push(item);
+		else array.splice(newIndex, 0, item);
+	}
+	return array;
+}
+arrayMoveItem.__type = [
+	"array",
+	"item",
+	"move",
+	"arrayMoveItem",
+	"P\"2!\"2\"'2#\"/$"
+];
+
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+core@1.0.5_patch_hash=8c3beca4372c6a8941162780ddd0f977ef3d461c2018f0809f86f416260ba440/node_modules/@deepkit/core/dist/esm/src/indent.js
+function __assignType$1(fn, args) {
+	fn.__type = args;
+	return fn;
+}
+/**
+* @reflection never
+*/
+const indent$1 = __assignType$1(function(n) {
+	function t(n, t) {
+		var e, r = [];
+		for (e = 0; e < n.length; e++) r.push(t(n[e], e, n));
+		return r;
+	}
+	t.__type = [
+		"n",
+		"t",
+		"P\"2!\"2\"\"/\""
+	];
+	function e(n, t) {
+		var e, r;
+		for (e = 0; e < n.length; e++) if (r = t(n[e], e, n)) return r;
+		return !1;
+	}
+	e.__type = [
+		"n",
+		"t",
+		"e",
+		"P\"2!\"2\"\"/#"
+	];
+	function r(n, t, e) {
+		if (d[n]) return d[n];
+		var r = [];
+		d[n] = r, e = e || "";
+		for (var a = 0; a < t.length; a++) t[a].a.indexOf(n.toLowerCase()) !== -1 && e.indexOf(t[a].b) === -1 && r.push(t[a]);
+		return r;
+	}
+	r.__type = [
+		"n",
+		"t",
+		"e",
+		"r",
+		"P\"2!\"2\"\"2#\"/$"
+	];
+	function a(n, a, o) {
+		function h(n) {
+			P = n.cursor;
+			var t = n.rule, e = E + 1 + (t.c || 0);
+			n.line = e, Z.push(n), t.d && z[e]++, t.e && (S = r(t.e, g)), t.f && F.push(null), t.callback && t.callback(n, z, O);
+		}
+		h.__type = [
+			"n",
+			"h",
+			"P\"2!\"/\""
+		];
+		function d() {
+			var n = Z.pop(), t = n.line, e = n.rule;
+			if (e.d) {
+				var a = ("function" == typeof e.g ? e.g(b) : e.g) || 0 !== b.matchIndex ? 1 : 0;
+				O[E + a] && O[E + a].push(t);
+			}
+			e.e && (S = null), e.f && F.pop(), F[F.length - 1] = n;
+		}
+		d.__type = ["d", "P\"/!"];
+		function m(n, r, a) {
+			n = n.substring(a, n.length);
+			for (var l, s, i, c = null, u = n.length, o = F[F.length - 1], h = o ? o.rule.b : "", d = t(Z, __assignType$1(function(n) {
+				return n.rule.b;
+			}, [
+				"n",
+				"",
+				"P\"2!\"/\""
+			])).join("\n"), m = 0; m < r.length; m++) i = r[m], i.h && e(i.h, __assignType$1(function(n) {
+				return d.indexOf(n) != -1;
+			}, [
+				"n",
+				"",
+				"P\"2!\"/\""
+			])) || (!i.i || h && i.i.indexOf(h) !== -1) && (s = f(n, i.j, i), s.matchIndex != -1 && s.matchIndex < u && (!i.k || 0 === a) && (u = s.matchIndex, l = s, c = i));
+			return {
+				rule: c,
+				relativeIndex: c ? u : -1,
+				matchIndex: c ? u + a : -1,
+				cursor: c ? a + l.cursor : -1,
+				state: l ? l.state : {},
+				lastMatch: o
+			};
+		}
+		m.__type = [
+			"n",
+			"r",
+			"a",
+			"m",
+			"P\"2!\"2\"\"2#\"/$"
+		];
+		function j(n, t, e, r) {
+			n = n.substr(e, n.length);
+			var a = t.rule, l = f(n, a.l, a, t.state, r), s = a.m ? l.cursor : l.matchIndex;
+			return {
+				endPatternIndex: l.endPatternIndex,
+				matchIndex: l.matchIndex === -1 ? -1 : l.matchIndex + e,
+				cursor: s === -1 ? -1 : s + e,
+				state: l.state
+			};
+		}
+		j.__type = [
+			"n",
+			"t",
+			"e",
+			"r",
+			"j",
+			"P\"2!\"2\"\"2#\"2$\"/%"
+		];
+		n = n || "";
+		var b, x, v, p, I, y = o && null != o.tabString ? o.tabString : "	", k = n.split(/[\r]?\n/gi), w = k.length, A = s(w), z = s(w), O = l(w), Z = [], F = [null], E = 0, P = 0, S = null;
+		for (o && (o.debug = { buffers: {
+			ignore: A,
+			indent: z,
+			dedent: O,
+			active: Z
+		} }); E < w;) {
+			if (v = k[E].trim(), p = u(v) + "\r\n", I = Z[Z.length - 1], x = m(p, S || a, P), Z.length) {
+				if (b = j(p, I, P, x), b.matchIndex === -1) {
+					if (I.rule.n) {
+						A[E] = 1, E++, P = 0;
+						continue;
+					}
+				} else if (I.rule.n || x.matchIndex === -1 || b.matchIndex <= x.matchIndex) {
+					d(), P = b.cursor;
+					continue;
+				}
+			}
+			x.matchIndex !== -1 ? h(x) : (E++, P = 0);
+		}
+		var $, q, R, T, M, C, H = 0, L = i(z), _ = s(w), B = [];
+		for (M = 0; M < w; M++) {
+			for (q = O[M], T = 0, C = 0; C < q.length; C++) R = q[C], R < 0 ? -R !== M && (_[-R]++, T += 1) : L[R] > 0 && (L[R]--, T += R !== M);
+			$ = L[M], _[M] = $ > T ? 1 : $ < T ? $ - T : 0, L[M] = $ > 0 ? 1 : 0;
+		}
+		for (M = 0; M < w; M++) 1 === A[M - 1] && 1 === A[M] ? B.push(k[M]) : (H += _[M] || 0, B.push((H > 0 ? c(y, H) : "") + k[M].trim()));
+		return B.join("\r\n");
+	}
+	a.__type = [
+		"n",
+		"a",
+		"o",
+		"P\"2!\"2\"\"2#\"/\""
+	];
+	function l(n) {
+		for (var t = new Array(n), e = 0; e < n; e++) t[e] = [];
+		return t;
+	}
+	l.__type = [
+		"n",
+		"l",
+		"P\"2!\"/\""
+	];
+	function s(t) {
+		if (n.Int16Array) return new Int16Array(t);
+		for (var e = new Array(t), r = 0; r < t; r++) e[r] = 0;
+		return e;
+	}
+	s.__type = [
+		"t",
+		"s",
+		"P\"2!\"/\""
+	];
+	function i(n) {
+		for (var t = s(n.length), e = 0; e < n.length; e++) t[e] = n[e];
+		return t;
+	}
+	i.__type = [
+		"n",
+		"i",
+		"P\"2!\"/\""
+	];
+	function c(n, t) {
+		return new Array(t + 1).join(n);
+	}
+	c.__type = [
+		"n",
+		"t",
+		"c",
+		"P\"2!\"2\"\"/#"
+	];
+	function u(n) {
+		return n.replace(/\\(u[0-9A-Za-z]{4}|u\{[0-9A-Za-z]{1,6}]\}|x[0-9A-Za-z]{2}|.)/g, "0");
+	}
+	u.__type = [
+		"n",
+		"u",
+		"P\"2!\"/\""
+	];
+	function o(n, t, e) {
+		var r = n.lastMatch;
+		r && "=" === r.rule.b && e[n.line].push(-r.line);
+	}
+	o.__type = [
+		"n",
+		"t",
+		"e",
+		"o",
+		"P\"2!\"2\"\"2#\"/$"
+	];
+	function h(n, t, e, r) {
+		var a;
+		if (e.newline) {
+			if (a = n.search(/[;,=]?\r*\n/), a !== -1) return {
+				matchIndex: a,
+				length: 1
+			};
+		} else a = n.search(/[^\s\r\n\{\(\[]/), e.newline = a !== -1 && (a <= r.relativeIndex || r.relativeIndex === -1);
+		return null;
+	}
+	h.__type = [
+		"n",
+		"t",
+		"e",
+		"r",
+		"h",
+		"P\"2!\"2\"\"2#\"2$\"/%"
+	];
+	function f(n, t, e, r, a) {
+		r = r || {};
+		for (var l, s, i = -1, c = 0, u = 0; u < t.length; u++) if (s = t[u], "function" == typeof s) {
+			if (l = s(n, e, r, a)) {
+				i = l.matchIndex, c = l.length;
+				break;
+			}
+		} else if (l = n.match(s)) {
+			i = n.search(s), c = l[0].length;
+			break;
+		}
+		return {
+			endPatternIndex: u,
+			matchIndex: i,
+			cursor: i + c,
+			state: r
+		};
+	}
+	f.__type = [
+		"n",
+		"t",
+		"e",
+		"r",
+		"a",
+		"f",
+		"P\"2!\"2\"\"2#\"2$\"2%\"/&"
+	];
+	var d = {};
+	String.prototype.trim || (String.prototype.trim = function() {
+		return this.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, "");
+	});
+	var m = /\r*\n/, j = [
+		"tag",
+		"void-tags",
+		"html-tag"
+	], g = [
+		{
+			a: "js html",
+			b: "comment",
+			j: [/\<\!\-\-/],
+			l: [/\-\-\>/],
+			n: !0,
+			m: !0
+		},
+		{
+			a: "html",
+			b: "doctype",
+			j: [/\<\!doctype html>/i],
+			l: [m],
+			n: !0,
+			m: !0
+		},
+		{
+			a: "js html",
+			b: "void-tags",
+			j: [/\<(area|base|br|col|command|embed|hr|img|input|keygen|link|menuitem|meta|param|source|track|wbr)/i],
+			l: [/>/],
+			d: !0,
+			m: !0
+		},
+		{
+			a: "html",
+			b: "mode switch js",
+			j: [__assignType$1(function(n) {
+				var t = /<script[\s>].*/i, e = /<\/script>/i, r = t.exec(n), a = e.exec(n);
+				return r && (!a || a.index < r.index) ? {
+					matchIndex: r.index,
+					length: r[0].length
+				} : null;
+			}, [
+				"n",
+				"",
+				"P\"2!\"/\""
+			])],
+			l: [/<\/script>/i],
+			e: "js",
+			m: !0,
+			d: !0,
+			f: !0
+		},
+		{
+			a: "html",
+			b: "mode switch css",
+			j: [__assignType$1(function(n) {
+				var t = /<style[\s>].*/i, e = /<\/style>/i, r = t.exec(n), a = e.exec(n);
+				return r && (!a || a.index < r.index) ? {
+					matchIndex: r.index,
+					length: r[0].length
+				} : null;
+			}, [
+				"n",
+				"",
+				"P\"2!\"/\""
+			])],
+			l: [/<\/style>/i],
+			e: "css",
+			m: !0,
+			d: !0,
+			f: !0
+		},
+		{
+			a: "html",
+			b: "html-tag",
+			j: [/<html[^A-Za-z0-9]/i],
+			l: [/<\/html>/i],
+			m: !0
+		},
+		{
+			a: "js html",
+			b: "tag",
+			j: [__assignType$1(function(n, t, e) {
+				var a = n.match(/<([A-Za-z][A-Za-z0-9\-\.]*)/);
+				return a ? (e.openingTag = a[1], {
+					matchIndex: a.index,
+					length: a[0].length
+				}) : null;
+			}, [
+				"n",
+				"t",
+				"e",
+				"",
+				"P\"2!\"2\"\"2#\"/$"
+			])],
+			l: [__assignType$1(function(n, t, e) {
+				var r = new RegExp("</" + e.openingTag + ">|\\s/>", "i"), a = n.match(r);
+				return a ? {
+					matchIndex: a.index,
+					length: a[0].length
+				} : null;
+			}, [
+				"n",
+				"t",
+				"e",
+				"",
+				"P\"2!\"2\"\"2#\"/$"
+			])],
+			d: !0,
+			m: !0
+		},
+		{
+			a: "js",
+			b: "line-comment",
+			j: [/\/\//],
+			l: [m],
+			n: !0
+		},
+		{
+			a: "js css",
+			b: "block-comment",
+			j: [/\/\*/],
+			l: [/\*\//],
+			n: !0,
+			m: !0
+		},
+		{
+			a: "js",
+			b: "regex",
+			j: [__assignType$1(function(n, t) {
+				var r = n.search(/[(,=:[!&|?{};][\s]*\/[^\/]|^[\s]*\/[^\/]/);
+				if (r != -1) {
+					r = n.indexOf("/", r);
+					var a = n.substring(r + 1), l = f(a, t.l, t);
+					if (l.matchIndex != -1) {
+						a = a.substring(0, l.matchIndex);
+						try {
+							return new RegExp(a), {
+								matchIndex: r,
+								length: 1
+							};
+						} catch (s) {
+							return null;
+						}
+					}
+				}
+				return null;
+			}, [
+				"n",
+				"t",
+				"",
+				"P\"2!\"2\"\"/#"
+			])],
+			l: [__assignType$1(function(n) {
+				for (var t = 0, e = n.indexOf("/"); e != -1;) try {
+					new RegExp(n.substring(0, e));
+					break;
+				} catch (r) {
+					e = n.indexOf("/", t), t = e + 1;
+				}
+				return e === -1 ? null : {
+					matchIndex: e,
+					length: 1
+				};
+			}, [
+				"n",
+				"",
+				"P\"2!\"/\""
+			])],
+			n: !0,
+			m: !0
+		},
+		{
+			a: "js html",
+			b: "quotes",
+			h: j,
+			j: [/"/],
+			l: [/"/, m],
+			n: !0,
+			m: !0
+		},
+		{
+			a: "js html",
+			b: "quotes",
+			h: j,
+			j: [/'/],
+			l: [/'/, m],
+			n: !0,
+			m: !0
+		},
+		{
+			a: "js css",
+			b: "string",
+			j: [/(''|""|``)/],
+			l: [/./, m]
+		},
+		{
+			a: "js css",
+			b: "string",
+			j: [/\"(?=[^"])/],
+			l: [/[^\\]\"/, m],
+			n: !0,
+			m: !0
+		},
+		{
+			a: "js css",
+			b: "string",
+			j: [/\'(?=[^'])/],
+			l: [/[^\\]\'/, m],
+			n: !0,
+			m: !0
+		},
+		{
+			a: "js css",
+			b: "string",
+			j: [/\`(?=[^`])/],
+			l: [/[^\\]\`/],
+			n: !0,
+			m: !0
+		},
+		{
+			a: "js",
+			b: "if",
+			j: [/^if\s*(?=\()/, /[\s]+if\s*(?=\()/],
+			l: [
+				/else[\s]+/,
+				h,
+				/[{;]/
+			],
+			d: !0
+		},
+		{
+			a: "js",
+			b: "for|while",
+			j: [/^(for|while)\s*(?=\()/],
+			l: [h, /[{;]/],
+			d: !0
+		},
+		{
+			a: "js",
+			b: "else",
+			j: [/else[\s]+/],
+			l: [
+				/if[^\w$]/,
+				h,
+				/[{;]/
+			],
+			d: !0
+		},
+		{
+			a: "js css",
+			b: "bracket",
+			j: [/\(\s*(var|let|const)?\s*/],
+			l: [/\)/],
+			d: !0,
+			m: !0,
+			f: !0
+		},
+		{
+			a: "js",
+			b: "dot-chain",
+			j: [/^\.[A-Za-z$_]/],
+			l: [/[\.;]/, m],
+			d: !0,
+			k: !0,
+			c: -1
+		},
+		{
+			a: "js",
+			b: "dot-chain",
+			j: [/\.\s*\r*\n/],
+			l: [/[\.;})\]]/, /[^\s]\s*\r*\n/],
+			d: !0
+		},
+		{
+			a: "js css",
+			b: "array",
+			j: [/\[/],
+			l: [/\]/],
+			d: !0,
+			m: !0,
+			f: !0
+		},
+		{
+			a: "js css",
+			b: "block",
+			j: [/\{/],
+			l: [/\}/],
+			d: !0,
+			m: !0,
+			f: !0
+		},
+		{
+			a: "js",
+			b: "var/let/const",
+			j: [/(var|let|const)[\s]*\r*\n/],
+			l: [h],
+			d: !0,
+			g: !0
+		},
+		{
+			a: "js",
+			b: "var/let/const",
+			j: [/(var|let|const)\s+(?=[\w$])/],
+			l: [/[,;=]/, h],
+			d: !0
+		},
+		{
+			a: "js",
+			b: "var/let/const",
+			i: ["var/let/const", "="],
+			j: [/,[\s]*\r*\n/],
+			l: [/[,;]/, h],
+			d: !0,
+			callback: o
+		},
+		{
+			a: "js",
+			b: "var/let/const",
+			i: ["var/let/const", "="],
+			j: [/^,/],
+			l: [/[,;]/, h],
+			k: !0,
+			d: !0,
+			c: -1,
+			callback: o
+		},
+		{
+			a: "js",
+			b: "equality",
+			j: [/[=<>!]=(=)?/],
+			l: [/./]
+		},
+		{
+			a: "js",
+			b: "=",
+			h: j,
+			j: [/=/],
+			l: [/[,;\)\]}]/, m]
+		},
+		{
+			a: "js",
+			b: "?:",
+			j: [/\?/],
+			l: [/[:;]/],
+			g: !0,
+			d: !0
+		},
+		{
+			a: "js",
+			b: "case",
+			j: [/^(case|default)[\s:]/],
+			l: [
+				/break[\s;\r\n]/,
+				/^return[\s;\r\n]/,
+				/^case[\s]+/,
+				/^default[\s:]/,
+				/}/
+			],
+			g: __assignType$1(function(n) {
+				return n.endPatternIndex <= 1;
+			}, [
+				"n",
+				"",
+				"P\"2!\"/\""
+			]),
+			d: !0,
+			f: !0
+		},
+		{
+			a: "js",
+			b: "semicolon",
+			j: [/;/],
+			l: [/./]
+		}
+	];
+	return {
+		css: __assignType$1(function(n, t) {
+			return a(n, r("css", g), t);
+		}, [
+			"n",
+			"t",
+			"",
+			"P\"2!\"2\"\"/#"
+		]),
+		js: __assignType$1(function(n, t) {
+			return a(n, r("js", g), t);
+		}, [
+			"n",
+			"t",
+			"",
+			"P\"2!\"2\"\"/#"
+		]),
+		ts: __assignType$1(function(n, t) {
+			return a(n, r("js", g), t);
+		}, [
+			"n",
+			"t",
+			"",
+			"P\"2!\"2\"\"/#"
+		]),
+		html: __assignType$1(function(n, t) {
+			return a(n, t && t.indentHtmlTag ? r("html", g, "html-tag") : r("html", g), t);
+		}, [
+			"n",
+			"t",
+			"",
+			"P\"2!\"2\"\"/#"
+		])
+	};
+}, [
+	"n",
+	"",
+	"P\"2!\"/\""
+])(globalThis);
+
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+core@1.0.5_patch_hash=8c3beca4372c6a8941162780ddd0f977ef3d461c2018f0809f86f416260ba440/node_modules/@deepkit/core/dist/esm/src/compiler.js
+const __ΩPartial = [
+	"T",
+	"Partial",
+	"l+e#!e\"!fRb!Pde\"!gN#\"w\"y"
+];
+const indentCode = ("undefined" !== typeof process && process.env?.DEBUG || "").includes("deepkit");
+var CompilerContext = class {
+	constructor(config = {}) {
+		this.context = (Map.Ω = [["&"], ["\""]], /* @__PURE__ */ new Map());
+		this.constVariables = (Map.Ω = [["\""], ["&"]], /* @__PURE__ */ new Map());
+		this.maxReservedVariable = 1e4;
+		this.reservedNames = (Set.Ω = [["&"]], /* @__PURE__ */ new Set());
+		this.variableContext = {};
+		/**
+		* Code that is executed in the context, but before the actual function is generated.
+		* This helps for example to initialize dynamically some context variables.
+		*/
+		this.preCode = "";
+		this.initialiseVariables = [];
+		this.config = { indent: false };
+		Object.assign(this.config, config);
+		this.context.set("_context", this.variableContext);
+	}
+	reserveName(name) {
+		for (let i = 0; i < this.maxReservedVariable; i++) {
+			const candidate = name + "_" + i;
+			if (!this.reservedNames.has(candidate)) {
+				this.reservedNames.add(candidate);
+				return candidate;
+			}
+		}
+		throw new Error(`Too many context variables (max ${this.maxReservedVariable})`);
+	}
+	set(values) {
+		for (const i in values) {
+			if (!hasProperty(values, i)) continue;
+			this.context.set(i, values[i]);
+		}
+	}
+	/**
+	* Returns always the same variable name for the same value.
+	* The variable name should not be set afterwards.
+	*/
+	reserveConst(value, name = "constVar") {
+		if (value === void 0) throw new Error("Can not reserve const for undefined value");
+		let constName = this.constVariables.get(value);
+		if (!constName) {
+			constName = this.reserveName(name);
+			this.constVariables.set(value, constName);
+			this.context.set(constName, value);
+		}
+		return constName;
+	}
+	reserveVariable(name = "var", value) {
+		const freeName = this.reserveName(name);
+		if (value === void 0) return "_context." + freeName;
+		else {
+			this.context.set(freeName, value);
+			return freeName;
+		}
+	}
+	raw(functionCode) {
+		try {
+			return new Function(...this.context.keys(), `'use strict';\n` + functionCode)(...this.context.values());
+		} catch (error) {
+			throw new Error("Could not build function: " + error + functionCode);
+		}
+	}
+	format(code) {
+		if (indentCode || this.config.indent) return indent$1.js(code, { tabString: "    " });
+		return code;
+	}
+	build(functionCode, ...args) {
+		functionCode = this.format(`
+            'use strict';
+            ${this.preCode}
+            return function self(${args.join(", ")}){
+                'use strict';
+                ${functionCode}
+            };
+        `);
+		try {
+			return new Function(...this.context.keys(), functionCode)(...this.context.values());
+		} catch (error) {
+			throw new Error(`Could not build function(${[...this.context.keys()].join(",")}): ` + error + functionCode);
+		}
+	}
+	buildAsync(functionCode, ...args) {
+		functionCode = `
+            'use strict';
+            ${this.preCode}
+            return async function self(${args.join(", ")}){
+                'use strict';
+                ${functionCode}
+            };
+        `;
+		try {
+			return new Function(...this.context.keys(), this.format(functionCode))(...this.context.values());
+		} catch (error) {
+			throw new Error("Could not build function: " + error + functionCode);
+		}
+	}
+};
+CompilerContext.__type = [
+	"context",
+	function() {
+		return Map.Ω = [["&"], ["\""]], /* @__PURE__ */ new Map();
+	},
+	"constVariables",
+	function() {
+		return Map.Ω = [["\""], ["&"]], /* @__PURE__ */ new Map();
+	},
+	"maxReservedVariable",
+	function() {
+		return 1e4;
+	},
+	"reservedNames",
+	function() {
+		return Set.Ω = [["&"]], /* @__PURE__ */ new Set();
+	},
+	"variableContext",
+	function() {
+		return {};
+	},
+	"preCode",
+	function() {
+		return "";
+	},
+	"initialiseVariables",
+	function() {
+		return [];
+	},
+	"indent",
+	"config",
+	function() {
+		return { indent: false };
+	},
+	() => __ΩPartial,
+	() => CompilerContext,
+	"config",
+	() => ({}),
+	"constructor",
+	"name",
+	"reserveName",
+	"values",
+	"set",
+	"value",
+	() => "constVar",
+	"reserveConst",
+	() => "var",
+	"reserveVariable",
+	"functionCode",
+	() => Function,
+	"raw",
+	"code",
+	"format",
+	"args",
+	"build",
+	() => Function,
+	"buildAsync",
+	"CompilerContext",
+	"!3!9>\"!3#<>$'3%>&!3'<>(P&\"LM3)<>*&3+>,&F3->.P)4/M30>1PP73.4fo2\"20>5\"06P&27&08PP&\"LM29\"0:P\"2;&27><&0=P&27>>\"2;8&0?P&2@PuA0BP&2C&0D<P&2@&@2E\"0FP&2@&@2EPuG0H5wI"
+];
+
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+core@1.0.5_patch_hash=8c3beca4372c6a8941162780ddd0f977ef3d461c2018f0809f86f416260ba440/node_modules/@deepkit/core/dist/esm/src/string.js
+function __assignType(fn, args) {
+	fn.__type = args;
+	return fn;
+}
+function indent(indentation, prefix = "") {
+	return __assignType((str = "") => {
+		return " ".repeat(indentation) + str.replace(/\n/g, "\n" + " ".repeat(indentation) + prefix);
+	}, [
+		"str",
+		() => "",
+		"",
+		"P&2!>\"\"/#"
+	]);
+}
+indent.__type = [
+	"indentation",
+	"prefix",
+	() => "",
+	"indent",
+	"P'2!&2\">#\"/$"
+];
+function capitalize(string) {
+	return string.charAt(0).toUpperCase() + string.slice(1);
+}
+capitalize.__type = [
+	"string",
+	"capitalize",
+	"P&2!&/\""
+];
+
+//#endregion
+export { isFunction as $, first as A, eachKey as At, getObjectKeysSize as B, copy as C, setPathValue as Ct, empty as D, time as Dt, deletePathValue as E, stringifyValueWithType as Et, getClassName as F, identifyType as G, getPathValue as H, getClassPropertyName as I, isArray as J, inDebugMode as K, getClassTypeFromInstance as L, fixAsyncOperation as M, formatError as N, ensureError as O, zip as Ot, forwardTypeArguments as P, isConstructable as Q, getCurrentFileName as R, collectForMicrotask as S, rangeArray as St, createStack as T, sleep as Tt, hasProperty as U, getParentClass as V, humanBytes as W, isClass as X, isAsyncFunction as Y, isClassInstance as Z, assertDefined as _, mergePromiseStack as _t, arrayHasItem as a, isNumeric as at, average as b, prettyPrintObject as bt, toFastProperties as c, isPlainObject as ct, __ΩAbstractClassType as d, isSet as dt, isGlobalClass as et, __ΩClassType as f, isString as ft, applyDefaults as g, lastKey as gt, appendObject as h, last as ht, arrayClear as i, isNumber as it, firstKey as j, eachPair as jt, escapeRegExp as k, each as kt, AsyncFunction as l, isPromise as lt, __ΩExtractClassType as m, iterableSize as mt, indent as n, isIterable as nt, arrayMoveItem as o, isObject as ot, __ΩCustomError as p, isUndefined as pt, indexOf as q, CompilerContext as r, isNull as rt, arrayRemoveItem as s, isObjectLiteral as st, capitalize as t, isInteger as tt, CustomError as u, isPrototypeOfBase as ut, assertInstanceOf as v, mergeStack as vt, createDynamicClass as w, size as wt, changeClass as x, range as xt, asyncOperation as y, prependObjectKeys as yt, getInheritanceChain as z };