@powerlines/deepkit 0.6.167 → 0.7.0

package/dist/vendor/string-BoXo0wS7.cjs

@@ -0,0 +1,2983 @@
+//#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
+Object.defineProperty(exports, 'AsyncFunction', {
+  enumerable: true,
+  get: function () {
+    return AsyncFunction;
+  }
+});
+Object.defineProperty(exports, 'CompilerContext', {
+  enumerable: true,
+  get: function () {
+    return CompilerContext;
+  }
+});
+Object.defineProperty(exports, 'CustomError', {
+  enumerable: true,
+  get: function () {
+    return CustomError;
+  }
+});
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});
+Object.defineProperty(exports, '__ΩAbstractClassType', {
+  enumerable: true,
+  get: function () {
+    return __ΩAbstractClassType;
+  }
+});
+Object.defineProperty(exports, '__ΩClassType', {
+  enumerable: true,
+  get: function () {
+    return __ΩClassType;
+  }
+});
+Object.defineProperty(exports, '__ΩCustomError', {
+  enumerable: true,
+  get: function () {
+    return __ΩCustomError;
+  }
+});
+Object.defineProperty(exports, '__ΩExtractClassType', {
+  enumerable: true,
+  get: function () {
+    return __ΩExtractClassType;
+  }
+});
+Object.defineProperty(exports, 'appendObject', {
+  enumerable: true,
+  get: function () {
+    return appendObject;
+  }
+});
+Object.defineProperty(exports, 'applyDefaults', {
+  enumerable: true,
+  get: function () {
+    return applyDefaults;
+  }
+});
+Object.defineProperty(exports, 'arrayClear', {
+  enumerable: true,
+  get: function () {
+    return arrayClear;
+  }
+});
+Object.defineProperty(exports, 'arrayHasItem', {
+  enumerable: true,
+  get: function () {
+    return arrayHasItem;
+  }
+});
+Object.defineProperty(exports, 'arrayMoveItem', {
+  enumerable: true,
+  get: function () {
+    return arrayMoveItem;
+  }
+});
+Object.defineProperty(exports, 'arrayRemoveItem', {
+  enumerable: true,
+  get: function () {
+    return arrayRemoveItem;
+  }
+});
+Object.defineProperty(exports, 'assertDefined', {
+  enumerable: true,
+  get: function () {
+    return assertDefined;
+  }
+});
+Object.defineProperty(exports, 'assertInstanceOf', {
+  enumerable: true,
+  get: function () {
+    return assertInstanceOf;
+  }
+});
+Object.defineProperty(exports, 'asyncOperation', {
+  enumerable: true,
+  get: function () {
+    return asyncOperation;
+  }
+});
+Object.defineProperty(exports, 'average', {
+  enumerable: true,
+  get: function () {
+    return average;
+  }
+});
+Object.defineProperty(exports, 'capitalize', {
+  enumerable: true,
+  get: function () {
+    return capitalize;
+  }
+});
+Object.defineProperty(exports, 'changeClass', {
+  enumerable: true,
+  get: function () {
+    return changeClass;
+  }
+});
+Object.defineProperty(exports, 'collectForMicrotask', {
+  enumerable: true,
+  get: function () {
+    return collectForMicrotask;
+  }
+});
+Object.defineProperty(exports, 'copy', {
+  enumerable: true,
+  get: function () {
+    return copy;
+  }
+});
+Object.defineProperty(exports, 'createDynamicClass', {
+  enumerable: true,
+  get: function () {
+    return createDynamicClass;
+  }
+});
+Object.defineProperty(exports, 'createStack', {
+  enumerable: true,
+  get: function () {
+    return createStack;
+  }
+});
+Object.defineProperty(exports, 'deletePathValue', {
+  enumerable: true,
+  get: function () {
+    return deletePathValue;
+  }
+});
+Object.defineProperty(exports, 'each', {
+  enumerable: true,
+  get: function () {
+    return each;
+  }
+});
+Object.defineProperty(exports, 'eachKey', {
+  enumerable: true,
+  get: function () {
+    return eachKey;
+  }
+});
+Object.defineProperty(exports, 'eachPair', {
+  enumerable: true,
+  get: function () {
+    return eachPair;
+  }
+});
+Object.defineProperty(exports, 'empty', {
+  enumerable: true,
+  get: function () {
+    return empty;
+  }
+});
+Object.defineProperty(exports, 'ensureError', {
+  enumerable: true,
+  get: function () {
+    return ensureError;
+  }
+});
+Object.defineProperty(exports, 'escapeRegExp', {
+  enumerable: true,
+  get: function () {
+    return escapeRegExp;
+  }
+});
+Object.defineProperty(exports, 'first', {
+  enumerable: true,
+  get: function () {
+    return first;
+  }
+});
+Object.defineProperty(exports, 'firstKey', {
+  enumerable: true,
+  get: function () {
+    return firstKey;
+  }
+});
+Object.defineProperty(exports, 'fixAsyncOperation', {
+  enumerable: true,
+  get: function () {
+    return fixAsyncOperation;
+  }
+});
+Object.defineProperty(exports, 'formatError', {
+  enumerable: true,
+  get: function () {
+    return formatError;
+  }
+});
+Object.defineProperty(exports, 'forwardTypeArguments', {
+  enumerable: true,
+  get: function () {
+    return forwardTypeArguments;
+  }
+});
+Object.defineProperty(exports, 'getClassName', {
+  enumerable: true,
+  get: function () {
+    return getClassName;
+  }
+});
+Object.defineProperty(exports, 'getClassPropertyName', {
+  enumerable: true,
+  get: function () {
+    return getClassPropertyName;
+  }
+});
+Object.defineProperty(exports, 'getClassTypeFromInstance', {
+  enumerable: true,
+  get: function () {
+    return getClassTypeFromInstance;
+  }
+});
+Object.defineProperty(exports, 'getCurrentFileName', {
+  enumerable: true,
+  get: function () {
+    return getCurrentFileName;
+  }
+});
+Object.defineProperty(exports, 'getInheritanceChain', {
+  enumerable: true,
+  get: function () {
+    return getInheritanceChain;
+  }
+});
+Object.defineProperty(exports, 'getObjectKeysSize', {
+  enumerable: true,
+  get: function () {
+    return getObjectKeysSize;
+  }
+});
+Object.defineProperty(exports, 'getParentClass', {
+  enumerable: true,
+  get: function () {
+    return getParentClass;
+  }
+});
+Object.defineProperty(exports, 'getPathValue', {
+  enumerable: true,
+  get: function () {
+    return getPathValue;
+  }
+});
+Object.defineProperty(exports, 'hasProperty', {
+  enumerable: true,
+  get: function () {
+    return hasProperty;
+  }
+});
+Object.defineProperty(exports, 'humanBytes', {
+  enumerable: true,
+  get: function () {
+    return humanBytes;
+  }
+});
+Object.defineProperty(exports, 'identifyType', {
+  enumerable: true,
+  get: function () {
+    return identifyType;
+  }
+});
+Object.defineProperty(exports, 'inDebugMode', {
+  enumerable: true,
+  get: function () {
+    return inDebugMode;
+  }
+});
+Object.defineProperty(exports, 'indent', {
+  enumerable: true,
+  get: function () {
+    return indent;
+  }
+});
+Object.defineProperty(exports, 'indexOf', {
+  enumerable: true,
+  get: function () {
+    return indexOf;
+  }
+});
+Object.defineProperty(exports, 'isArray', {
+  enumerable: true,
+  get: function () {
+    return isArray;
+  }
+});
+Object.defineProperty(exports, 'isAsyncFunction', {
+  enumerable: true,
+  get: function () {
+    return isAsyncFunction;
+  }
+});
+Object.defineProperty(exports, 'isClass', {
+  enumerable: true,
+  get: function () {
+    return isClass;
+  }
+});
+Object.defineProperty(exports, 'isClassInstance', {
+  enumerable: true,
+  get: function () {
+    return isClassInstance;
+  }
+});
+Object.defineProperty(exports, 'isConstructable', {
+  enumerable: true,
+  get: function () {
+    return isConstructable;
+  }
+});
+Object.defineProperty(exports, 'isFunction', {
+  enumerable: true,
+  get: function () {
+    return isFunction;
+  }
+});
+Object.defineProperty(exports, 'isGlobalClass', {
+  enumerable: true,
+  get: function () {
+    return isGlobalClass;
+  }
+});
+Object.defineProperty(exports, 'isInteger', {
+  enumerable: true,
+  get: function () {
+    return isInteger;
+  }
+});
+Object.defineProperty(exports, 'isIterable', {
+  enumerable: true,
+  get: function () {
+    return isIterable;
+  }
+});
+Object.defineProperty(exports, 'isNull', {
+  enumerable: true,
+  get: function () {
+    return isNull;
+  }
+});
+Object.defineProperty(exports, 'isNumber', {
+  enumerable: true,
+  get: function () {
+    return isNumber;
+  }
+});
+Object.defineProperty(exports, 'isNumeric', {
+  enumerable: true,
+  get: function () {
+    return isNumeric;
+  }
+});
+Object.defineProperty(exports, 'isObject', {
+  enumerable: true,
+  get: function () {
+    return isObject;
+  }
+});
+Object.defineProperty(exports, 'isObjectLiteral', {
+  enumerable: true,
+  get: function () {
+    return isObjectLiteral;
+  }
+});
+Object.defineProperty(exports, 'isPlainObject', {
+  enumerable: true,
+  get: function () {
+    return isPlainObject;
+  }
+});
+Object.defineProperty(exports, 'isPromise', {
+  enumerable: true,
+  get: function () {
+    return isPromise;
+  }
+});
+Object.defineProperty(exports, 'isPrototypeOfBase', {
+  enumerable: true,
+  get: function () {
+    return isPrototypeOfBase;
+  }
+});
+Object.defineProperty(exports, 'isSet', {
+  enumerable: true,
+  get: function () {
+    return isSet;
+  }
+});
+Object.defineProperty(exports, 'isString', {
+  enumerable: true,
+  get: function () {
+    return isString;
+  }
+});
+Object.defineProperty(exports, 'isUndefined', {
+  enumerable: true,
+  get: function () {
+    return isUndefined;
+  }
+});
+Object.defineProperty(exports, 'iterableSize', {
+  enumerable: true,
+  get: function () {
+    return iterableSize;
+  }
+});
+Object.defineProperty(exports, 'last', {
+  enumerable: true,
+  get: function () {
+    return last;
+  }
+});
+Object.defineProperty(exports, 'lastKey', {
+  enumerable: true,
+  get: function () {
+    return lastKey;
+  }
+});
+Object.defineProperty(exports, 'mergePromiseStack', {
+  enumerable: true,
+  get: function () {
+    return mergePromiseStack;
+  }
+});
+Object.defineProperty(exports, 'mergeStack', {
+  enumerable: true,
+  get: function () {
+    return mergeStack;
+  }
+});
+Object.defineProperty(exports, 'prependObjectKeys', {
+  enumerable: true,
+  get: function () {
+    return prependObjectKeys;
+  }
+});
+Object.defineProperty(exports, 'prettyPrintObject', {
+  enumerable: true,
+  get: function () {
+    return prettyPrintObject;
+  }
+});
+Object.defineProperty(exports, 'range', {
+  enumerable: true,
+  get: function () {
+    return range;
+  }
+});
+Object.defineProperty(exports, 'rangeArray', {
+  enumerable: true,
+  get: function () {
+    return rangeArray;
+  }
+});
+Object.defineProperty(exports, 'setPathValue', {
+  enumerable: true,
+  get: function () {
+    return setPathValue;
+  }
+});
+Object.defineProperty(exports, 'size', {
+  enumerable: true,
+  get: function () {
+    return size;
+  }
+});
+Object.defineProperty(exports, 'sleep', {
+  enumerable: true,
+  get: function () {
+    return sleep;
+  }
+});
+Object.defineProperty(exports, 'stringifyValueWithType', {
+  enumerable: true,
+  get: function () {
+    return stringifyValueWithType;
+  }
+});
+Object.defineProperty(exports, 'time', {
+  enumerable: true,
+  get: function () {
+    return time;
+  }
+});
+Object.defineProperty(exports, 'toFastProperties', {
+  enumerable: true,
+  get: function () {
+    return toFastProperties;
+  }
+});
+Object.defineProperty(exports, 'zip', {
+  enumerable: true,
+  get: function () {
+    return zip;
+  }
+});