@powerlines/deepkit 0.7.7 → 0.7.8

package/dist/transformer-BiefehPu.mjs

@@ -0,0 +1,1360 @@
+import { createRequire } from "node:module";
+import ts from "typescript";
+import { DeclarationTransformer, ReflectionTransformer } from "@powerlines/deepkit/vendor/type-compiler";
+import defu from "defu";
+
+//#region \0rolldown/runtime.js
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+type-spec@1.0.1_patch_hash=f3c3a4fd486751022d78f17d39a5a79f493bca20b185964ca1aba41fbfc93244/node_modules/@deepkit/type-spec/dist/esm/src/type.js
+/**
+* note: Checks are based on range checks (>, <, etc), so when adding
+* new types a check is required for all code using `TypeNumberBrand`.
+*/
+var TypeNumberBrand;
+(function(TypeNumberBrand) {
+	TypeNumberBrand[TypeNumberBrand["integer"] = 0] = "integer";
+	TypeNumberBrand[TypeNumberBrand["int8"] = 1] = "int8";
+	TypeNumberBrand[TypeNumberBrand["int16"] = 2] = "int16";
+	TypeNumberBrand[TypeNumberBrand["int32"] = 3] = "int32";
+	TypeNumberBrand[TypeNumberBrand["uint8"] = 4] = "uint8";
+	TypeNumberBrand[TypeNumberBrand["uint16"] = 5] = "uint16";
+	TypeNumberBrand[TypeNumberBrand["uint32"] = 6] = "uint32";
+	TypeNumberBrand[TypeNumberBrand["float"] = 7] = "float";
+	TypeNumberBrand[TypeNumberBrand["float32"] = 8] = "float32";
+	TypeNumberBrand[TypeNumberBrand["float64"] = 9] = "float64";
+})(TypeNumberBrand || (TypeNumberBrand = {}));
+/**
+* The instruction set.
+* Should not be greater than 93 members, because we encode it via charCode starting at 33. +93 means we end up with charCode=126
+* (which is '~' and the last char that can be represented without \x. The next 127 is '\x7F').
+*/
+var ReflectionOp;
+(function(ReflectionOp) {
+	ReflectionOp[ReflectionOp["never"] = 0] = "never";
+	ReflectionOp[ReflectionOp["any"] = 1] = "any";
+	ReflectionOp[ReflectionOp["unknown"] = 2] = "unknown";
+	ReflectionOp[ReflectionOp["void"] = 3] = "void";
+	ReflectionOp[ReflectionOp["object"] = 4] = "object";
+	ReflectionOp[ReflectionOp["string"] = 5] = "string";
+	ReflectionOp[ReflectionOp["number"] = 6] = "number";
+	ReflectionOp[ReflectionOp["numberBrand"] = 7] = "numberBrand";
+	ReflectionOp[ReflectionOp["boolean"] = 8] = "boolean";
+	ReflectionOp[ReflectionOp["bigint"] = 9] = "bigint";
+	ReflectionOp[ReflectionOp["symbol"] = 10] = "symbol";
+	ReflectionOp[ReflectionOp["null"] = 11] = "null";
+	ReflectionOp[ReflectionOp["undefined"] = 12] = "undefined";
+	/**
+	* The literal type of string, number, or boolean.
+	*
+	* This OP has 1 parameter. The next byte is the absolute address of the literal on the stack, which is the actual literal value.
+	*
+	* Pushes a function type.
+	*/
+	ReflectionOp[ReflectionOp["literal"] = 13] = "literal";
+	/**
+	* This OP pops all types on the current stack frame.
+	*
+	* This OP has 1 parameter. The next byte is the absolute address of a string|number|symbol entry on the stack.
+	*
+	* Pushes a function type.
+	*/
+	ReflectionOp[ReflectionOp["function"] = 14] = "function";
+	/**
+	* This OP pops all types on the current stack frame.
+	*
+	* Pushes a method type.
+	*/
+	ReflectionOp[ReflectionOp["method"] = 15] = "method";
+	ReflectionOp[ReflectionOp["methodSignature"] = 16] = "methodSignature";
+	ReflectionOp[ReflectionOp["parameter"] = 17] = "parameter";
+	/**
+	* This OP pops the latest type entry on the stack.
+	*
+	* Pushes a property type.
+	*/
+	ReflectionOp[ReflectionOp["property"] = 18] = "property";
+	ReflectionOp[ReflectionOp["propertySignature"] = 19] = "propertySignature";
+	/**
+	* This OP pops all types on the current stack frame. Those types should be method|property.
+	*
+	* Pushes a TypeClass onto the stack.
+	*/
+	ReflectionOp[ReflectionOp["class"] = 20] = "class";
+	/**
+	* If a class extends another class with generics, this OP represents the generic type arguments of the super class.
+	*
+	* e.g. `class A extends B<string, boolean>`, string and boolean are on the stack and classExtends pops() them, and then assigns to A.extendsTypeArguments = [string, boolean].
+	*
+	* This is only emitted when the class that is currently being described actually extends another class and uses generics.
+	*
+	* This OP has 1 argument and pops x types from the stack. X is the first argument.
+	* Expects a TypeClass on the stack.
+	*/
+	ReflectionOp[ReflectionOp["classExtends"] = 21] = "classExtends";
+	/**
+	* This OP has 1 parameter, the stack entry to the actual class symbol.
+	*/
+	ReflectionOp[ReflectionOp["classReference"] = 22] = "classReference";
+	/**
+	* Marks the last entry in the stack as optional. Used for method|property. Equal to the QuestionMark operator in a property assignment.
+	*/
+	ReflectionOp[ReflectionOp["optional"] = 23] = "optional";
+	ReflectionOp[ReflectionOp["readonly"] = 24] = "readonly";
+	ReflectionOp[ReflectionOp["public"] = 25] = "public";
+	ReflectionOp[ReflectionOp["private"] = 26] = "private";
+	ReflectionOp[ReflectionOp["protected"] = 27] = "protected";
+	ReflectionOp[ReflectionOp["abstract"] = 28] = "abstract";
+	ReflectionOp[ReflectionOp["defaultValue"] = 29] = "defaultValue";
+	ReflectionOp[ReflectionOp["description"] = 30] = "description";
+	ReflectionOp[ReflectionOp["rest"] = 31] = "rest";
+	ReflectionOp[ReflectionOp["regexp"] = 32] = "regexp";
+	ReflectionOp[ReflectionOp["enum"] = 33] = "enum";
+	ReflectionOp[ReflectionOp["enumMember"] = 34] = "enumMember";
+	ReflectionOp[ReflectionOp["set"] = 35] = "set";
+	ReflectionOp[ReflectionOp["map"] = 36] = "map";
+	/**
+	* Pops the latest stack entry and uses it as T for an array type.
+	*
+	* Pushes an array type.
+	*/
+	ReflectionOp[ReflectionOp["array"] = 37] = "array";
+	ReflectionOp[ReflectionOp["tuple"] = 38] = "tuple";
+	ReflectionOp[ReflectionOp["tupleMember"] = 39] = "tupleMember";
+	ReflectionOp[ReflectionOp["namedTupleMember"] = 40] = "namedTupleMember";
+	ReflectionOp[ReflectionOp["union"] = 41] = "union";
+	ReflectionOp[ReflectionOp["intersection"] = 42] = "intersection";
+	ReflectionOp[ReflectionOp["indexSignature"] = 43] = "indexSignature";
+	ReflectionOp[ReflectionOp["objectLiteral"] = 44] = "objectLiteral";
+	ReflectionOp[ReflectionOp["mappedType"] = 45] = "mappedType";
+	ReflectionOp[ReflectionOp["in"] = 46] = "in";
+	ReflectionOp[ReflectionOp["frame"] = 47] = "frame";
+	ReflectionOp[ReflectionOp["moveFrame"] = 48] = "moveFrame";
+	ReflectionOp[ReflectionOp["return"] = 49] = "return";
+	ReflectionOp[ReflectionOp["templateLiteral"] = 50] = "templateLiteral";
+	ReflectionOp[ReflectionOp["date"] = 51] = "date";
+	ReflectionOp[ReflectionOp["int8Array"] = 52] = "int8Array";
+	ReflectionOp[ReflectionOp["uint8ClampedArray"] = 53] = "uint8ClampedArray";
+	ReflectionOp[ReflectionOp["uint8Array"] = 54] = "uint8Array";
+	ReflectionOp[ReflectionOp["int16Array"] = 55] = "int16Array";
+	ReflectionOp[ReflectionOp["uint16Array"] = 56] = "uint16Array";
+	ReflectionOp[ReflectionOp["int32Array"] = 57] = "int32Array";
+	ReflectionOp[ReflectionOp["uint32Array"] = 58] = "uint32Array";
+	ReflectionOp[ReflectionOp["float32Array"] = 59] = "float32Array";
+	ReflectionOp[ReflectionOp["float64Array"] = 60] = "float64Array";
+	ReflectionOp[ReflectionOp["bigInt64Array"] = 61] = "bigInt64Array";
+	ReflectionOp[ReflectionOp["arrayBuffer"] = 62] = "arrayBuffer";
+	ReflectionOp[ReflectionOp["promise"] = 63] = "promise";
+	ReflectionOp[ReflectionOp["arg"] = 64] = "arg";
+	ReflectionOp[ReflectionOp["typeParameter"] = 65] = "typeParameter";
+	ReflectionOp[ReflectionOp["typeParameterDefault"] = 66] = "typeParameterDefault";
+	ReflectionOp[ReflectionOp["var"] = 67] = "var";
+	ReflectionOp[ReflectionOp["loads"] = 68] = "loads";
+	ReflectionOp[ReflectionOp["indexAccess"] = 69] = "indexAccess";
+	ReflectionOp[ReflectionOp["keyof"] = 70] = "keyof";
+	ReflectionOp[ReflectionOp["infer"] = 71] = "infer";
+	ReflectionOp[ReflectionOp["typeof"] = 72] = "typeof";
+	ReflectionOp[ReflectionOp["condition"] = 73] = "condition";
+	ReflectionOp[ReflectionOp["jumpCondition"] = 74] = "jumpCondition";
+	ReflectionOp[ReflectionOp["jump"] = 75] = "jump";
+	ReflectionOp[ReflectionOp["call"] = 76] = "call";
+	ReflectionOp[ReflectionOp["inline"] = 77] = "inline";
+	ReflectionOp[ReflectionOp["inlineCall"] = 78] = "inlineCall";
+	ReflectionOp[ReflectionOp["distribute"] = 79] = "distribute";
+	ReflectionOp[ReflectionOp["extends"] = 80] = "extends";
+	ReflectionOp[ReflectionOp["widen"] = 81] = "widen";
+	ReflectionOp[ReflectionOp["static"] = 82] = "static";
+	ReflectionOp[ReflectionOp["mappedType2"] = 83] = "mappedType2";
+	ReflectionOp[ReflectionOp["functionReference"] = 84] = "functionReference";
+	ReflectionOp[ReflectionOp["callSignature"] = 85] = "callSignature";
+	/**
+	* Assign for Enum, Interface, Class, and TypeAlias declaration at the very end
+	* of the program the typeName. This is so that we have type names available even
+	* if the JS code is minified.
+	*
+	* his operator also assigns originTypes to the type, as it acts as the finalization
+	* step of a type.
+	*/
+	ReflectionOp[ReflectionOp["typeName"] = 86] = "typeName";
+	/**
+	* If a class implement an interface or type,
+	*
+	* e.g. `class A implements B`, then B is on the stack and implements pops() it, and then assigns to A.implements = [B].
+	*
+	* This is only emitted when the class that is currently being described actually implements something.
+	*
+	* This OP has 1 argument and pops x types from the stack. X is the first argument.
+	* Expects a TypeClass on the stack.
+	*/
+	ReflectionOp[ReflectionOp["implements"] = 87] = "implements";
+	ReflectionOp[ReflectionOp["nominal"] = 88] = "nominal";
+	/**
+	* Custom Storm Software operators
+	*/
+	ReflectionOp[ReflectionOp["tags"] = 89] = "tags";
+})(ReflectionOp || (ReflectionOp = {}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@typescript+vfs@1.6.4_typescript@5.9.3/node_modules/@typescript/vfs/dist/vfs.cjs.production.min.js
+var require_vfs_cjs_production_min = /* @__PURE__ */ __commonJSMin(((exports) => {
+	function e() {
+		return e = Object.assign ? Object.assign.bind() : function(e) {
+			for (var t = 1; t < arguments.length; t++) {
+				var r = arguments[t];
+				for (var i in r) ({}).hasOwnProperty.call(r, i) && (e[i] = r[i]);
+			}
+			return e;
+		}, e.apply(null, arguments);
+	}
+	Object.defineProperty(exports, "__esModule", { value: !0 });
+	var t = !1;
+	try {
+		t = "undefined" != typeof localStorage;
+	} catch (e) {}
+	var r = "undefined" != typeof process, i = t && "function" == typeof localStorage.getItem && localStorage.getItem("DEBUG") || r && process.env.DEBUG ? console.log : function(e) {
+		return "";
+	}, s = function(e, t) {
+		var r, i = e.lib || [], s = [
+			"lib.d.ts",
+			"lib.core.d.ts",
+			"lib.decorators.d.ts",
+			"lib.decorators.legacy.d.ts",
+			"lib.dom.asynciterable.d.ts",
+			"lib.dom.d.ts",
+			"lib.dom.iterable.d.ts",
+			"lib.webworker.asynciterable.d.ts",
+			"lib.webworker.d.ts",
+			"lib.webworker.importscripts.d.ts",
+			"lib.webworker.iterable.d.ts",
+			"lib.scripthost.d.ts",
+			"lib.es5.d.ts",
+			"lib.es6.d.ts",
+			"lib.es7.d.ts",
+			"lib.core.es6.d.ts",
+			"lib.core.es7.d.ts",
+			"lib.es2015.collection.d.ts",
+			"lib.es2015.core.d.ts",
+			"lib.es2015.d.ts",
+			"lib.es2015.generator.d.ts",
+			"lib.es2015.iterable.d.ts",
+			"lib.es2015.promise.d.ts",
+			"lib.es2015.proxy.d.ts",
+			"lib.es2015.reflect.d.ts",
+			"lib.es2015.symbol.d.ts",
+			"lib.es2015.symbol.wellknown.d.ts",
+			"lib.es2016.array.include.d.ts",
+			"lib.es2016.d.ts",
+			"lib.es2016.full.d.ts",
+			"lib.es2016.intl.d.ts",
+			"lib.es2017.arraybuffer.d.ts",
+			"lib.es2017.d.ts",
+			"lib.es2017.date.d.ts",
+			"lib.es2017.full.d.ts",
+			"lib.es2017.intl.d.ts",
+			"lib.es2017.object.d.ts",
+			"lib.es2017.sharedmemory.d.ts",
+			"lib.es2017.string.d.ts",
+			"lib.es2017.typedarrays.d.ts",
+			"lib.es2018.asyncgenerator.d.ts",
+			"lib.es2018.asynciterable.d.ts",
+			"lib.es2018.d.ts",
+			"lib.es2018.full.d.ts",
+			"lib.es2018.intl.d.ts",
+			"lib.es2018.promise.d.ts",
+			"lib.es2018.regexp.d.ts",
+			"lib.es2019.array.d.ts",
+			"lib.es2019.d.ts",
+			"lib.es2019.full.d.ts",
+			"lib.es2019.intl.d.ts",
+			"lib.es2019.object.d.ts",
+			"lib.es2019.string.d.ts",
+			"lib.es2019.symbol.d.ts",
+			"lib.es2020.bigint.d.ts",
+			"lib.es2020.d.ts",
+			"lib.es2020.date.d.ts",
+			"lib.es2020.full.d.ts",
+			"lib.es2020.intl.d.ts",
+			"lib.es2020.number.d.ts",
+			"lib.es2020.promise.d.ts",
+			"lib.es2020.sharedmemory.d.ts",
+			"lib.es2020.string.d.ts",
+			"lib.es2020.symbol.wellknown.d.ts",
+			"lib.es2021.d.ts",
+			"lib.es2021.full.d.ts",
+			"lib.es2021.intl.d.ts",
+			"lib.es2021.promise.d.ts",
+			"lib.es2021.string.d.ts",
+			"lib.es2021.weakref.d.ts",
+			"lib.es2022.array.d.ts",
+			"lib.es2022.d.ts",
+			"lib.es2022.error.d.ts",
+			"lib.es2022.full.d.ts",
+			"lib.es2022.intl.d.ts",
+			"lib.es2022.object.d.ts",
+			"lib.es2022.regexp.d.ts",
+			"lib.es2022.sharedmemory.d.ts",
+			"lib.es2022.string.d.ts",
+			"lib.es2023.array.d.ts",
+			"lib.es2023.collection.d.ts",
+			"lib.es2023.d.ts",
+			"lib.es2023.full.d.ts",
+			"lib.es2023.intl.d.ts",
+			"lib.es2024.arraybuffer.d.ts",
+			"lib.es2024.collection.d.ts",
+			"lib.es2024.d.ts",
+			"lib.es2024.full.d.ts",
+			"lib.es2024.object.d.ts",
+			"lib.es2024.promise.d.ts",
+			"lib.es2024.regexp.d.ts",
+			"lib.es2024.sharedmemory.d.ts",
+			"lib.es2024.string.d.ts",
+			"lib.es2025.collection.d.ts",
+			"lib.es2025.d.ts",
+			"lib.es2025.float16.d.ts",
+			"lib.es2025.full.d.ts",
+			"lib.es2025.intl.d.ts",
+			"lib.es2025.iterator.d.ts",
+			"lib.es2025.promise.d.ts",
+			"lib.es2025.regexp.d.ts",
+			"lib.esnext.array.d.ts",
+			"lib.esnext.asynciterable.d.ts",
+			"lib.esnext.bigint.d.ts",
+			"lib.esnext.collection.d.ts",
+			"lib.esnext.d.ts",
+			"lib.esnext.date.d.ts",
+			"lib.esnext.decorators.d.ts",
+			"lib.esnext.disposable.d.ts",
+			"lib.esnext.error.d.ts",
+			"lib.esnext.float16.d.ts",
+			"lib.esnext.full.d.ts",
+			"lib.esnext.intl.d.ts",
+			"lib.esnext.iterator.d.ts",
+			"lib.esnext.object.d.ts",
+			"lib.esnext.promise.d.ts",
+			"lib.esnext.regexp.d.ts",
+			"lib.esnext.sharedmemory.d.ts",
+			"lib.esnext.string.d.ts",
+			"lib.esnext.symbol.d.ts",
+			"lib.esnext.temporal.d.ts",
+			"lib.esnext.typedarrays.d.ts",
+			"lib.esnext.weakref.d.ts"
+		], n = t.ScriptTarget[e.target || t.ScriptTarget.ES5], l = s.filter(function(e) {
+			return e.startsWith("lib." + n.toLowerCase());
+		}), o = s.indexOf(l.pop()), c = ((r = i.map(function(e) {
+			var t = s.filter(function(t) {
+				return t.startsWith("lib." + e.toLowerCase());
+			});
+			return 0 === t.length ? 0 : s.indexOf(t.pop());
+		})) && r.length ? r.reduce(function(e, t) {
+			return t > e ? t : e;
+		}) : void 0) || 0, u = Math.max(o, c);
+		return s.slice(0, u + 1);
+	}, n = function(e, t) {
+		var r = f(), i = b(), s = function(e) {
+			var t = [];
+			return i.readdirSync(e).forEach(function(n) {
+				n = r.join(e, n);
+				var l = i.statSync(n);
+				l && l.isDirectory() ? t = t.concat(s(n)) : t.push(n);
+			}), t;
+		};
+		s(t).forEach(function(s) {
+			var n = "/node_modules/@types" + s.replace(t, ""), l = i.readFileSync(s, "utf8");
+			[".ts", ".tsx"].includes(r.extname(n)) && e.set(n, l);
+		});
+	};
+	function l(e) {
+		throw new Error("Method '" + e + "' is not implemented.");
+	}
+	function o(e, t) {
+		return function() {
+			for (var r = arguments.length, s = new Array(r), n = 0; n < r; n++) s[n] = arguments[n];
+			var l = t.apply(void 0, s), o = "string" == typeof l ? l.slice(0, 80) + "..." : l;
+			return i.apply(void 0, ["> " + e].concat(s)), i("< " + o), l;
+		};
+	}
+	var a = function(t) {
+		return e({}, t.getDefaultCompilerOptions(), {
+			jsx: t.JsxEmit.React,
+			strict: !0,
+			esModuleInterop: !0,
+			module: t.ModuleKind.ESNext,
+			suppressOutputPathCheck: !0,
+			skipLibCheck: !0,
+			skipDefaultLibCheck: !0
+		}, t.versionMajorMinor && Number(t.versionMajorMinor.split(".")[0]) >= 6 ? { ignoreDeprecations: "6.0" } : { moduleResolution: t.ModuleResolutionKind.NodeJs });
+	}, c = function(e) {
+		return e.replace("/", "/lib.").toLowerCase();
+	};
+	function u(t, r, i) {
+		var s = /* @__PURE__ */ new Map();
+		return {
+			compilerHost: e({}, t, {
+				getCanonicalFileName: function(e) {
+					return e;
+				},
+				getDefaultLibFileName: function() {
+					return "/" + i.getDefaultLibFileName(r);
+				},
+				getNewLine: function() {
+					return t.newLine;
+				},
+				getSourceFile: function(e, n) {
+					var l, o;
+					return s.get(e) || (o = i.createSourceFile(e, t.readFile(e), null != (l = null != n ? n : r.target) ? l : a(i).target, !1), s.set(o.fileName, o), o);
+				},
+				useCaseSensitiveFileNames: function() {
+					return t.useCaseSensitiveFileNames;
+				}
+			}),
+			updateFile: function(e) {
+				var r = s.has(e.fileName);
+				return t.writeFile(e.fileName, e.text), s.set(e.fileName, e), r;
+			},
+			deleteFile: function(e) {
+				var r = s.has(e.fileName);
+				return s.delete(e.fileName), t.deleteFile(e.fileName), r;
+			}
+		};
+	}
+	function d(t, r, i, s, n) {
+		var l = [].concat(r), o = u(t, i, s), a = o.compilerHost, c = o.updateFile, d = o.deleteFile, f = /* @__PURE__ */ new Map(), b = 0;
+		return {
+			languageServiceHost: e({}, a, {
+				getProjectVersion: function() {
+					return b.toString();
+				},
+				getCompilationSettings: function() {
+					return i;
+				},
+				getCustomTransformers: function() {
+					return n;
+				},
+				getScriptFileNames: function() {
+					return l.slice();
+				},
+				getScriptSnapshot: function(e) {
+					var r = t.readFile(e);
+					if (r && "string" == typeof r) return s.ScriptSnapshot.fromString(r);
+				},
+				getScriptVersion: function(e) {
+					return f.get(e) || "0";
+				},
+				writeFile: t.writeFile
+			}),
+			updateFile: function(e) {
+				b++, f.set(e.fileName, b.toString()), l.includes(e.fileName) || l.push(e.fileName), c(e);
+			},
+			deleteFile: function(e) {
+				b++, f.set(e.fileName, b.toString());
+				var t = l.indexOf(e.fileName);
+				-1 !== t && l.splice(t, 1), d(e);
+			}
+		};
+	}
+	var f = function() {
+		return __require(String.fromCharCode(112, 97, 116, 104));
+	}, b = function() {
+		return __require(String.fromCharCode(102, 115));
+	};
+	exports.addAllFilesFromFolder = n, exports.addFilesForTypesIntoFolder = function(e) {
+		return n(e, "node_modules/@types");
+	}, exports.createDefaultMapFromCDN = function(e, t, r, i, n, l, o) {
+		var a = l || fetch, c = /* @__PURE__ */ new Map(), u = s(e, i), d = "https://playgroundcdn.typescriptlang.org/cdn/" + t + "/typescript/lib/";
+		return (r ? function() {
+			var e = o || localStorage;
+			return Object.keys(e).forEach(function(r) {
+				r.startsWith("ts-lib-") && !r.startsWith("ts-lib-" + t) && e.removeItem(r);
+			}), Promise.all(u.map(function(r) {
+				var i, s = "ts-lib-" + t + "-" + r, l = e.getItem(s);
+				return l ? Promise.resolve((i = l, n ? n.decompressFromUTF16(i) : i)) : a(d + r).then(function(e) {
+					return e.text();
+				}).then(function(t) {
+					var r;
+					return e.setItem(s, (r = t, n ? n.compressToUTF16(r) : r)), t;
+				}).catch(function() {});
+			})).then(function(e) {
+				e.forEach(function(e, t) {
+					e && c.set("/" + u[t], e);
+				});
+			});
+		} : function() {
+			return Promise.all(u.map(function(e) {
+				return a(d + e).then(function(e) {
+					return e.text();
+				});
+			})).then(function(e) {
+				e.forEach(function(e, t) {
+					return c.set("/" + u[t], e);
+				});
+			}).catch(function() {});
+		})().then(function() {
+			return c;
+		});
+	}, exports.createDefaultMapFromNodeModules = function(e, t, r) {
+		var i = f(), s = b(), n = s.readdirSync(r || i.dirname(__require.resolve("typescript"))).filter(function(e) {
+			return e.startsWith("lib.") && /\.d\.([^\.]+\.)?[cm]?ts$/i.test(e);
+		}), l = /* @__PURE__ */ new Map();
+		return n.forEach(function(e) {
+			l.set("/" + e, function(e) {
+				var t = r || i.dirname(__require.resolve("typescript"));
+				return s.readFileSync(i.join(t, e), "utf8");
+			}(e));
+		}), l;
+	}, exports.createFSBackedSystem = function(e, t, r, i) {
+		var s = t + "/vfs", n = f(), a = r.sys, c = null != i ? i : n.dirname(__require.resolve("typescript"));
+		return {
+			name: "fs-vfs",
+			root: s,
+			args: [],
+			createDirectory: function() {
+				return l("createDirectory");
+			},
+			directoryExists: o("directoryExists", function(t) {
+				return Array.from(e.keys()).some(function(e) {
+					return e.startsWith(t);
+				}) || a.directoryExists(t);
+			}),
+			exit: a.exit,
+			fileExists: o("fileExists", function(t) {
+				if (e.has(t)) return !0;
+				if (t.includes("tsconfig.json") || t.includes("tsconfig.json")) return !1;
+				if (t.startsWith("/lib")) {
+					var r = c + "/" + t.replace("/", "");
+					return a.fileExists(r);
+				}
+				return a.fileExists(t);
+			}),
+			getCurrentDirectory: function() {
+				return s;
+			},
+			getDirectories: a.getDirectories,
+			getExecutingFilePath: function() {
+				return l("getExecutingFilePath");
+			},
+			readDirectory: o("readDirectory", function() {
+				return "/" === (arguments.length <= 0 ? void 0 : arguments[0]) ? Array.from(e.keys()) : a.readDirectory.apply(a, arguments);
+			}),
+			readFile: o("readFile", function(t) {
+				if (e.has(t)) return e.get(t);
+				if (t.startsWith("/lib")) {
+					var r = c + "/" + t.replace("/", ""), i = a.readFile(r);
+					if (!i) {
+						var s = a.readDirectory(c);
+						throw new Error("TSVFS: A request was made for " + r + " but there wasn't a file found in the file map. You likely have a mismatch in the compiler options for the CDN download vs the compiler program. Existing Libs: " + s + ".");
+					}
+					return i;
+				}
+				return a.readFile(t);
+			}),
+			resolvePath: function(t) {
+				return e.has(t) ? t : a.resolvePath(t);
+			},
+			newLine: "\n",
+			useCaseSensitiveFileNames: !0,
+			write: function() {
+				return l("write");
+			},
+			writeFile: function(t, r) {
+				e.set(t, r);
+			},
+			deleteFile: function(t) {
+				e.delete(t);
+			},
+			realpath: a.realpath
+		};
+	}, exports.createSystem = function(e) {
+		return {
+			args: [],
+			createDirectory: function() {
+				return l("createDirectory");
+			},
+			directoryExists: o("directoryExists", function(t) {
+				return Array.from(e.keys()).some(function(e) {
+					return e.startsWith(t);
+				});
+			}),
+			exit: function() {
+				return l("exit");
+			},
+			fileExists: o("fileExists", function(t) {
+				return e.has(t) || e.has(c(t));
+			}),
+			getCurrentDirectory: function() {
+				return "/";
+			},
+			getDirectories: function() {
+				return [];
+			},
+			getExecutingFilePath: function() {
+				return l("getExecutingFilePath");
+			},
+			readDirectory: o("readDirectory", function(t) {
+				return "/" === t ? Array.from(e.keys()) : [];
+			}),
+			readFile: o("readFile", function(t) {
+				var r;
+				return null != (r = e.get(t)) ? r : e.get(c(t));
+			}),
+			resolvePath: function(e) {
+				return e;
+			},
+			newLine: "\n",
+			useCaseSensitiveFileNames: !0,
+			write: function() {
+				return l("write");
+			},
+			writeFile: function(t, r) {
+				e.set(t, r);
+			},
+			deleteFile: function(t) {
+				e.delete(t);
+			}
+		};
+	}, exports.createVirtualCompilerHost = u, exports.createVirtualLanguageServiceHost = d, exports.createVirtualTypeScriptEnvironment = function(t, r, i, s, n) {
+		void 0 === s && (s = {});
+		var l = e({}, a(i), s), o = d(t, r, l, i, n), c = o.updateFile, f = o.deleteFile, b = i.createLanguageService(o.languageServiceHost), p = b.getCompilerOptionsDiagnostics();
+		if (p.length) {
+			var g = u(t, s, i);
+			throw new Error(i.formatDiagnostics(p, g.compilerHost));
+		}
+		return {
+			name: "vfs",
+			sys: t,
+			languageService: b,
+			getSourceFile: function(e) {
+				var t;
+				return null == (t = b.getProgram()) ? void 0 : t.getSourceFile(e);
+			},
+			createFile: function(e, t) {
+				c(i.createSourceFile(e, t, l.target, !1));
+			},
+			updateFile: function(e, t, r) {
+				var s = b.getProgram().getSourceFile(e);
+				if (!s) throw new Error("Did not find a source file for " + e);
+				var n = s.text, l = null != r ? r : i.createTextSpan(0, n.length), o = n.slice(0, l.start) + t + n.slice(l.start + l.length);
+				c(i.updateSourceFile(s, o, {
+					span: l,
+					newLength: t.length
+				}));
+			},
+			deleteFile: function(e) {
+				var t = b.getProgram().getSourceFile(e);
+				t && f(t);
+			}
+		};
+	}, exports.knownLibFilesForCompilerOptions = s;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@typescript+vfs@1.6.4_typescript@5.9.3/node_modules/@typescript/vfs/dist/vfs.cjs.development.js
+var require_vfs_cjs_development = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	function _extends() {
+		return _extends = Object.assign ? Object.assign.bind() : function(n) {
+			for (var e = 1; e < arguments.length; e++) {
+				var t = arguments[e];
+				for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+			}
+			return n;
+		}, _extends.apply(null, arguments);
+	}
+	var hasLocalStorage = false;
+	try {
+		hasLocalStorage = typeof localStorage !== "undefined";
+	} catch (error) {}
+	var hasProcess = typeof process !== "undefined";
+	var debugLog = hasLocalStorage && typeof localStorage.getItem === "function" && /* @__PURE__ */ localStorage.getItem("DEBUG") || hasProcess && process.env.DEBUG ? console.log : function(_message) {
+		return "";
+	};
+	/**
+	* Makes a virtual copy of the TypeScript environment. This is the main API you want to be using with
+	* @typescript/vfs. A lot of the other exposed functions are used by this function to get set up.
+	*
+	* @param sys an object which conforms to the TS Sys (a shim over read/write access to the fs)
+	* @param rootFiles a list of files which are considered inside the project
+	* @param ts a copy pf the TypeScript module
+	* @param compilerOptions the options for this compiler run
+	* @param customTransformers custom transformers for this compiler run
+	*/
+	function createVirtualTypeScriptEnvironment(sys, rootFiles, ts, compilerOptions, customTransformers) {
+		if (compilerOptions === void 0) compilerOptions = {};
+		var mergedCompilerOpts = _extends({}, defaultCompilerOptions(ts), compilerOptions);
+		var _createVirtualLanguag = createVirtualLanguageServiceHost(sys, rootFiles, mergedCompilerOpts, ts, customTransformers), languageServiceHost = _createVirtualLanguag.languageServiceHost, _updateFile = _createVirtualLanguag.updateFile, _deleteFile = _createVirtualLanguag.deleteFile;
+		var languageService = ts.createLanguageService(languageServiceHost);
+		var diagnostics = languageService.getCompilerOptionsDiagnostics();
+		if (diagnostics.length) {
+			var compilerHost = createVirtualCompilerHost(sys, compilerOptions, ts);
+			throw new Error(ts.formatDiagnostics(diagnostics, compilerHost.compilerHost));
+		}
+		return {
+			name: "vfs",
+			sys,
+			languageService,
+			getSourceFile: function getSourceFile(fileName) {
+				var _languageService$getP;
+				return (_languageService$getP = languageService.getProgram()) == null ? void 0 : _languageService$getP.getSourceFile(fileName);
+			},
+			createFile: function createFile(fileName, content) {
+				_updateFile(ts.createSourceFile(fileName, content, mergedCompilerOpts.target, false));
+			},
+			updateFile: function updateFile(fileName, content, optPrevTextSpan) {
+				var prevSourceFile = languageService.getProgram().getSourceFile(fileName);
+				if (!prevSourceFile) throw new Error("Did not find a source file for " + fileName);
+				var prevFullContents = prevSourceFile.text;
+				var prevTextSpan = optPrevTextSpan != null ? optPrevTextSpan : ts.createTextSpan(0, prevFullContents.length);
+				var newText = prevFullContents.slice(0, prevTextSpan.start) + content + prevFullContents.slice(prevTextSpan.start + prevTextSpan.length);
+				_updateFile(ts.updateSourceFile(prevSourceFile, newText, {
+					span: prevTextSpan,
+					newLength: content.length
+				}));
+			},
+			deleteFile: function deleteFile(fileName) {
+				var sourceFile = languageService.getProgram().getSourceFile(fileName);
+				if (sourceFile) _deleteFile(sourceFile);
+			}
+		};
+	}
+	/**
+	* Grab the list of lib files for a particular target, will return a bit more than necessary (by including
+	* the dom) but that's OK, we're really working with the constraint that you can't get a list of files
+	* when running in a browser.
+	*
+	* @param target The compiler settings target baseline
+	* @param ts A copy of the TypeScript module
+	*/
+	var knownLibFilesForCompilerOptions = function knownLibFilesForCompilerOptions(compilerOptions, ts) {
+		var target = compilerOptions.target || ts.ScriptTarget.ES5;
+		var lib = compilerOptions.lib || [];
+		var files = [
+			"lib.d.ts",
+			"lib.core.d.ts",
+			"lib.decorators.d.ts",
+			"lib.decorators.legacy.d.ts",
+			"lib.dom.asynciterable.d.ts",
+			"lib.dom.d.ts",
+			"lib.dom.iterable.d.ts",
+			"lib.webworker.asynciterable.d.ts",
+			"lib.webworker.d.ts",
+			"lib.webworker.importscripts.d.ts",
+			"lib.webworker.iterable.d.ts",
+			"lib.scripthost.d.ts",
+			"lib.es5.d.ts",
+			"lib.es6.d.ts",
+			"lib.es7.d.ts",
+			"lib.core.es6.d.ts",
+			"lib.core.es7.d.ts",
+			"lib.es2015.collection.d.ts",
+			"lib.es2015.core.d.ts",
+			"lib.es2015.d.ts",
+			"lib.es2015.generator.d.ts",
+			"lib.es2015.iterable.d.ts",
+			"lib.es2015.promise.d.ts",
+			"lib.es2015.proxy.d.ts",
+			"lib.es2015.reflect.d.ts",
+			"lib.es2015.symbol.d.ts",
+			"lib.es2015.symbol.wellknown.d.ts",
+			"lib.es2016.array.include.d.ts",
+			"lib.es2016.d.ts",
+			"lib.es2016.full.d.ts",
+			"lib.es2016.intl.d.ts",
+			"lib.es2017.arraybuffer.d.ts",
+			"lib.es2017.d.ts",
+			"lib.es2017.date.d.ts",
+			"lib.es2017.full.d.ts",
+			"lib.es2017.intl.d.ts",
+			"lib.es2017.object.d.ts",
+			"lib.es2017.sharedmemory.d.ts",
+			"lib.es2017.string.d.ts",
+			"lib.es2017.typedarrays.d.ts",
+			"lib.es2018.asyncgenerator.d.ts",
+			"lib.es2018.asynciterable.d.ts",
+			"lib.es2018.d.ts",
+			"lib.es2018.full.d.ts",
+			"lib.es2018.intl.d.ts",
+			"lib.es2018.promise.d.ts",
+			"lib.es2018.regexp.d.ts",
+			"lib.es2019.array.d.ts",
+			"lib.es2019.d.ts",
+			"lib.es2019.full.d.ts",
+			"lib.es2019.intl.d.ts",
+			"lib.es2019.object.d.ts",
+			"lib.es2019.string.d.ts",
+			"lib.es2019.symbol.d.ts",
+			"lib.es2020.bigint.d.ts",
+			"lib.es2020.d.ts",
+			"lib.es2020.date.d.ts",
+			"lib.es2020.full.d.ts",
+			"lib.es2020.intl.d.ts",
+			"lib.es2020.number.d.ts",
+			"lib.es2020.promise.d.ts",
+			"lib.es2020.sharedmemory.d.ts",
+			"lib.es2020.string.d.ts",
+			"lib.es2020.symbol.wellknown.d.ts",
+			"lib.es2021.d.ts",
+			"lib.es2021.full.d.ts",
+			"lib.es2021.intl.d.ts",
+			"lib.es2021.promise.d.ts",
+			"lib.es2021.string.d.ts",
+			"lib.es2021.weakref.d.ts",
+			"lib.es2022.array.d.ts",
+			"lib.es2022.d.ts",
+			"lib.es2022.error.d.ts",
+			"lib.es2022.full.d.ts",
+			"lib.es2022.intl.d.ts",
+			"lib.es2022.object.d.ts",
+			"lib.es2022.regexp.d.ts",
+			"lib.es2022.sharedmemory.d.ts",
+			"lib.es2022.string.d.ts",
+			"lib.es2023.array.d.ts",
+			"lib.es2023.collection.d.ts",
+			"lib.es2023.d.ts",
+			"lib.es2023.full.d.ts",
+			"lib.es2023.intl.d.ts",
+			"lib.es2024.arraybuffer.d.ts",
+			"lib.es2024.collection.d.ts",
+			"lib.es2024.d.ts",
+			"lib.es2024.full.d.ts",
+			"lib.es2024.object.d.ts",
+			"lib.es2024.promise.d.ts",
+			"lib.es2024.regexp.d.ts",
+			"lib.es2024.sharedmemory.d.ts",
+			"lib.es2024.string.d.ts",
+			"lib.es2025.collection.d.ts",
+			"lib.es2025.d.ts",
+			"lib.es2025.float16.d.ts",
+			"lib.es2025.full.d.ts",
+			"lib.es2025.intl.d.ts",
+			"lib.es2025.iterator.d.ts",
+			"lib.es2025.promise.d.ts",
+			"lib.es2025.regexp.d.ts",
+			"lib.esnext.array.d.ts",
+			"lib.esnext.asynciterable.d.ts",
+			"lib.esnext.bigint.d.ts",
+			"lib.esnext.collection.d.ts",
+			"lib.esnext.d.ts",
+			"lib.esnext.date.d.ts",
+			"lib.esnext.decorators.d.ts",
+			"lib.esnext.disposable.d.ts",
+			"lib.esnext.error.d.ts",
+			"lib.esnext.float16.d.ts",
+			"lib.esnext.full.d.ts",
+			"lib.esnext.intl.d.ts",
+			"lib.esnext.iterator.d.ts",
+			"lib.esnext.object.d.ts",
+			"lib.esnext.promise.d.ts",
+			"lib.esnext.regexp.d.ts",
+			"lib.esnext.sharedmemory.d.ts",
+			"lib.esnext.string.d.ts",
+			"lib.esnext.symbol.d.ts",
+			"lib.esnext.temporal.d.ts",
+			"lib.esnext.typedarrays.d.ts",
+			"lib.esnext.weakref.d.ts"
+		];
+		var targetToCut = ts.ScriptTarget[target];
+		var matches = files.filter(function(f) {
+			return f.startsWith("lib." + targetToCut.toLowerCase());
+		});
+		var targetCutIndex = files.indexOf(matches.pop());
+		var libCutIndex = function getMax(array) {
+			return array && array.length ? array.reduce(function(max, current) {
+				return current > max ? current : max;
+			}) : void 0;
+		}(lib.map(function(lib) {
+			var matches = files.filter(function(f) {
+				return f.startsWith("lib." + lib.toLowerCase());
+			});
+			if (matches.length === 0) return 0;
+			return files.indexOf(matches.pop());
+		})) || 0;
+		var finalCutIndex = Math.max(targetCutIndex, libCutIndex);
+		return files.slice(0, finalCutIndex + 1);
+	};
+	/**
+	* Sets up a Map with lib contents by grabbing the necessary files from
+	* the local copy of typescript via the file system.
+	*
+	* The first two args are un-used, but kept around so as to not cause a
+	* semver major bump for no gain to module users.
+	*/
+	var createDefaultMapFromNodeModules = function createDefaultMapFromNodeModules(_compilerOptions, _ts, tsLibDirectory) {
+		var path = requirePath();
+		var fs = requireFS();
+		var getLib = function getLib(name) {
+			var lib = tsLibDirectory || path.dirname(__require.resolve("typescript"));
+			return fs.readFileSync(path.join(lib, name), "utf8");
+		};
+		var isDtsFile = function isDtsFile(file) {
+			return /\.d\.([^\.]+\.)?[cm]?ts$/i.test(file);
+		};
+		var knownLibFiles = fs.readdirSync(tsLibDirectory || path.dirname(__require.resolve("typescript"))).filter(function(f) {
+			return f.startsWith("lib.") && isDtsFile(f);
+		});
+		var fsMap = /* @__PURE__ */ new Map();
+		knownLibFiles.forEach(function(lib) {
+			fsMap.set("/" + lib, getLib(lib));
+		});
+		return fsMap;
+	};
+	/**
+	* Adds recursively files from the FS into the map based on the folder
+	*/
+	var addAllFilesFromFolder = function addAllFilesFromFolder(map, workingDir) {
+		var path = requirePath();
+		var fs = requireFS();
+		var _walk = function walk(dir) {
+			var results = [];
+			fs.readdirSync(dir).forEach(function(file) {
+				file = path.join(dir, file);
+				var stat = fs.statSync(file);
+				if (stat && stat.isDirectory()) results = results.concat(_walk(file));
+				else results.push(file);
+			});
+			return results;
+		};
+		_walk(workingDir).forEach(function(lib) {
+			var fsPath = "/node_modules/@types" + lib.replace(workingDir, "");
+			var content = fs.readFileSync(lib, "utf8");
+			if ([".ts", ".tsx"].includes(path.extname(fsPath))) map.set(fsPath, content);
+		});
+	};
+	/** Adds all files from node_modules/@types into the FS Map */
+	var addFilesForTypesIntoFolder = function addFilesForTypesIntoFolder(map) {
+		return addAllFilesFromFolder(map, "node_modules/@types");
+	};
+	/**
+	* Create a virtual FS Map with the lib files from a particular TypeScript
+	* version based on the target, Always includes dom ATM.
+	*
+	* @param options The compiler target, which dictates the libs to set up
+	* @param version the versions of TypeScript which are supported
+	* @param cache should the values be stored in local storage
+	* @param ts a copy of the typescript import
+	* @param lzstring an optional copy of the lz-string import
+	* @param fetcher an optional replacement for the global fetch function (tests mainly)
+	* @param storer an optional replacement for the localStorage global (tests mainly)
+	*/
+	var createDefaultMapFromCDN = function createDefaultMapFromCDN(options, version, cache, ts, lzstring, fetcher, storer) {
+		var fetchlike = fetcher || fetch;
+		var fsMap = /* @__PURE__ */ new Map();
+		var files = knownLibFilesForCompilerOptions(options, ts);
+		var prefix = "https://playgroundcdn.typescriptlang.org/cdn/" + version + "/typescript/lib/";
+		function zip(str) {
+			return lzstring ? lzstring.compressToUTF16(str) : str;
+		}
+		function unzip(str) {
+			return lzstring ? lzstring.decompressFromUTF16(str) : str;
+		}
+		function uncached() {
+			return Promise.all(files.map(function(lib) {
+				return fetchlike(prefix + lib).then(function(resp) {
+					return resp.text();
+				});
+			})).then(function(contents) {
+				contents.forEach(function(text, index) {
+					return fsMap.set("/" + files[index], text);
+				});
+			})["catch"](function() {});
+		}
+		function cached() {
+			var storelike = storer || localStorage;
+			Object.keys(storelike).forEach(function(key) {
+				if (key.startsWith("ts-lib-") && !key.startsWith("ts-lib-" + version)) storelike.removeItem(key);
+			});
+			return Promise.all(files.map(function(lib) {
+				var cacheKey = "ts-lib-" + version + "-" + lib;
+				var content = storelike.getItem(cacheKey);
+				if (!content) return fetchlike(prefix + lib).then(function(resp) {
+					return resp.text();
+				}).then(function(t) {
+					storelike.setItem(cacheKey, zip(t));
+					return t;
+				})["catch"](function() {});
+				else return Promise.resolve(unzip(content));
+			})).then(function(contents) {
+				contents.forEach(function(text, index) {
+					if (text) {
+						var name = "/" + files[index];
+						fsMap.set(name, text);
+					}
+				});
+			});
+		}
+		return (cache ? cached : uncached)().then(function() {
+			return fsMap;
+		});
+	};
+	function notImplemented(methodName) {
+		throw new Error("Method '" + methodName + "' is not implemented.");
+	}
+	function audit(name, fn) {
+		return function() {
+			for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];
+			var res = fn.apply(void 0, args);
+			var smallres = typeof res === "string" ? res.slice(0, 80) + "..." : res;
+			debugLog.apply(void 0, ["> " + name].concat(args));
+			debugLog("< " + smallres);
+			return res;
+		};
+	}
+	/** The default compiler options if TypeScript could ever change the compiler options */
+	var defaultCompilerOptions = function defaultCompilerOptions(ts) {
+		return _extends({}, ts.getDefaultCompilerOptions(), {
+			jsx: ts.JsxEmit.React,
+			strict: true,
+			esModuleInterop: true,
+			module: ts.ModuleKind.ESNext,
+			suppressOutputPathCheck: true,
+			skipLibCheck: true,
+			skipDefaultLibCheck: true
+		}, ts.versionMajorMinor && Number(ts.versionMajorMinor.split(".")[0]) >= 6 ? { ignoreDeprecations: "6.0" } : { moduleResolution: ts.ModuleResolutionKind.NodeJs });
+	};
+	var libize = function libize(path) {
+		return path.replace("/", "/lib.").toLowerCase();
+	};
+	/**
+	* Creates an in-memory System object which can be used in a TypeScript program, this
+	* is what provides read/write aspects of the virtual fs
+	*/
+	function createSystem(files) {
+		return {
+			args: [],
+			createDirectory: function createDirectory() {
+				return notImplemented("createDirectory");
+			},
+			directoryExists: audit("directoryExists", function(directory) {
+				return Array.from(files.keys()).some(function(path) {
+					return path.startsWith(directory);
+				});
+			}),
+			exit: function exit() {
+				return notImplemented("exit");
+			},
+			fileExists: audit("fileExists", function(fileName) {
+				return files.has(fileName) || files.has(libize(fileName));
+			}),
+			getCurrentDirectory: function getCurrentDirectory() {
+				return "/";
+			},
+			getDirectories: function getDirectories() {
+				return [];
+			},
+			getExecutingFilePath: function getExecutingFilePath() {
+				return notImplemented("getExecutingFilePath");
+			},
+			readDirectory: audit("readDirectory", function(directory) {
+				return directory === "/" ? Array.from(files.keys()) : [];
+			}),
+			readFile: audit("readFile", function(fileName) {
+				var _files$get;
+				return (_files$get = files.get(fileName)) != null ? _files$get : files.get(libize(fileName));
+			}),
+			resolvePath: function resolvePath(path) {
+				return path;
+			},
+			newLine: "\n",
+			useCaseSensitiveFileNames: true,
+			write: function write() {
+				return notImplemented("write");
+			},
+			writeFile: function writeFile(fileName, contents) {
+				files.set(fileName, contents);
+			},
+			deleteFile: function deleteFile(fileName) {
+				files["delete"](fileName);
+			}
+		};
+	}
+	/**
+	* Creates a file-system backed System object which can be used in a TypeScript program, you provide
+	* a set of virtual files which are prioritised over the FS versions, then a path to the root of your
+	* project (basically the folder your node_modules lives)
+	*/
+	function createFSBackedSystem(files, _projectRoot, ts, tsLibDirectory) {
+		var root = _projectRoot + "/vfs";
+		var path = requirePath();
+		var nodeSys = ts.sys;
+		var tsLib = tsLibDirectory != null ? tsLibDirectory : path.dirname(__require.resolve("typescript"));
+		return {
+			name: "fs-vfs",
+			root,
+			args: [],
+			createDirectory: function createDirectory() {
+				return notImplemented("createDirectory");
+			},
+			directoryExists: audit("directoryExists", function(directory) {
+				return Array.from(files.keys()).some(function(path) {
+					return path.startsWith(directory);
+				}) || nodeSys.directoryExists(directory);
+			}),
+			exit: nodeSys.exit,
+			fileExists: audit("fileExists", function(fileName) {
+				if (files.has(fileName)) return true;
+				if (fileName.includes("tsconfig.json") || fileName.includes("tsconfig.json")) return false;
+				if (fileName.startsWith("/lib")) {
+					var tsLibName = tsLib + "/" + fileName.replace("/", "");
+					return nodeSys.fileExists(tsLibName);
+				}
+				return nodeSys.fileExists(fileName);
+			}),
+			getCurrentDirectory: function getCurrentDirectory() {
+				return root;
+			},
+			getDirectories: nodeSys.getDirectories,
+			getExecutingFilePath: function getExecutingFilePath() {
+				return notImplemented("getExecutingFilePath");
+			},
+			readDirectory: audit("readDirectory", function() {
+				if ((arguments.length <= 0 ? void 0 : arguments[0]) === "/") return Array.from(files.keys());
+				else return nodeSys.readDirectory.apply(nodeSys, arguments);
+			}),
+			readFile: audit("readFile", function(fileName) {
+				if (files.has(fileName)) return files.get(fileName);
+				if (fileName.startsWith("/lib")) {
+					var tsLibName = tsLib + "/" + fileName.replace("/", "");
+					var result = nodeSys.readFile(tsLibName);
+					if (!result) {
+						var libs = nodeSys.readDirectory(tsLib);
+						throw new Error("TSVFS: A request was made for " + tsLibName + " but there wasn't a file found in the file map. You likely have a mismatch in the compiler options for the CDN download vs the compiler program. Existing Libs: " + libs + ".");
+					}
+					return result;
+				}
+				return nodeSys.readFile(fileName);
+			}),
+			resolvePath: function resolvePath(path) {
+				if (files.has(path)) return path;
+				return nodeSys.resolvePath(path);
+			},
+			newLine: "\n",
+			useCaseSensitiveFileNames: true,
+			write: function write() {
+				return notImplemented("write");
+			},
+			writeFile: function writeFile(fileName, contents) {
+				files.set(fileName, contents);
+			},
+			deleteFile: function deleteFile(fileName) {
+				files["delete"](fileName);
+			},
+			realpath: nodeSys.realpath
+		};
+	}
+	/**
+	* Creates an in-memory CompilerHost -which is essentially an extra wrapper to System
+	* which works with TypeScript objects - returns both a compiler host, and a way to add new SourceFile
+	* instances to the in-memory file system.
+	*/
+	function createVirtualCompilerHost(sys, compilerOptions, ts) {
+		var sourceFiles = /* @__PURE__ */ new Map();
+		var save = function save(sourceFile) {
+			sourceFiles.set(sourceFile.fileName, sourceFile);
+			return sourceFile;
+		};
+		return {
+			compilerHost: _extends({}, sys, {
+				getCanonicalFileName: function getCanonicalFileName(fileName) {
+					return fileName;
+				},
+				getDefaultLibFileName: function getDefaultLibFileName() {
+					return "/" + ts.getDefaultLibFileName(compilerOptions);
+				},
+				getNewLine: function getNewLine() {
+					return sys.newLine;
+				},
+				getSourceFile: function getSourceFile(fileName, languageVersionOrOptions) {
+					var _ref;
+					return sourceFiles.get(fileName) || save(ts.createSourceFile(fileName, sys.readFile(fileName), (_ref = languageVersionOrOptions != null ? languageVersionOrOptions : compilerOptions.target) != null ? _ref : defaultCompilerOptions(ts).target, false));
+				},
+				useCaseSensitiveFileNames: function useCaseSensitiveFileNames() {
+					return sys.useCaseSensitiveFileNames;
+				}
+			}),
+			updateFile: function updateFile(sourceFile) {
+				var alreadyExists = sourceFiles.has(sourceFile.fileName);
+				sys.writeFile(sourceFile.fileName, sourceFile.text);
+				sourceFiles.set(sourceFile.fileName, sourceFile);
+				return alreadyExists;
+			},
+			deleteFile: function deleteFile(sourceFile) {
+				var alreadyExists = sourceFiles.has(sourceFile.fileName);
+				sourceFiles["delete"](sourceFile.fileName);
+				sys.deleteFile(sourceFile.fileName);
+				return alreadyExists;
+			}
+		};
+	}
+	/**
+	* Creates an object which can host a language service against the virtual file-system
+	*/
+	function createVirtualLanguageServiceHost(sys, rootFiles, compilerOptions, ts, customTransformers) {
+		var fileNames = [].concat(rootFiles);
+		var _createVirtualCompile = createVirtualCompilerHost(sys, compilerOptions, ts), compilerHost = _createVirtualCompile.compilerHost, _updateFile2 = _createVirtualCompile.updateFile, _deleteFile2 = _createVirtualCompile.deleteFile;
+		var fileVersions = /* @__PURE__ */ new Map();
+		var projectVersion = 0;
+		return {
+			languageServiceHost: _extends({}, compilerHost, {
+				getProjectVersion: function getProjectVersion() {
+					return projectVersion.toString();
+				},
+				getCompilationSettings: function getCompilationSettings() {
+					return compilerOptions;
+				},
+				getCustomTransformers: function getCustomTransformers() {
+					return customTransformers;
+				},
+				getScriptFileNames: function getScriptFileNames() {
+					return fileNames.slice();
+				},
+				getScriptSnapshot: function getScriptSnapshot(fileName) {
+					var contents = sys.readFile(fileName);
+					if (contents && typeof contents === "string") return ts.ScriptSnapshot.fromString(contents);
+				},
+				getScriptVersion: function getScriptVersion(fileName) {
+					return fileVersions.get(fileName) || "0";
+				},
+				writeFile: sys.writeFile
+			}),
+			updateFile: function updateFile(sourceFile) {
+				projectVersion++;
+				fileVersions.set(sourceFile.fileName, projectVersion.toString());
+				if (!fileNames.includes(sourceFile.fileName)) fileNames.push(sourceFile.fileName);
+				_updateFile2(sourceFile);
+			},
+			deleteFile: function deleteFile(sourceFile) {
+				projectVersion++;
+				fileVersions.set(sourceFile.fileName, projectVersion.toString());
+				var index = fileNames.indexOf(sourceFile.fileName);
+				if (index !== -1) fileNames.splice(index, 1);
+				_deleteFile2(sourceFile);
+			}
+		};
+	}
+	var requirePath = function requirePath() {
+		return __require(String.fromCharCode(112, 97, 116, 104));
+	};
+	var requireFS = function requireFS() {
+		return __require(String.fromCharCode(102, 115));
+	};
+	exports.addAllFilesFromFolder = addAllFilesFromFolder;
+	exports.addFilesForTypesIntoFolder = addFilesForTypesIntoFolder;
+	exports.createDefaultMapFromCDN = createDefaultMapFromCDN;
+	exports.createDefaultMapFromNodeModules = createDefaultMapFromNodeModules;
+	exports.createFSBackedSystem = createFSBackedSystem;
+	exports.createSystem = createSystem;
+	exports.createVirtualCompilerHost = createVirtualCompilerHost;
+	exports.createVirtualLanguageServiceHost = createVirtualLanguageServiceHost;
+	exports.createVirtualTypeScriptEnvironment = createVirtualTypeScriptEnvironment;
+	exports.knownLibFilesForCompilerOptions = knownLibFilesForCompilerOptions;
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@typescript+vfs@1.6.4_typescript@5.9.3/node_modules/@typescript/vfs/dist/index.js
+var require_dist = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	if (process.env.NODE_ENV === "production") module.exports = require_vfs_cjs_production_min();
+	else module.exports = require_vfs_cjs_development();
+}));
+
+//#endregion
+//#region ../../node_modules/.pnpm/@deepkit+type-compiler@1.0.5_patch_hash=439aa6e683a9a48c3ebbf3529be5811680c45c22d6a265d_be73b50bc43bac944747b8ca0498113a/node_modules/@deepkit/type-compiler/dist/esm/src/compiler.js
+var import_dist = require_dist();
+const { visitEachChild, visitNode, isPropertyAssignment, isArrayTypeNode, isArrowFunction, isBlock, isCallExpression, isCallSignatureDeclaration, isClassDeclaration, isClassExpression, isConstructorDeclaration, isConstructorTypeNode, isConstructSignatureDeclaration, isEnumDeclaration, isExportDeclaration, isExpression, isExpressionWithTypeArguments, isFunctionDeclaration, isFunctionExpression, isFunctionLike, isIdentifier, isImportClause, isImportDeclaration, isImportSpecifier, isInferTypeNode, isInterfaceDeclaration, isMethodDeclaration, isMethodSignature, isModuleDeclaration, isNamedExports, isNamedTupleMember, isNewExpression, isObjectLiteralExpression, isOptionalTypeNode, isParameter, isParenthesizedExpression, isParenthesizedTypeNode, isPropertyAccessExpression, isQualifiedName, isSourceFile, isStringLiteral, isTypeAliasDeclaration, isTypeLiteralNode, isTypeParameterDeclaration, isTypeQueryNode, isTypeReferenceNode, isUnionTypeNode, isExpressionStatement, isVariableDeclaration, getEffectiveConstraintOfTypeParameter, addSyntheticLeadingComment, createCompilerHost, createPrinter, escapeLeadingUnderscores, EmitHint, NodeFlags, SyntaxKind, ScriptTarget, ModifierFlags, ScriptKind } = ts;
+const packSizeByte = 6;
+/**
+* It can't be more ops than this given number
+*/
+const packSize = 2 ** 6;
+const OPs = {
+	[ReflectionOp.literal]: { params: 1 },
+	[ReflectionOp.classReference]: { params: 1 },
+	[ReflectionOp.propertySignature]: { params: 1 },
+	[ReflectionOp.property]: { params: 1 },
+	[ReflectionOp.jump]: { params: 1 },
+	[ReflectionOp.enum]: { params: 0 },
+	[ReflectionOp.enumMember]: { params: 1 },
+	[ReflectionOp.typeParameter]: { params: 1 },
+	[ReflectionOp.typeParameterDefault]: { params: 1 },
+	[ReflectionOp.mappedType]: { params: 2 },
+	[ReflectionOp.call]: { params: 1 },
+	[ReflectionOp.inline]: { params: 1 },
+	[ReflectionOp.inlineCall]: { params: 2 },
+	[ReflectionOp.loads]: { params: 2 },
+	[ReflectionOp.extends]: { params: 0 },
+	[ReflectionOp.infer]: { params: 2 },
+	[ReflectionOp.defaultValue]: { params: 1 },
+	[ReflectionOp.parameter]: { params: 1 },
+	[ReflectionOp.method]: { params: 1 },
+	[ReflectionOp.function]: { params: 1 },
+	[ReflectionOp.description]: { params: 1 },
+	[ReflectionOp.numberBrand]: { params: 1 },
+	[ReflectionOp.typeof]: { params: 1 },
+	[ReflectionOp.classExtends]: { params: 1 },
+	[ReflectionOp.distribute]: { params: 1 },
+	[ReflectionOp.jumpCondition]: { params: 2 },
+	[ReflectionOp.typeName]: { params: 1 },
+	[ReflectionOp.implements]: { params: 1 },
+	[ReflectionOp.tags]: { params: 1 }
+};
+var Cache = class {
+	constructor() {
+		this.resolver = {};
+		this.sourceFiles = {};
+	}
+	/**
+	* Signals the cache to check if it needs to be cleared.
+	*/
+	tick() {
+		if (Object.keys(this.sourceFiles).length > 300) this.sourceFiles = {};
+	}
+};
+const cache$1 = new Cache();
+
+//#endregion
+//#region src/transformer.ts
+let loaded = false;
+const cache = new Cache();
+/**
+* Creates a Deepkit TypeScript transformer.
+*
+* @param context - The Powerlines plugin context.
+* @param options - The transformation options.
+* @returns A Deepkit TypeScript custom transformer factory.
+*/
+function createTransformer(context, options = {}) {
+	return function transformer(ctx) {
+		if (!loaded) loaded = true;
+		cache.tick();
+		return new ReflectionTransformer(ctx, cache).withReflection(defu(options, {
+			reflection: context.tsconfig.tsconfigJson.compilerOptions?.reflection || context.tsconfig.tsconfigJson.reflection,
+			reflectionLevel: context.tsconfig.tsconfigJson.compilerOptions?.reflectionLevel || context.tsconfig.tsconfigJson.reflectionLevel
+		}, {
+			exclude: [],
+			reflection: "default",
+			reflectionLevel: "normal"
+		}));
+	};
+}
+/**
+* Creates a Deepkit TypeScript declaration transformer.
+*
+* @param context - The Powerlines plugin context.
+* @param options - The transformation options.
+* @returns A Deepkit TypeScript custom declaration transformer factory.
+*/
+function createDeclarationTransformer(context, options = {}) {
+	return function declarationTransformer(ctx) {
+		return new DeclarationTransformer(ctx, cache).withReflection(defu(options, {
+			reflection: context.tsconfig.tsconfigJson.compilerOptions?.reflection || context.tsconfig.tsconfigJson.reflection,
+			reflectionLevel: context.tsconfig.tsconfigJson.compilerOptions?.reflectionLevel || context.tsconfig.tsconfigJson.reflectionLevel
+		}, {
+			exclude: [],
+			reflection: "default",
+			reflectionLevel: "normal"
+		}));
+	};
+}
+
+//#endregion
+export { createTransformer as n, createDeclarationTransformer as t };
+//# sourceMappingURL=transformer-BiefehPu.mjs.map