@power-plant/schema 0.0.55 → 0.0.57

package/dist/deepkit-CHBsrtv1.cjs

@@ -0,0 +1,2369 @@
+const require_rolldown_runtime = require('./rolldown-runtime-C24Yb2bl.cjs');
+let typescript = require("typescript");
+typescript = require_rolldown_runtime.__toESM(typescript, 1);
+let _marcj_ts_clone_node = require("@marcj/ts-clone-node");
+let _deepkit_type_spec = require("@deepkit/type-spec");
+let micromatch = require("micromatch");
+micromatch = require_rolldown_runtime.__toESM(micromatch, 1);
+let _typescript_vfs = require("@typescript/vfs");
+let path = require("path");
+
+//#region ../../../node_modules/.pnpm/@deepkit+type-compiler@1.0.19_patch_hash=bd438188cbc12e606ed4d519c25ab921a833fbc2d92357_e562d261195ccb1f28e41e80fc823414/node_modules/@deepkit/type-compiler/dist/esm/src/reflection-ast.js
+const { isArrowFunction: isArrowFunction$1, isComputedPropertyName, isIdentifier: isIdentifier$1, isNamedImports, isNumericLiteral, isPrivateIdentifier, isStringLiteral: isStringLiteral$2, isStringLiteralLike, setOriginalNode, getLeadingCommentRanges, isNoSubstitutionTemplateLiteral, NodeFlags: NodeFlags$1, SyntaxKind: SyntaxKind$1 } = typescript.default;
+function is__String(value) {
+	return typeof value === "string";
+}
+function getIdentifierName(node) {
+	if (is__String(node)) return node;
+	if (isIdentifier$1(node) || isPrivateIdentifier(node)) return typescript.default.unescapeLeadingUnderscores(node.escapedText);
+	if (isStringLiteral$2(node)) return node.text;
+	return "";
+}
+function getEscapedText(node) {
+	if (is__String(node)) return node;
+	if (isIdentifier$1(node) || isPrivateIdentifier(node)) return node.escapedText;
+	return getIdentifierName(node);
+}
+function findSourceFile(node) {
+	if (node.kind === SyntaxKind$1.SourceFile) return node;
+	let current = node.parent;
+	while (current && current.kind !== SyntaxKind$1.SourceFile) current = current.parent;
+	return current;
+}
+function joinQualifiedName(name) {
+	if (isIdentifier$1(name)) return getIdentifierName(name);
+	return joinQualifiedName(name.left) + "_" + getIdentifierName(name.right);
+}
+function getCommentOfNode(sourceFile, node) {
+	const comment = getLeadingCommentRanges(sourceFile.text, node.pos);
+	if (!comment) return;
+	return comment.map((v) => sourceFile.text.substring(v.pos, v.end)).join("\n");
+}
+function parseJSDocAttributeFromText(comment, attribute) {
+	const index = comment.indexOf("@" + attribute + " ");
+	if (index === -1) {
+		let start = 0;
+		while (true) {
+			const withoutContent = comment.indexOf("@" + attribute, start);
+			if (withoutContent === -1) return void 0;
+			const nextCharacter = comment[withoutContent + attribute.length + 1];
+			if (!nextCharacter || nextCharacter === " " || nextCharacter === "\n" || nextCharacter === "\r" || nextCharacter === "	") return "";
+			start = withoutContent + attribute.length + 1;
+		}
+		return;
+	}
+	const start = index + attribute.length + 2;
+	const nextAttribute = comment.indexOf("@", start);
+	const endOfComment = comment.indexOf("*/", start);
+	const end = nextAttribute === -1 ? endOfComment : Math.min(nextAttribute, endOfComment);
+	return comment.substring(start, end).trim().split("\n").map((v) => {
+		const indexOfStar = v.indexOf("*");
+		if (indexOfStar === -1) return v.trim();
+		return v.substring(indexOfStar + 1).trim();
+	}).join("\n");
+}
+function extractJSDocAttribute(sourceFile, node, attribute) {
+	if (!node) return void 0;
+	const comment = getCommentOfNode(sourceFile, node);
+	if (!comment) return void 0;
+	return parseJSDocAttributeFromText(comment, attribute);
+}
+/** Tags consumed by the type-compiler itself; never emitted as runtime type annotations. */
+const JSDoc_COMPILER_TAGS = /* @__PURE__ */ new Set(["reflection", "intrinsic"]);
+/**
+* Parse a single JSDoc/TSDoc tag value.
+*
+* - empty / missing → `true` (flag tags like `@internal`)
+* - `true` / `false` → boolean
+* - `"quoted"` / `'quoted'` → unquoted string
+* - otherwise → trimmed string (e.g. `@title The Title`)
+*/
+function parseJSDocTagValue(raw) {
+	const content = raw.trim();
+	if (!content) return true;
+	if (content === "true") return true;
+	if (content === "false") return false;
+	const quote = content[0];
+	if ((quote === "\"" || quote === "'") && content.length >= 2 && content[content.length - 1] === quote) return content.slice(1, -1);
+	return content;
+}
+function stripJSDocLinePrefix(line) {
+	const trimmed = line.trim();
+	if (trimmed.startsWith("*")) return trimmed.slice(1).trimStart();
+	return trimmed;
+}
+/**
+* Parse a full JSDoc/TSDoc comment into its main description and `@tag` values.
+*/
+function parseJSDocTagsFromText(comment) {
+	let body = comment.trim();
+	if (body.startsWith("/**")) body = body.slice(3);
+	else if (body.startsWith("/*")) body = body.slice(2);
+	if (body.endsWith("*/")) body = body.slice(0, -2);
+	const lines = body.split("\n").map(stripJSDocLinePrefix);
+	const descriptionLines = [];
+	const tags = [];
+	let i = 0;
+	while (i < lines.length) {
+		const line = lines[i];
+		if (line.startsWith("@")) break;
+		descriptionLines.push(line);
+		i++;
+	}
+	while (i < lines.length) {
+		const line = lines[i];
+		if (!line.startsWith("@")) {
+			i++;
+			continue;
+		}
+		const afterAt = line.slice(1);
+		const space = afterAt.search(/[\s]/);
+		const name = (space === -1 ? afterAt : afterAt.slice(0, space)).trim();
+		let valueRaw = space === -1 ? "" : afterAt.slice(space + 1);
+		i++;
+		while (i < lines.length && !lines[i].startsWith("@")) {
+			if (lines[i] !== "" || valueRaw !== "") valueRaw = valueRaw === "" ? lines[i] : valueRaw + "\n" + lines[i];
+			i++;
+		}
+		if (!name || JSDoc_COMPILER_TAGS.has(name)) continue;
+		tags.push({
+			name,
+			value: parseJSDocTagValue(valueRaw)
+		});
+	}
+	const description = descriptionLines.join("\n").replace(/^\n+|\n+$/g, "");
+	return {
+		description: description.length ? description : void 0,
+		tags
+	};
+}
+function extractJSDocTags(sourceFile, node) {
+	if (!node) return { tags: [] };
+	const comment = getCommentOfNode(sourceFile, node);
+	if (!comment) return { tags: [] };
+	return parseJSDocTagsFromText(comment);
+}
+function getPropertyName(f, node) {
+	if (!node) return "";
+	if (isIdentifier$1(node)) return getIdentifierName(node);
+	if (isStringLiteral$2(node)) return node.text;
+	if (isNumericLiteral(node)) return +node.text;
+	if (isNoSubstitutionTemplateLiteral(node)) return node.text;
+	if (isComputedPropertyName(node)) return f.createArrowFunction(void 0, void 0, [], void 0, void 0, node.expression);
+	if (isPrivateIdentifier(node)) return getIdentifierName(node);
+	return "";
+}
+function getNameAsString(node) {
+	if (!node) return "";
+	if (isIdentifier$1(node)) return getIdentifierName(node);
+	if (isStringLiteral$2(node)) return node.text;
+	if (isNumericLiteral(node)) return node.text;
+	if ((0, typescript.isBigIntLiteral)(node)) return node.text;
+	if (isNoSubstitutionTemplateLiteral(node)) return node.text;
+	if (isComputedPropertyName(node)) {
+		if (isStringLiteralLike(node) || isNumericLiteral(node)) return node.text;
+		return "";
+	}
+	if (isPrivateIdentifier(node)) return getIdentifierName(node);
+	return joinQualifiedName(node);
+}
+function hasModifier(node, modifier) {
+	if (!node.modifiers) return false;
+	return node.modifiers.some((v) => v.kind === modifier);
+}
+const cloneHook = (node, payload) => {
+	if (isIdentifier$1(node)) return { text: () => {
+		return getIdentifierName(node);
+	} };
+};
+var NodeConverter = class {
+	constructor(f) {
+		this.f = f;
+	}
+	toExpression(node) {
+		if (node === void 0) return this.f.createIdentifier("undefined");
+		if (Array.isArray(node)) return this.f.createArrayLiteralExpression(this.f.createNodeArray(node.map((v) => this.toExpression(v))));
+		if ("string" === typeof node) return this.f.createStringLiteral(node, true);
+		if ("number" === typeof node) return this.f.createNumericLiteral(node);
+		if ("bigint" === typeof node) return this.f.createBigIntLiteral(String(node));
+		if ("boolean" === typeof node) return node ? this.f.createTrue() : this.f.createFalse();
+		if (node.pos === -1 && node.end === -1 && node.parent === void 0) {
+			if (isArrowFunction$1(node)) {
+				if (node.body.pos === -1 && node.body.end === -1 && node.body.parent === void 0) return node;
+				return this.f.createArrowFunction(node.modifiers, node.typeParameters, node.parameters, node.type, node.equalsGreaterThanToken, this.toExpression(node.body));
+			}
+			return node;
+		}
+		switch (node.kind) {
+			case SyntaxKind$1.Identifier: return finish(node, this.f.createIdentifier(getIdentifierName(node)));
+			case SyntaxKind$1.StringLiteral: return finish(node, this.f.createStringLiteral(node.text));
+			case SyntaxKind$1.NumericLiteral: return finish(node, this.f.createNumericLiteral(node.text));
+			case SyntaxKind$1.BigIntLiteral: return finish(node, this.f.createBigIntLiteral(node.text));
+			case SyntaxKind$1.TrueKeyword: return finish(node, this.f.createTrue());
+			case SyntaxKind$1.FalseKeyword: return finish(node, this.f.createFalse());
+		}
+		try {
+			return (0, _marcj_ts_clone_node.cloneNode)(node, {
+				preserveComments: false,
+				factory: this.f,
+				setOriginalNodes: true,
+				preserveSymbols: true,
+				setParents: true,
+				hook: cloneHook
+			});
+		} catch (error) {
+			console.error("could not clone node", node);
+			throw error;
+		}
+	}
+};
+function isExternalOrCommonJsModule(file) {
+	return (file.externalModuleIndicator || file.commonJsModuleIndicator) !== void 0;
+}
+function isNodeWithLocals(node) {
+	return "locals" in node;
+}
+function getGlobalsOfSourceFile(file) {
+	if (file.redirectInfo) return;
+	if (!isNodeWithLocals(file)) return;
+	if (!isExternalOrCommonJsModule(file)) return file.locals;
+	if (file.jsGlobalAugmentations) return file.jsGlobalAugmentations;
+	if (file.symbol && file.symbol.globalExports) return file.symbol.globalExports;
+}
+/**
+* For imports that can removed (like a class import only used as type only, like `p: Model[]`) we have
+* to modify the import so TS does not remove it.
+*/
+function ensureImportIsEmitted(importDeclaration, specifierName) {
+	if (specifierName && importDeclaration.importClause && importDeclaration.importClause.namedBindings) {
+		if (isNamedImports(importDeclaration.importClause.namedBindings)) {
+			for (const element of importDeclaration.importClause.namedBindings.elements) if (element.name.escapedText === specifierName.escapedText) {
+				element.flags |= NodeFlags$1.Synthesized;
+				return;
+			}
+		}
+	}
+	importDeclaration.flags |= NodeFlags$1.Synthesized;
+}
+/**
+* Serializes an entity name as an expression for decorator type metadata.
+*
+* @param node The entity name to serialize.
+*/
+function serializeEntityNameAsExpression(f, node) {
+	switch (node.kind) {
+		case SyntaxKind$1.Identifier: return finish(node, f.createIdentifier(getIdentifierName(node)));
+		case SyntaxKind$1.QualifiedName: return finish(node, serializeQualifiedNameAsExpression(f, node));
+	}
+	return node;
+}
+/**
+* Serializes an qualified name as an expression for decorator type metadata.
+*
+* @param node The qualified name to serialize.
+* @param useFallback A value indicating whether to use logical operators to test for the
+*                    qualified name at runtime.
+*/
+function serializeQualifiedNameAsExpression(f, node) {
+	return f.createPropertyAccessExpression(serializeEntityNameAsExpression(f, node.left), node.right);
+}
+function finish(oldNode, newNode) {
+	setOriginalNode(newNode, oldNode);
+	newNode._original = newNode.original;
+	newNode._symbol = oldNode._symbol ?? oldNode.symbol;
+	newNode.symbol = newNode._symbol;
+	return newNode;
+}
+
+//#endregion
+//#region ../../../node_modules/.pnpm/@deepkit+type-compiler@1.0.19_patch_hash=bd438188cbc12e606ed4d519c25ab921a833fbc2d92357_e562d261195ccb1f28e41e80fc823414/node_modules/@deepkit/type-compiler/dist/esm/src/resolver.js
+const { createSourceFile, resolveModuleName, isStringLiteral: isStringLiteral$1, JSDocParsingMode, ScriptTarget: ScriptTarget$1 } = typescript.default;
+function patternMatch(path, patterns, base) {
+	const include = patterns.filter((pattern) => pattern[0] !== "!");
+	const exclude = patterns.filter((pattern) => pattern[0] === "!").map((pattern) => pattern.substring(1));
+	return micromatch.default.isMatch(path, include, { ignore: exclude });
+}
+/**
+* A utility to resolve a module path and its declaration.
+*
+* It automatically reads a SourceFile, binds and caches it.
+*/
+var Resolver = class {
+	constructor(compilerOptions, host, sourceFiles) {
+		this.compilerOptions = compilerOptions;
+		this.host = host;
+		this.sourceFiles = sourceFiles;
+	}
+	resolve(from, importOrExportNode) {
+		const moduleSpecifier = importOrExportNode.moduleSpecifier;
+		if (!moduleSpecifier) return;
+		if (!isStringLiteral$1(moduleSpecifier)) return;
+		return this.resolveSourceFile(from, moduleSpecifier);
+	}
+	resolveImpl(modulePath, sourceFile) {
+		if (this.host.resolveModuleNameLiterals !== void 0) {
+			const results = this.host.resolveModuleNameLiterals([modulePath], sourceFile.fileName, void 0, this.compilerOptions, sourceFile, void 0);
+			if (results[0]) return results[0].resolvedModule;
+			return;
+		}
+		if (this.host.resolveModuleNames !== void 0) return this.host.resolveModuleNames([modulePath.text], sourceFile.fileName, void 0, void 0, this.compilerOptions)[0];
+		return resolveModuleName(modulePath.text, sourceFile.fileName, this.compilerOptions, this.host).resolvedModule;
+	}
+	/**
+	* Tries to resolve the .ts/d.ts file path for a given module path.
+	* Scans relative paths. Looks into package.json "types" and "exports" (with new 4.7 support)
+	*
+	* @param sourceFile the SourceFile of the file that contains the import. modulePath is relative to that.
+	* @param modulePath the x in 'from x'.
+	*/
+	resolveSourceFile(sourceFile, modulePath) {
+		const result = this.resolveImpl(modulePath, sourceFile);
+		if (!result) return;
+		if (!result.resolvedFileName.endsWith(".ts") && !result.resolvedFileName.endsWith(".tsx") && !result.resolvedFileName.endsWith(".d.ts")) return;
+		const fileName = result.resolvedFileName;
+		if (this.sourceFiles[fileName]) return this.sourceFiles[fileName];
+		const source = this.host.readFile(result.resolvedFileName);
+		if (!source) return;
+		const moduleSourceFile = this.sourceFiles[fileName] = createSourceFile(fileName, source, {
+			languageVersion: this.compilerOptions.target || ScriptTarget$1.ES2018,
+			jsDocParsingMode: JSDocParsingMode ? JSDocParsingMode.ParseNone : void 0
+		}, true);
+		this.sourceFiles[fileName] = moduleSourceFile;
+		typescript.default.bindSourceFile(moduleSourceFile, this.compilerOptions);
+		return moduleSourceFile;
+	}
+};
+
+//#endregion
+//#region ../../../node_modules/.pnpm/@deepkit+type-compiler@1.0.19_patch_hash=bd438188cbc12e606ed4d519c25ab921a833fbc2d92357_e562d261195ccb1f28e41e80fc823414/node_modules/@deepkit/type-compiler/dist/esm/src/debug.js
+function isDebug(level = 1) {
+	const expected = "deepkit" + (level > 1 ? "+".repeat(level - 1) : "");
+	return "undefined" !== typeof process && "string" === typeof process.env.DEBUG && process.env.DEBUG.includes(expected);
+}
+/**
+* First level debugging with DEBUG=deepkit
+*/
+function debug(...message) {
+	if (isDebug(1)) console.debug(...message);
+}
+/**
+* Second level debugging with DEBUG=deepkit+
+*/
+function debug2(...message) {
+	if (isDebug(2)) console.debug(...message);
+}
+
+//#endregion
+//#region ../../../node_modules/.pnpm/@deepkit+type-compiler@1.0.19_patch_hash=bd438188cbc12e606ed4d519c25ab921a833fbc2d92357_e562d261195ccb1f28e41e80fc823414/node_modules/@deepkit/type-compiler/dist/esm/src/config.js
+function isObject(obj) {
+	if (!obj) return false;
+	return typeof obj === "object" && !Array.isArray(obj);
+}
+const defaultMergeStrategy = "merge";
+/**
+* Read config and parses under TypeScript specification.
+*/
+function readTsConfig(parseConfigHost, path$1) {
+	const configFile = typescript.default.readConfigFile(path$1, (path$2) => parseConfigHost.readFile(path$2));
+	if (configFile.error) {
+		debug(`Failed to read tsconfig ${path$1}: ${configFile.error.messageText}`);
+		return;
+	}
+	const parsed = typescript.default.parseJsonConfigFileContent(configFile.config, parseConfigHost, (0, path.dirname)(path$1));
+	const ignoredErrors = [18003];
+	const softErrors = [18e3];
+	const errors = parsed.errors.filter((v) => !ignoredErrors.includes(v.code));
+	if (errors.length) debug(`Failed to parse tsconfig ${path$1}: ${parsed.errors.map((v) => v.messageText).join(", ")}`);
+	if (errors.filter((v) => !softErrors.includes(v.code)).length) return;
+	return Object.assign(configFile.config, { compilerOptions: parsed.options });
+}
+function reflectionModeMatcher(config, filePath) {
+	if (Array.isArray(config.exclude)) {
+		if (patternMatch(filePath, config.exclude)) return "never";
+	}
+	if (Array.isArray(config.reflection)) return patternMatch(filePath, config.reflection) ? "default" : "never";
+	if (config.reflection === "default" || config.reflection === "explicit") return config.reflection;
+	return "never";
+}
+function ensureStringArray(value) {
+	if (Array.isArray(value)) return value.map((v) => "" + v);
+	if ("string" === typeof value) return [value];
+	return [];
+}
+function parseRawMode(mode) {
+	if ("boolean" === typeof mode) return mode ? "default" : "never";
+	if (mode === "default" || mode === "explicit") return mode;
+	return ensureStringArray(mode);
+}
+function resolvePaths(baseDir, paths) {
+	if (!paths || !Array.isArray(paths)) return;
+	for (let i = 0; i < paths.length; i++) {
+		if ("string" !== typeof paths[i]) continue;
+		if ((0, path.isAbsolute)(paths[i])) continue;
+		let path$3 = paths[i];
+		let exclude = false;
+		if (path$3.startsWith("!")) {
+			exclude = true;
+			path$3 = path$3.substring(1);
+		}
+		if (path$3.startsWith("./") || path$3.includes("/")) path$3 = (0, path.join)(baseDir, path$3);
+		path$3 = path$3.replace(/\\/g, "/");
+		if (exclude) path$3 = "!" + path$3;
+		paths[i] = path$3;
+	}
+}
+function appendPaths(strategy = defaultMergeStrategy, parent, existing) {
+	if (strategy === "replace") return [...existing || parent];
+	if (!existing) return [...parent];
+	return [...parent, ...existing];
+}
+function applyConfigValues(existing, parent, baseDir) {
+	const parentReflection = isObject(parent.deepkitCompilerOptions) ? parent.deepkitCompilerOptions?.reflection : parent.reflection;
+	if (isObject(parent.deepkitCompilerOptions) && "undefined" === typeof existing.mergeStrategy) existing.mergeStrategy = parent.deepkitCompilerOptions.mergeStrategy;
+	if ("undefined" !== typeof parentReflection) {
+		const next = parseRawMode(parentReflection);
+		if ("undefined" === typeof existing.reflection) existing.reflection = next;
+		else if ("string" === typeof existing.reflection) {} else if (Array.isArray(next) && Array.isArray(existing.reflection)) existing.reflection = appendPaths(existing.mergeStrategy, next, existing.reflection);
+		else if ("string" === typeof next && Array.isArray(existing.reflection)) {}
+	}
+	if (isObject(parent.deepkitCompilerOptions)) {
+		if (`undefined` !== typeof parent.deepkitCompilerOptions.exclude) {
+			const next = ensureStringArray(parent.deepkitCompilerOptions.exclude);
+			existing.exclude = appendPaths(existing.mergeStrategy, next, existing.exclude);
+		}
+	}
+	resolvePaths(baseDir, existing.reflection);
+	resolvePaths(baseDir, existing.exclude);
+	if (parent.compilerOptions) {
+		if (Object.keys(existing.compilerOptions).length === 0) Object.assign(existing.compilerOptions, parent.compilerOptions);
+	}
+	existing.extends = parent.extends;
+}
+const defaultExcluded = [
+	"lib.dom*.d.ts",
+	"*typedarrays.d.ts",
+	"lib.webworker*.d.ts",
+	"lib.decorator*.d.ts",
+	"lib.es2015.proxy.d.ts",
+	"lib.es2020.sharedmemory.d.ts",
+	"lib.es2015.core.d.ts"
+];
+function getConfigResolver(cache, host, compilerOptions, sourceFile, tsConfigPath = "") {
+	let config = { compilerOptions: {} };
+	tsConfigPath = tsConfigPath || ("string" === typeof compilerOptions.configFilePath ? compilerOptions.configFilePath : "");
+	if (tsConfigPath) {
+		if (cache[tsConfigPath]) return cache[tsConfigPath];
+		const configFile = readTsConfig(host, tsConfigPath);
+		if (configFile) applyConfigValues(config, configFile, (0, path.dirname)(tsConfigPath));
+	} else {
+		if (!tsConfigPath && sourceFile) {
+			const baseDir = (0, path.dirname)(sourceFile.fileName);
+			const configPath = typescript.default.findConfigFile(baseDir, (path$4) => {
+				path$4 = (0, path.isAbsolute)(path$4) ? path$4 : (0, path.join)(baseDir, path$4);
+				return host.fileExists(path$4);
+			});
+			debug2(`No tsConfigPath|compilerOptions.configFilePath provided. Manually searching for tsconfig.json in ${baseDir} returned ${configPath}`);
+			if (configPath) tsConfigPath = (0, path.isAbsolute)(configPath) ? configPath : (0, path.join)(baseDir, configPath);
+		}
+		if (tsConfigPath) {
+			if (cache[tsConfigPath]) return cache[tsConfigPath];
+			const configFile = readTsConfig(host, tsConfigPath);
+			if (configFile) applyConfigValues(config, configFile, (0, path.dirname)(tsConfigPath));
+		}
+	}
+	if (tsConfigPath) {
+		let basePath = (0, path.dirname)(tsConfigPath);
+		let currentConfig = config;
+		const seen = /* @__PURE__ */ new Set();
+		seen.add(tsConfigPath);
+		while (currentConfig.extends) {
+			const path$5 = (0, path.join)(basePath, currentConfig.extends);
+			if (seen.has(path$5)) break;
+			seen.add(path$5);
+			const nextConfig = typescript.default.readConfigFile(path$5, (path$6) => host.readFile(path$6));
+			if (!nextConfig) break;
+			basePath = (0, path.dirname)(path$5);
+			applyConfigValues(currentConfig, nextConfig.config, basePath);
+		}
+	} else throw new Error(`No tsconfig found for ${sourceFile?.fileName}, that is weird. Either provide a tsconfig or compilerOptions.configFilePath`);
+	config.exclude = config.exclude ? [...defaultExcluded, ...config.exclude] : [...defaultExcluded];
+	config.compilerOptions.configFilePath = tsConfigPath;
+	const resolvedConfig = {
+		path: tsConfigPath,
+		compilerOptions: Object.assign(config.compilerOptions, compilerOptions),
+		exclude: config.exclude,
+		reflection: config.reflection,
+		mergeStrategy: config.mergeStrategy || defaultMergeStrategy
+	};
+	if (isDebug()) debug(`Found config ${resolvedConfig.path}:\nreflection:`, resolvedConfig.reflection, `\nexclude:`, resolvedConfig.exclude, `\npaths:`, resolvedConfig.compilerOptions.paths);
+	const match = (path$7) => {
+		return {
+			mode: reflectionModeMatcher(config, path$7),
+			tsConfigPath
+		};
+	};
+	return cache[tsConfigPath] = {
+		config: resolvedConfig,
+		match
+	};
+}
+
+//#endregion
+//#region ../../../node_modules/.pnpm/@deepkit+type-compiler@1.0.19_patch_hash=bd438188cbc12e606ed4d519c25ab921a833fbc2d92357_e562d261195ccb1f28e41e80fc823414/node_modules/@deepkit/type-compiler/dist/esm/src/compiler.js
+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 } = typescript.default;
+function encodeOps(ops) {
+	return ops.map((v) => String.fromCharCode(v + 33)).join("");
+}
+function filterUndefined(object) {
+	return Object.fromEntries(Object.entries(object).filter(([, v]) => v !== void 0));
+}
+const packSizeByte = 6;
+/**
+* It can't be more ops than this given number
+*/
+const packSize = 2 ** 6;
+const OPs = {
+	[_deepkit_type_spec.ReflectionOp.literal]: { params: 1 },
+	[_deepkit_type_spec.ReflectionOp.classReference]: { params: 1 },
+	[_deepkit_type_spec.ReflectionOp.propertySignature]: { params: 1 },
+	[_deepkit_type_spec.ReflectionOp.property]: { params: 1 },
+	[_deepkit_type_spec.ReflectionOp.jump]: { params: 1 },
+	[_deepkit_type_spec.ReflectionOp.enum]: { params: 0 },
+	[_deepkit_type_spec.ReflectionOp.enumMember]: { params: 1 },
+	[_deepkit_type_spec.ReflectionOp.typeParameter]: { params: 1 },
+	[_deepkit_type_spec.ReflectionOp.typeParameterDefault]: { params: 1 },
+	[_deepkit_type_spec.ReflectionOp.mappedType]: { params: 2 },
+	[_deepkit_type_spec.ReflectionOp.call]: { params: 1 },
+	[_deepkit_type_spec.ReflectionOp.inline]: { params: 1 },
+	[_deepkit_type_spec.ReflectionOp.inlineCall]: { params: 2 },
+	[_deepkit_type_spec.ReflectionOp.loads]: { params: 2 },
+	[_deepkit_type_spec.ReflectionOp.extends]: { params: 0 },
+	[_deepkit_type_spec.ReflectionOp.infer]: { params: 2 },
+	[_deepkit_type_spec.ReflectionOp.defaultValue]: { params: 1 },
+	[_deepkit_type_spec.ReflectionOp.parameter]: { params: 1 },
+	[_deepkit_type_spec.ReflectionOp.method]: { params: 1 },
+	[_deepkit_type_spec.ReflectionOp.function]: { params: 1 },
+	[_deepkit_type_spec.ReflectionOp.description]: { params: 1 },
+	[_deepkit_type_spec.ReflectionOp.numberBrand]: { params: 1 },
+	[_deepkit_type_spec.ReflectionOp.typeof]: { params: 1 },
+	[_deepkit_type_spec.ReflectionOp.classExtends]: { params: 1 },
+	[_deepkit_type_spec.ReflectionOp.distribute]: { params: 1 },
+	[_deepkit_type_spec.ReflectionOp.jumpCondition]: { params: 2 },
+	[_deepkit_type_spec.ReflectionOp.typeName]: { params: 1 },
+	[_deepkit_type_spec.ReflectionOp.implements]: { params: 1 }
+};
+function debugPackStruct(sourceFile, forType, pack) {
+	const items = [];
+	for (let i = 0; i < pack.ops.length; i++) {
+		const op = pack.ops[i];
+		const opInfo = OPs[op];
+		items.push(_deepkit_type_spec.ReflectionOp[op]);
+		if (opInfo && opInfo.params > 0) for (let j = 0; j < opInfo.params; j++) {
+			const address = pack.ops[++i];
+			items.push(address);
+		}
+	}
+	const printer = createPrinter();
+	const stack = [];
+	for (const s of pack.stack) if ("object" === typeof s && "getText" in s) stack.push(printer.printNode(EmitHint.Unspecified, s, sourceFile));
+	else stack.push(JSON.stringify(s));
+	console.log(stack.join(","), "|", ...items);
+}
+function findVariable(frame, name, frameOffset = 0) {
+	const variable = frame.variables.find((v) => v.name === name);
+	if (variable) return {
+		frameOffset,
+		stackIndex: variable.index
+	};
+	if (frame.previous) return findVariable(frame.previous, name, frameOffset + 1);
+}
+function findConditionalFrame(frame) {
+	if (frame.conditional) return frame;
+	if (frame.previous) return findConditionalFrame(frame.previous);
+}
+var CompilerProgram = class {
+	constructor(forNode, sourceFile) {
+		this.forNode = forNode;
+		this.sourceFile = sourceFile;
+		this.ops = [];
+		this.stack = [];
+		this.mainOffset = 0;
+		this.stackPosition = 0;
+		this.frame = {
+			variables: [],
+			opIndex: 0
+		};
+		this.activeCoRoutines = [];
+		this.coRoutines = [];
+		this.resolveFunctionParameters = /* @__PURE__ */ new Map();
+	}
+	buildPackStruct() {
+		const ops = [...this.ops];
+		if (this.coRoutines.length) for (let i = this.coRoutines.length - 1; i >= 0; i--) ops.unshift(...this.coRoutines[i].ops);
+		if (this.mainOffset) ops.unshift(_deepkit_type_spec.ReflectionOp.jump, this.mainOffset);
+		return {
+			ops,
+			stack: this.stack
+		};
+	}
+	isEmpty() {
+		return this.ops.length === 0;
+	}
+	pushConditionalFrame() {
+		const frame = this.pushFrame();
+		frame.conditional = true;
+	}
+	pushStack(item) {
+		this.stack.push(item);
+		return this.stackPosition++;
+	}
+	pushCoRoutine() {
+		this.pushFrame(true);
+		this.activeCoRoutines.push({ ops: [] });
+	}
+	popCoRoutine() {
+		const coRoutine = this.activeCoRoutines.pop();
+		if (!coRoutine) throw new Error("No active co routine found");
+		this.popFrameImplicit();
+		if (this.mainOffset === 0) this.mainOffset = 2;
+		const startIndex = this.mainOffset;
+		coRoutine.ops.push(_deepkit_type_spec.ReflectionOp.return);
+		this.coRoutines.push(coRoutine);
+		this.mainOffset += coRoutine.ops.length;
+		return startIndex;
+	}
+	pushOp(...ops) {
+		for (const op of ops) if ("number" !== typeof op) throw new Error("No valid OP added");
+		if (this.activeCoRoutines.length) {
+			this.activeCoRoutines[this.activeCoRoutines.length - 1].ops.push(...ops);
+			return;
+		}
+		this.ops.push(...ops);
+	}
+	pushOpAtFrame(frame, ...ops) {
+		if (this.activeCoRoutines.length) {
+			this.activeCoRoutines[this.activeCoRoutines.length - 1].ops.splice(frame.opIndex, 0, ...ops);
+			return;
+		}
+		this.ops.splice(frame.opIndex, 0, ...ops);
+	}
+	/**
+	* Returns the index of the `entry` in the stack, if already exists. If not, add it, and return that new index.
+	*/
+	findOrAddStackEntry(entry) {
+		const index = this.stack.indexOf(entry);
+		if (index !== -1) return index;
+		return this.pushStack(entry);
+	}
+	/**
+	* To make room for a stack entry expected on the stack as input for example.
+	*/
+	increaseStackPosition() {
+		return this.stackPosition++;
+	}
+	resolveFunctionParametersIncrease(fn) {
+		this.resolveFunctionParameters.set(fn, (this.resolveFunctionParameters.get(fn) || 0) + 1);
+	}
+	resolveFunctionParametersDecrease(fn) {
+		this.resolveFunctionParameters.set(fn, (this.resolveFunctionParameters.get(fn) || 1) - 1);
+	}
+	isResolveFunctionParameters(fn) {
+		return (this.resolveFunctionParameters.get(fn) || 0) > 0;
+	}
+	/**
+	*
+	* Each pushFrame() call needs a popFrame() call.
+	*/
+	pushFrame(implicit = false) {
+		if (!implicit) this.pushOp(_deepkit_type_spec.ReflectionOp.frame);
+		const opIndex = this.activeCoRoutines.length ? this.activeCoRoutines[this.activeCoRoutines.length - 1].ops.length : this.ops.length;
+		this.frame = {
+			previous: this.frame,
+			variables: [],
+			opIndex
+		};
+		return this.frame;
+	}
+	findConditionalFrame() {
+		return findConditionalFrame(this.frame);
+	}
+	/**
+	* Remove stack without doing it as OP in the processor. Some other command calls popFrame() already, which makes popFrameImplicit() an implicit popFrame.
+	* e.g. union, class, etc. all call popFrame(). the current CompilerProgram needs to be aware of that, which this function is for.
+	*/
+	popFrameImplicit() {
+		if (this.frame.previous) this.frame = this.frame.previous;
+	}
+	moveFrame() {
+		this.pushOp(_deepkit_type_spec.ReflectionOp.moveFrame);
+		if (this.frame.previous) this.frame = this.frame.previous;
+	}
+	pushVariable(name, frame = this.frame) {
+		this.pushOpAtFrame(frame, _deepkit_type_spec.ReflectionOp.var);
+		frame.variables.push({
+			index: frame.variables.length,
+			name
+		});
+		return frame.variables.length - 1;
+	}
+	pushTemplateParameter(name, withDefault = false) {
+		this.pushOp(withDefault ? _deepkit_type_spec.ReflectionOp.typeParameterDefault : _deepkit_type_spec.ReflectionOp.typeParameter, this.findOrAddStackEntry(name));
+		this.frame.variables.push({
+			index: this.frame.variables.length,
+			name
+		});
+		return this.frame.variables.length - 1;
+	}
+	findVariable(name, frame = this.frame) {
+		return findVariable(frame, name);
+	}
+};
+function getAssignTypeExpression(call) {
+	if (isParenthesizedExpression(call) && isCallExpression(call.expression)) call = call.expression;
+	if (isCallExpression(call) && isIdentifier(call.expression) && getIdentifierName(call.expression) === "__assignType" && call.arguments.length > 0) return call.arguments[0];
+}
+function getReceiveTypeParameter(type) {
+	if (isUnionTypeNode(type)) for (const t of type.types) {
+		const rfn = getReceiveTypeParameter(t);
+		if (rfn) return rfn;
+	}
+	else if (isTypeReferenceNode(type) && isIdentifier(type.typeName) && getIdentifierName(type.typeName) === "ReceiveType" && !!type.typeArguments && type.typeArguments.length === 1) return type;
+}
+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 = {};
+	}
+};
+/**
+* Read the TypeScript AST and generate pack struct (instructions + pre-defined stack).
+*
+* This transformer extracts type and add the encoded (so its small and low overhead) at classes and functions as property.
+*
+* Deepkit/type can then extract and decode them on-demand.
+*/
+var ReflectionTransformer = class {
+	constructor(context, cache = new Cache()) {
+		this.context = context;
+		this.cache = cache;
+		this.embedAssignType = false;
+		/**
+		* Types added to this map will get a type program directly under it.
+		* This is for types used in the very same file.
+		*/
+		this.compileDeclarations = /* @__PURE__ */ new Map();
+		/**
+		* Types added to this map will get a type program at the top root level of the program.
+		* This is for imported types, which need to be inlined into the current file, as we do not emit type imports (TS will omit them).
+		*/
+		this.embedDeclarations = /* @__PURE__ */ new Map();
+		/**
+		* When a node was embedded or compiled (from the maps above), we store it here to know to not add it again.
+		*/
+		this.compiledDeclarations = /* @__PURE__ */ new Set();
+		this.addImports = [];
+		this.additionalImports = /* @__PURE__ */ new Map();
+		this.overriddenHost = false;
+		this.knownClasses = {
+			"Int8Array": _deepkit_type_spec.ReflectionOp.int8Array,
+			"Uint8Array": _deepkit_type_spec.ReflectionOp.uint8Array,
+			"Uint8ClampedArray": _deepkit_type_spec.ReflectionOp.uint8ClampedArray,
+			"Int16Array": _deepkit_type_spec.ReflectionOp.int16Array,
+			"Uint16Array": _deepkit_type_spec.ReflectionOp.uint16Array,
+			"Int32Array": _deepkit_type_spec.ReflectionOp.int32Array,
+			"Uint32Array": _deepkit_type_spec.ReflectionOp.uint32Array,
+			"Float32Array": _deepkit_type_spec.ReflectionOp.float32Array,
+			"Float64Array": _deepkit_type_spec.ReflectionOp.float64Array,
+			"ArrayBuffer": _deepkit_type_spec.ReflectionOp.arrayBuffer,
+			"BigInt64Array": _deepkit_type_spec.ReflectionOp.bigInt64Array,
+			"Date": _deepkit_type_spec.ReflectionOp.date,
+			"RegExp": _deepkit_type_spec.ReflectionOp.regexp,
+			"String": _deepkit_type_spec.ReflectionOp.string,
+			"Number": _deepkit_type_spec.ReflectionOp.number,
+			"BigInt": _deepkit_type_spec.ReflectionOp.bigint,
+			"Boolean": _deepkit_type_spec.ReflectionOp.boolean
+		};
+		this.f = context.factory;
+		this.nodeConverter = new NodeConverter(this.f);
+		this.compilerOptions = { ...filterUndefined(context.getCompilerOptions()) };
+		this.host = createCompilerHost(this.compilerOptions);
+		this.resolver = new Resolver(this.compilerOptions, this.host, this.cache.sourceFiles);
+		this.parseConfigHost = {
+			useCaseSensitiveFileNames: true,
+			fileExists: (path) => this.host.fileExists(path),
+			readFile: (path) => this.host.readFile(path),
+			readDirectory: (path, extensions, exclude, include, depth) => {
+				if (!this.host.readDirectory) return [];
+				return this.host.readDirectory(path, extensions || [], exclude, include || [], depth);
+			}
+		};
+		{
+			const T = this.f.createIdentifier("T");
+			const Options = this.f.createIdentifier("Options");
+			this.intrinsicMetaDeclaration = this.f.createTypeAliasDeclaration([], "TypeAnnotation", [this.f.createTypeParameterDeclaration([], T), this.f.createTypeParameterDeclaration([], Options, void 0, this.f.createTypeReferenceNode("never"))], this.f.createTypeLiteralNode([this.f.createPropertySignature(void 0, "__meta", this.f.createToken(SyntaxKind.QuestionToken), this.f.createIntersectionTypeNode([this.f.createTypeReferenceNode("never"), this.f.createTupleTypeNode([this.f.createTypeReferenceNode(T), this.f.createTypeReferenceNode(Options)])]))]));
+		}
+	}
+	forHost(host) {
+		this.host = host;
+		this.resolver.host = host;
+		this.overriddenHost = true;
+		return this;
+	}
+	withReflection(config) {
+		const match = (path) => {
+			return {
+				mode: reflectionModeMatcher(config, path),
+				tsConfigPath: ""
+			};
+		};
+		const configResolver = {
+			...config,
+			path: "",
+			mergeStrategy: "replace",
+			compilerOptions: this.compilerOptions
+		};
+		this.overriddenConfigResolver = {
+			config: configResolver,
+			match
+		};
+		return this;
+	}
+	transformBundle(node) {
+		return node;
+	}
+	getTempResultIdentifier() {
+		if (this.tempResultIdentifier) return this.tempResultIdentifier;
+		const locals = isNodeWithLocals(this.sourceFile) ? this.sourceFile.locals : void 0;
+		if (locals) {
+			let found = "Ωr";
+			for (let i = 0;; i++) {
+				found = "Ωr" + (i ? i : "");
+				if (!locals.has(escapeLeadingUnderscores(found))) break;
+			}
+			this.tempResultIdentifier = this.f.createIdentifier(found);
+		} else this.tempResultIdentifier = this.f.createIdentifier("Ωr");
+		return this.tempResultIdentifier;
+	}
+	getConfigResolver(sourceFile) {
+		if (this.overriddenConfigResolver) return this.overriddenConfigResolver;
+		return getConfigResolver(this.cache.resolver, this.parseConfigHost, this.compilerOptions, sourceFile);
+	}
+	getReflectionConfig(sourceFile) {
+		return this.getConfigResolver(sourceFile).match(sourceFile.fileName);
+	}
+	isWithReflection(sourceFile, node) {
+		const mode = this.getExplicitReflectionMode(sourceFile, node);
+		if (mode === false) return false;
+		if (!sourceFile) return true;
+		const reflection = this.getReflectionConfig(sourceFile);
+		if (reflection.mode === "explicit") return mode === true;
+		return reflection.mode === "default";
+	}
+	transformSourceFile(sourceFile) {
+		this.sourceFile = sourceFile;
+		if (sourceFile.scriptKind !== ScriptKind.TS && sourceFile.scriptKind !== ScriptKind.TSX) return sourceFile;
+		if (sourceFile.deepkitTransformed) return sourceFile;
+		this.embedAssignType = false;
+		this.addImports = [];
+		this.additionalImports.clear();
+		const start = Date.now();
+		const configResolver = this.getConfigResolver(sourceFile);
+		const reflection = configResolver.match(sourceFile.fileName);
+		Object.assign(this.compilerOptions, configResolver.config.compilerOptions);
+		if (reflection.mode === "never") {
+			debug(`Transform file with reflection=${reflection.mode} took ${Date.now() - start}ms (${this.getModuleType()}) ${sourceFile.fileName} via config ${reflection.tsConfigPath || "none"}.`);
+			return sourceFile;
+		}
+		if (!sourceFile.locals) typescript.default.bindSourceFile(sourceFile, this.compilerOptions);
+		if (sourceFile.kind !== SyntaxKind.SourceFile) {
+			if ("undefined" === typeof require) throw new Error(`Invalid TypeScript library imported. SyntaxKind different ${sourceFile.kind} !== ${SyntaxKind.SourceFile}.`);
+			const path = require.resolve("typescript");
+			throw new Error(`Invalid TypeScript library imported. SyntaxKind different ${sourceFile.kind} !== ${SyntaxKind.SourceFile}. typescript package path: ${path}`);
+		}
+		const visitor = (node) => {
+			node = visitEachChild(node, visitor, this.context);
+			if (isInterfaceDeclaration(node) || isTypeAliasDeclaration(node) || isEnumDeclaration(node)) {
+				if (this.isWithReflection(sourceFile, node)) this.compileDeclarations.set(node, {
+					name: node.name,
+					sourceFile: this.sourceFile
+				});
+			}
+			if (isMethodDeclaration(node) && node.parent && node.body && isObjectLiteralExpression(node.parent)) {
+				let valid = true;
+				if (node.name.kind === SyntaxKind.Identifier && getIdentifierName(node.name) === "default") valid = false;
+				if (valid) {
+					const method = this.decorateFunctionExpression(this.f.createFunctionExpression(node.modifiers, node.asteriskToken, isIdentifier(node.name) ? node.name : void 0, node.typeParameters, node.parameters, node.type, node.body));
+					node = this.f.createPropertyAssignment(node.name, method);
+				}
+			}
+			if (isClassDeclaration(node)) return this.decorateClass(sourceFile, node);
+			else if (isParameter(node) && node.parent && node.type) {
+				const typeParameters = isConstructorDeclaration(node.parent) ? node.parent.parent.typeParameters : node.parent.typeParameters;
+				if (!typeParameters) return node;
+				const receiveType = getReceiveTypeParameter(node.type);
+				if (receiveType && receiveType.typeArguments) {
+					const first = receiveType.typeArguments[0];
+					if (first && isTypeReferenceNode(first) && isIdentifier(first.typeName)) {
+						const name = getIdentifierName(first.typeName);
+						const index = typeParameters.findIndex((v) => getIdentifierName(v.name) === name);
+						let container = this.f.createIdentifier("globalThis");
+						if (isArrowFunction(node.parent)) {
+							const next = this.getArrowFunctionΩPropertyAccessIdentifier(node.parent);
+							if (!next) return node;
+							container = next;
+						} else if ((isFunctionDeclaration(node.parent) || isFunctionExpression(node.parent)) && node.parent.name) container = node.parent.name;
+						else if (isMethodDeclaration(node.parent) && isIdentifier(node.parent.name)) container = this.f.createPropertyAccessExpression(this.f.createIdentifier("this"), node.parent.name);
+						else if (isConstructorDeclaration(node.parent)) container = this.f.createPropertyAccessExpression(this.f.createIdentifier("this"), "constructor");
+						return this.f.updateParameterDeclaration(node, node.modifiers, node.dotDotDotToken, node.name, node.questionToken, receiveType, this.f.createElementAccessChain(this.f.createPropertyAccessExpression(container, this.f.createIdentifier("Ω")), this.f.createToken(SyntaxKind.QuestionDotToken), this.f.createNumericLiteral(index)));
+					}
+				}
+			} else if (isClassExpression(node)) return this.decorateClass(sourceFile, node);
+			else if (isFunctionExpression(node)) return this.decorateFunctionExpression(this.injectResetΩ(node));
+			else if (isFunctionDeclaration(node)) return this.decorateFunctionDeclaration(this.injectResetΩ(node));
+			else if (isMethodDeclaration(node) || isConstructorDeclaration(node)) return this.injectResetΩ(node);
+			else if (isArrowFunction(node)) return this.decorateArrowFunction(this.injectResetΩ(node));
+			else if ((isNewExpression(node) || isCallExpression(node)) && node.typeArguments && node.typeArguments.length > 0) {
+				if (isCallExpression(node)) {
+					if (isIdentifier(node.expression) && [
+						"valuesOf",
+						"propertiesOf",
+						"typeOf"
+					].includes(getIdentifierName(node.expression))) {
+						const args = [...node.arguments];
+						if (!args.length) args.push(this.f.createArrayLiteralExpression());
+						const type = this.getTypeOfType(node.typeArguments[0]);
+						if (!type) return node;
+						args.push(type);
+						return this.f.updateCallExpression(node, node.expression, node.typeArguments, this.f.createNodeArray(args));
+					}
+				}
+				const expressionToCheck = getAssignTypeExpression(node.expression) || node.expression;
+				if (isArrowFunction(expressionToCheck)) return node;
+				const typeExpressions = [];
+				for (const a of node.typeArguments) {
+					const type = this.getTypeOfType(a);
+					typeExpressions.push(type || this.f.createIdentifier("undefined"));
+				}
+				let container = this.f.createIdentifier("globalThis");
+				if (isIdentifier(node.expression)) container = node.expression;
+				else if (isPropertyAccessExpression(node.expression)) container = node.expression;
+				const assignQ = this.f.createBinaryExpression(this.f.createPropertyAccessExpression(container, "Ω"), this.f.createToken(SyntaxKind.EqualsToken), this.f.createArrayLiteralExpression(typeExpressions));
+				const update = isNewExpression(node) ? this.f.updateNewExpression : this.f.updateCallExpression;
+				if (isPropertyAccessExpression(node.expression)) {
+					if (isCallExpression(node.expression.expression)) {
+						const r = this.getTempResultIdentifier();
+						const assignQ = this.f.createBinaryExpression(this.f.createPropertyAccessExpression(this.f.createPropertyAccessExpression(r, node.expression.name), "Ω"), this.f.createToken(SyntaxKind.EqualsToken), this.f.createArrayLiteralExpression(typeExpressions));
+						return update(node, this.f.createPropertyAccessExpression(this.f.createParenthesizedExpression(this.f.createBinaryExpression(this.f.createBinaryExpression(this.f.createBinaryExpression(r, this.f.createToken(typescript.default.SyntaxKind.EqualsToken), node.expression.expression), this.f.createToken(typescript.default.SyntaxKind.CommaToken), assignQ), this.f.createToken(typescript.default.SyntaxKind.CommaToken), r)), node.expression.name), node.typeArguments, node.arguments);
+					} else if (isParenthesizedExpression(node.expression.expression)) {
+						const r = this.getTempResultIdentifier();
+						const assignQ = this.f.createBinaryExpression(this.f.createPropertyAccessExpression(this.f.createPropertyAccessExpression(r, node.expression.name), "Ω"), this.f.createToken(SyntaxKind.EqualsToken), this.f.createArrayLiteralExpression(typeExpressions));
+						const updatedNode = update(node, this.f.updatePropertyAccessExpression(node.expression, this.f.updateParenthesizedExpression(node.expression.expression, this.f.createBinaryExpression(this.f.createBinaryExpression(this.f.createBinaryExpression(r, this.f.createToken(SyntaxKind.EqualsToken), node.expression.expression.expression), this.f.createToken(SyntaxKind.CommaToken), assignQ), this.f.createToken(SyntaxKind.CommaToken), r)), node.expression.name), node.typeArguments, node.arguments);
+						return this.f.createParenthesizedExpression(updatedNode);
+					}
+				}
+				return this.f.createParenthesizedExpression(this.f.createBinaryExpression(assignQ, this.f.createToken(SyntaxKind.CommaToken), node));
+			}
+			return node;
+		};
+		this.sourceFile = visitNode(this.sourceFile, visitor);
+		const newTopStatements = [];
+		while (true) {
+			let allCompiled = true;
+			for (const d of this.compileDeclarations.values()) {
+				if (d.compiled) continue;
+				allCompiled = false;
+				break;
+			}
+			if (this.embedDeclarations.size === 0 && allCompiled) break;
+			for (const [node, d] of [...this.compileDeclarations.entries()]) {
+				if (d.compiled) continue;
+				d.compiled = this.createProgramVarFromNode(node, d.name, this.sourceFile);
+			}
+			if (this.embedDeclarations.size) {
+				for (const node of this.embedDeclarations.keys()) this.compiledDeclarations.add(node);
+				const entries = Array.from(this.embedDeclarations.entries());
+				this.embedDeclarations.clear();
+				for (const [node, d] of entries) newTopStatements.push(...this.createProgramVarFromNode(node, d.name, d.sourceFile));
+			}
+		}
+		const compileDeclarations = (node) => {
+			node = visitEachChild(node, compileDeclarations, this.context);
+			if (isTypeAliasDeclaration(node) || isInterfaceDeclaration(node) || isEnumDeclaration(node)) {
+				const d = this.compileDeclarations.get(node);
+				if (!d) return node;
+				this.compileDeclarations.delete(node);
+				this.compiledDeclarations.add(node);
+				if (d.compiled) return [...d.compiled, node];
+			}
+			return node;
+		};
+		this.sourceFile = visitNode(this.sourceFile, compileDeclarations);
+		if (this.addImports.length) {
+			const handledIdentifier = [];
+			const importMap = /* @__PURE__ */ new Map();
+			for (const imp of this.addImports) {
+				if (handledIdentifier.includes(getIdentifierName(imp.identifier))) continue;
+				handledIdentifier.push(getIdentifierName(imp.identifier));
+				let arr = importMap.get(imp.importDeclaration);
+				if (!arr) {
+					arr = [];
+					importMap.set(imp.importDeclaration, arr);
+				}
+				arr.push(imp.identifier);
+			}
+			for (const [importDeclaration, identifiers] of importMap.entries()) {
+				if (this.additionalImports.has(importDeclaration)) throw new Error("Internal error: additional import already exists");
+				if (this.getModuleType() === "cjs") {
+					const varDeclaration = this.f.createVariableStatement(void 0, this.f.createVariableDeclarationList([this.f.createVariableDeclaration(this.f.createObjectBindingPattern(identifiers.map((identifier) => this.f.createBindingElement(void 0, void 0, identifier, void 0))), void 0, void 0, this.f.createCallExpression(this.f.createIdentifier("require"), void 0, [importDeclaration.moduleSpecifier]))], typescript.default.NodeFlags.None));
+					const typeDeclWithComment = addSyntheticLeadingComment(varDeclaration, SyntaxKind.MultiLineCommentTrivia, "@ts-ignore", true);
+					this.additionalImports.set(importDeclaration, typeDeclWithComment);
+				} else {
+					const namedImports = this.f.createNamedImports(identifiers.map((identifier) => this.f.createImportSpecifier(false, void 0, identifier)));
+					const importStatement = this.f.createImportDeclaration(void 0, this.f.createImportClause(false, void 0, namedImports), importDeclaration.moduleSpecifier);
+					const typeDeclWithComment = addSyntheticLeadingComment(importStatement, SyntaxKind.MultiLineCommentTrivia, "@ts-ignore", true);
+					this.additionalImports.set(importDeclaration, typeDeclWithComment);
+				}
+			}
+		}
+		if (this.embedAssignType) {
+			const assignType = this.f.createFunctionDeclaration(void 0, void 0, this.f.createIdentifier("__assignType"), void 0, [this.f.createParameterDeclaration(void 0, void 0, this.f.createIdentifier("fn"), void 0, void 0, void 0), this.f.createParameterDeclaration(void 0, void 0, this.f.createIdentifier("args"), void 0, void 0, void 0)], void 0, this.f.createBlock([this.f.createExpressionStatement(this.f.createBinaryExpression(this.f.createPropertyAccessExpression(this.f.createIdentifier("fn"), this.f.createIdentifier("__type")), this.f.createToken(SyntaxKind.EqualsToken), this.f.createIdentifier("args"))), this.f.createReturnStatement(this.f.createIdentifier("fn"))], true));
+			newTopStatements.push(assignType);
+		}
+		if (this.tempResultIdentifier) newTopStatements.push(this.f.createVariableStatement(void 0, this.f.createVariableDeclarationList([this.f.createVariableDeclaration(this.tempResultIdentifier, void 0, void 0, void 0)], typescript.default.NodeFlags.None)));
+		const indexOfFirstLiteralExpression = this.sourceFile.statements.findIndex((v) => isExpressionStatement(v) && isStringLiteral(v.expression));
+		const newStatements = indexOfFirstLiteralExpression === -1 ? [...newTopStatements, ...this.attachAdditionalStatements(this.sourceFile.statements)] : [
+			...this.sourceFile.statements.slice(0, indexOfFirstLiteralExpression + 1),
+			...newTopStatements,
+			...this.attachAdditionalStatements(this.sourceFile.statements.slice(indexOfFirstLiteralExpression + 1))
+		];
+		this.sourceFile = this.f.updateSourceFile(this.sourceFile, newStatements);
+		const took = Date.now() - start;
+		debug(`Transform file with reflection=${reflection.mode} took ${took}ms (${this.getModuleType()}) ${sourceFile.fileName} via config ${reflection.tsConfigPath || "none"}.`);
+		this.sourceFile.deepkitTransformed = true;
+		return this.sourceFile;
+	}
+	attachAdditionalStatements(statements) {
+		const result = [];
+		for (const statement of statements) {
+			if (isImportDeclaration(statement) || (0, typescript.isJSDocImportTag)(statement)) {
+				const additional = this.additionalImports.get(statement);
+				if (additional) result.push(additional);
+			}
+			result.push(statement);
+		}
+		return result;
+	}
+	getModuleType() {
+		if (this.compilerOptions.module === typescript.default.ModuleKind.Node16 || this.compilerOptions.module === typescript.default.ModuleKind.NodeNext) {
+			if (this.sourceFile.impliedNodeFormat === typescript.default.ModuleKind.ESNext) return "esm";
+			return "cjs";
+		}
+		return this.compilerOptions.module === typescript.default.ModuleKind.CommonJS ? "cjs" : "esm";
+	}
+	getArrowFunctionΩPropertyAccessIdentifier(node) {
+		let { parent } = node.original || node;
+		if (isVariableDeclaration(parent) && isIdentifier(parent.name)) return parent.name;
+		else if (isPropertyAssignment(parent) && isIdentifier(parent.name)) {
+			const names = [];
+			while (parent) if (isObjectLiteralExpression(parent)) parent = parent.parent;
+			else if (isVariableDeclaration(parent)) {
+				names.unshift(getIdentifierName(parent.name));
+				break;
+			} else if (isIdentifier(parent.name)) {
+				names.unshift(getIdentifierName(parent.name));
+				parent = parent.parent;
+			} else return;
+			return this.f.createIdentifier(names.join("."));
+		}
+	}
+	injectResetΩ(node) {
+		let hasReceiveType = false;
+		for (const param of node.parameters) if (param.type && getReceiveTypeParameter(param.type)) hasReceiveType = true;
+		if (!hasReceiveType) return node;
+		let container = this.f.createIdentifier("globalThis");
+		if (isArrowFunction(node)) {
+			const next = this.getArrowFunctionΩPropertyAccessIdentifier(node);
+			if (!next) return node;
+			container = next;
+		} else if ((isFunctionDeclaration(node) || isFunctionExpression(node)) && node.name) container = node.name;
+		else if (isMethodDeclaration(node) && isIdentifier(node.name)) container = this.f.createPropertyAccessExpression(this.f.createIdentifier("this"), node.name);
+		else if (isConstructorDeclaration(node)) container = this.f.createPropertyAccessExpression(this.f.createIdentifier("this"), "constructor");
+		const reset = this.f.createExpressionStatement(this.f.createBinaryExpression(this.f.createPropertyAccessExpression(container, this.f.createIdentifier("Ω")), this.f.createToken(typescript.default.SyntaxKind.EqualsToken), this.f.createIdentifier("undefined")));
+		let body = node.body && isBlock(node.body) ? node.body : void 0;
+		let bodyStatements = node.body && isBlock(node.body) ? [...node.body.statements] : [];
+		if (node.body) {
+			if (isExpression(node.body)) bodyStatements = [this.f.createReturnStatement(node.body)];
+			body = this.f.updateBlock(node.body, [reset, ...bodyStatements]);
+		}
+		if (isArrowFunction(node)) return this.f.updateArrowFunction(node, node.modifiers, node.typeParameters, node.parameters, node.type, node.equalsGreaterThanToken, body);
+		else if (isFunctionDeclaration(node)) return this.f.updateFunctionDeclaration(node, node.modifiers, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, body);
+		else if (isFunctionExpression(node)) return this.f.updateFunctionExpression(node, node.modifiers, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, body || node.body);
+		else if (isMethodDeclaration(node)) return this.f.updateMethodDeclaration(node, node.modifiers, node.asteriskToken, node.name, node.questionToken, node.typeParameters, node.parameters, node.type, body);
+		else if (isConstructorDeclaration(node)) return this.f.updateConstructorDeclaration(node, node.modifiers, node.parameters, body);
+		return node;
+	}
+	createProgramVarFromNode(node, name, sourceFile) {
+		const typeProgram = new CompilerProgram(node, sourceFile);
+		if ((isTypeAliasDeclaration(node) || isInterfaceDeclaration(node)) && node.typeParameters) for (const param of node.typeParameters) {
+			if (param.default) this.extractPackStructOfType(param.default, typeProgram);
+			typeProgram.pushTemplateParameter(getIdentifierName(param.name), !!param.default);
+		}
+		this.extractPackStructOfType(node, typeProgram);
+		if (isTypeAliasDeclaration(node) || isInterfaceDeclaration(node) || isClassDeclaration(node) || isClassExpression(node)) typeProgram.pushOp(_deepkit_type_spec.ReflectionOp.nominal);
+		const typeProgramExpression = this.packOpsAndStack(typeProgram);
+		const variable = this.f.createVariableStatement([], this.f.createVariableDeclarationList([this.f.createVariableDeclaration(this.getDeclarationVariableName(name), void 0, void 0, typeProgramExpression)], NodeFlags.Const));
+		if (hasModifier(node, SyntaxKind.ExportKeyword)) return [variable, this.f.createExportDeclaration(void 0, false, this.f.createNamedExports([this.f.createExportSpecifier(false, this.getDeclarationVariableName(name), this.getDeclarationVariableName(name))]))];
+		return [variable];
+	}
+	extractPackStructOfExpression(node, program) {
+		switch (node.kind) {
+			case SyntaxKind.StringLiteral:
+				program.pushOp(_deepkit_type_spec.ReflectionOp.string);
+				return;
+			case SyntaxKind.NumericLiteral:
+				program.pushOp(_deepkit_type_spec.ReflectionOp.number);
+				return;
+			case SyntaxKind.FalseKeyword:
+			case SyntaxKind.TrueKeyword:
+				program.pushOp(_deepkit_type_spec.ReflectionOp.boolean);
+				return;
+			case SyntaxKind.BigIntLiteral:
+				program.pushOp(_deepkit_type_spec.ReflectionOp.bigint);
+				return;
+			case SyntaxKind.CallExpression: {
+				const call = node;
+				if (isIdentifier(call.expression) && getIdentifierName(call.expression) === "Symbol") {
+					program.pushOp(_deepkit_type_spec.ReflectionOp.symbol);
+					return;
+				}
+				break;
+			}
+			case SyntaxKind.NewExpression: {
+				const call = node;
+				if (isIdentifier(call.expression)) {
+					const op = {
+						"Date": _deepkit_type_spec.ReflectionOp.date,
+						"RegExp": _deepkit_type_spec.ReflectionOp.regexp,
+						"Uint8Array": _deepkit_type_spec.ReflectionOp.uint8Array,
+						"Uint8ClampedArray": _deepkit_type_spec.ReflectionOp.uint8ClampedArray,
+						"Uint16Array": _deepkit_type_spec.ReflectionOp.uint16Array,
+						"Uint32Array": _deepkit_type_spec.ReflectionOp.uint32Array,
+						"Int8Array": _deepkit_type_spec.ReflectionOp.int8Array,
+						"Int16Array": _deepkit_type_spec.ReflectionOp.int16Array,
+						"Int32Array": _deepkit_type_spec.ReflectionOp.int32Array,
+						"Float32Array": _deepkit_type_spec.ReflectionOp.float32Array,
+						"Float64Array": _deepkit_type_spec.ReflectionOp.float64Array,
+						"ArrayBuffer": _deepkit_type_spec.ReflectionOp.arrayBuffer
+					}[getIdentifierName(call.expression)];
+					if (op) {
+						program.pushOp(op);
+						return;
+					}
+				}
+				break;
+			}
+		}
+		program.pushOp(_deepkit_type_spec.ReflectionOp.never);
+	}
+	extractPackStructOfType(node, program) {
+		if (isParenthesizedTypeNode(node)) return this.extractPackStructOfType(node.type, program);
+		switch (node.kind) {
+			case SyntaxKind.StringKeyword:
+				program.pushOp(_deepkit_type_spec.ReflectionOp.string);
+				break;
+			case SyntaxKind.NumberKeyword:
+				program.pushOp(_deepkit_type_spec.ReflectionOp.number);
+				break;
+			case SyntaxKind.BooleanKeyword:
+				program.pushOp(_deepkit_type_spec.ReflectionOp.boolean);
+				break;
+			case SyntaxKind.BigIntKeyword:
+				program.pushOp(_deepkit_type_spec.ReflectionOp.bigint);
+				break;
+			case SyntaxKind.VoidKeyword:
+				program.pushOp(_deepkit_type_spec.ReflectionOp.void);
+				break;
+			case SyntaxKind.UnknownKeyword:
+				program.pushOp(_deepkit_type_spec.ReflectionOp.unknown);
+				break;
+			case SyntaxKind.ObjectKeyword:
+				program.pushOp(_deepkit_type_spec.ReflectionOp.object);
+				break;
+			case SyntaxKind.SymbolKeyword:
+				program.pushOp(_deepkit_type_spec.ReflectionOp.symbol);
+				break;
+			case SyntaxKind.NullKeyword:
+				program.pushOp(_deepkit_type_spec.ReflectionOp.null);
+				break;
+			case SyntaxKind.NeverKeyword:
+				program.pushOp(_deepkit_type_spec.ReflectionOp.never);
+				break;
+			case SyntaxKind.AnyKeyword:
+				program.pushOp(_deepkit_type_spec.ReflectionOp.any);
+				break;
+			case SyntaxKind.UndefinedKeyword:
+				program.pushOp(_deepkit_type_spec.ReflectionOp.undefined);
+				break;
+			case SyntaxKind.TrueKeyword:
+				program.pushOp(_deepkit_type_spec.ReflectionOp.literal, program.pushStack(this.f.createTrue()));
+				break;
+			case SyntaxKind.FalseKeyword:
+				program.pushOp(_deepkit_type_spec.ReflectionOp.literal, program.pushStack(this.f.createFalse()));
+				break;
+			case SyntaxKind.ClassDeclaration:
+			case SyntaxKind.ClassExpression: {
+				const narrowed = node;
+				if (node) {
+					const jsDocNode = narrowed.name?.parent || narrowed;
+					this.withJSDocTypeAnnotations(program, jsDocNode, () => {
+						const members = [];
+						if (narrowed.typeParameters) for (const typeParameter of narrowed.typeParameters) {
+							const name = getNameAsString(typeParameter.name);
+							if (typeParameter.default) this.extractPackStructOfType(typeParameter.default, program);
+							program.pushTemplateParameter(name, !!typeParameter.default);
+						}
+						if (narrowed.heritageClauses) {
+							for (const heritage of narrowed.heritageClauses) if (heritage.token === SyntaxKind.ExtendsKeyword) for (const extendType of heritage.types) {
+								program.pushFrame();
+								if (extendType.typeArguments) for (const typeArgument of extendType.typeArguments) this.extractPackStructOfType(typeArgument, program);
+								const index = program.pushStack(this.f.createArrowFunction(void 0, void 0, [], void 0, void 0, this.nodeConverter.toExpression(extendType.expression)));
+								program.pushOp(_deepkit_type_spec.ReflectionOp.classReference, index);
+								program.popFrameImplicit();
+							}
+						}
+						for (const member of narrowed.members) {
+							const name = getNameAsString(member.name);
+							if (name) {
+								if (members.some((v) => getNameAsString(v.name) === name)) continue;
+							}
+							members.push(member);
+							this.extractPackStructOfType(member, program);
+						}
+						program.pushOp(_deepkit_type_spec.ReflectionOp.class);
+						if (narrowed.heritageClauses) {
+							for (const heritageClause of narrowed.heritageClauses) if (heritageClause.token === SyntaxKind.ExtendsKeyword) {
+								const first = heritageClause.types[0];
+								if (isExpressionWithTypeArguments(first) && first.typeArguments) {
+									for (const typeArgument of first.typeArguments) this.extractPackStructOfType(typeArgument, program);
+									program.pushOp(_deepkit_type_spec.ReflectionOp.classExtends, first.typeArguments.length);
+								}
+							} else if (heritageClause.token === SyntaxKind.ImplementsKeyword) {
+								for (const type of heritageClause.types) this.extractPackStructOfTypeReference(type, program);
+								program.pushOp(_deepkit_type_spec.ReflectionOp.implements, heritageClause.types.length);
+							}
+						}
+						if (narrowed.name) this.resolveTypeName(getIdentifierName(narrowed.name), program);
+					});
+				}
+				break;
+			}
+			case SyntaxKind.IntersectionType: {
+				const narrowed = node;
+				program.pushFrame();
+				for (const type of narrowed.types) this.extractPackStructOfType(type, program);
+				program.pushOp(_deepkit_type_spec.ReflectionOp.intersection);
+				program.popFrameImplicit();
+				break;
+			}
+			case SyntaxKind.MappedType: {
+				const narrowed = node;
+				program.pushFrame();
+				program.pushVariable(getIdentifierName(narrowed.typeParameter.name));
+				const constraint = getEffectiveConstraintOfTypeParameter(narrowed.typeParameter);
+				if (constraint) this.extractPackStructOfType(constraint, program);
+				else program.pushOp(_deepkit_type_spec.ReflectionOp.never);
+				let modifier = 0;
+				if (narrowed.questionToken) {
+					if (narrowed.questionToken.kind === SyntaxKind.QuestionToken) modifier |= 1;
+					if (narrowed.questionToken.kind === SyntaxKind.MinusToken) modifier |= 2;
+				}
+				if (narrowed.readonlyToken) {
+					if (narrowed.readonlyToken.kind === SyntaxKind.ReadonlyKeyword) modifier |= 4;
+					if (narrowed.readonlyToken.kind === SyntaxKind.MinusToken) modifier |= 8;
+				}
+				program.pushCoRoutine();
+				if (narrowed.nameType) program.pushFrame();
+				if (narrowed.type) this.extractPackStructOfType(narrowed.type, program);
+				else program.pushOp(_deepkit_type_spec.ReflectionOp.never);
+				if (narrowed.nameType) {
+					this.extractPackStructOfType(narrowed.nameType, program);
+					program.pushOp(_deepkit_type_spec.ReflectionOp.tuple);
+					program.popFrameImplicit();
+				}
+				const coRoutineIndex = program.popCoRoutine();
+				if (narrowed.nameType) program.pushOp(_deepkit_type_spec.ReflectionOp.mappedType2, coRoutineIndex, modifier);
+				else program.pushOp(_deepkit_type_spec.ReflectionOp.mappedType, coRoutineIndex, modifier);
+				program.popFrameImplicit();
+				break;
+			}
+			case SyntaxKind.TypeAliasDeclaration: {
+				let narrowed = node;
+				if (program.sourceFile && getNameAsString(narrowed.name) === "TypeAnnotation") {
+					if (extractJSDocAttribute(program.sourceFile, narrowed, "intrinsic") !== void 0) narrowed = this.intrinsicMetaDeclaration;
+				}
+				if (isTypeLiteralNode(narrowed.type) || isInterfaceDeclaration(narrowed.type)) {
+					this.extractPackStructOfType(narrowed.type, program);
+					if (narrowed.name) this.resolveTypeName(getIdentifierName(narrowed.name), program);
+				} else this.withJSDocTypeAnnotations(program, narrowed, () => {
+					this.extractPackStructOfType(narrowed.type, program);
+					if (narrowed.name) this.resolveTypeName(getIdentifierName(narrowed.name), program);
+				});
+				break;
+			}
+			case SyntaxKind.TypeLiteral:
+			case SyntaxKind.InterfaceDeclaration: {
+				const narrowed = node;
+				let descriptionNode = narrowed;
+				if (isTypeLiteralNode(narrowed)) descriptionNode = narrowed.parent;
+				this.withJSDocTypeAnnotations(program, descriptionNode, () => {
+					program.pushFrame();
+					if (isInterfaceDeclaration(narrowed) && narrowed.heritageClauses) {
+						for (const heritage of narrowed.heritageClauses) if (heritage.token === SyntaxKind.ExtendsKeyword) for (const extendType of heritage.types) this.extractPackStructOfTypeReference(extendType, program);
+					}
+					for (const member of narrowed.members) this.extractPackStructOfType(member, program);
+					program.pushOp(_deepkit_type_spec.ReflectionOp.objectLiteral);
+					if (isInterfaceDeclaration(narrowed)) {
+						if (narrowed.name) this.resolveTypeName(getIdentifierName(narrowed.name), program);
+					}
+					program.popFrameImplicit();
+				});
+				break;
+			}
+			case SyntaxKind.TypeReference:
+				this.extractPackStructOfTypeReference(node, program);
+				break;
+			case SyntaxKind.ArrayType:
+				this.extractPackStructOfType(node.elementType, program);
+				program.pushOp(_deepkit_type_spec.ReflectionOp.array);
+				break;
+			case SyntaxKind.RestType: {
+				let type = node.type;
+				if (isArrayTypeNode(type)) type = type.elementType;
+				this.extractPackStructOfType(type, program);
+				program.pushOp(_deepkit_type_spec.ReflectionOp.rest);
+				break;
+			}
+			case SyntaxKind.TupleType:
+				program.pushFrame();
+				for (const element of node.elements) if (isOptionalTypeNode(element)) {
+					this.extractPackStructOfType(element.type, program);
+					program.pushOp(_deepkit_type_spec.ReflectionOp.tupleMember);
+					program.pushOp(_deepkit_type_spec.ReflectionOp.optional);
+				} else if (isNamedTupleMember(element)) {
+					if (element.dotDotDotToken) {
+						let type = element.type;
+						if (isArrayTypeNode(type)) type = type.elementType;
+						this.extractPackStructOfType(type, program);
+						program.pushOp(_deepkit_type_spec.ReflectionOp.rest);
+					} else this.extractPackStructOfType(element.type, program);
+					const index = program.findOrAddStackEntry(getIdentifierName(element.name));
+					program.pushOp(_deepkit_type_spec.ReflectionOp.namedTupleMember, index);
+					if (element.questionToken) program.pushOp(_deepkit_type_spec.ReflectionOp.optional);
+				} else this.extractPackStructOfType(element, program);
+				program.pushOp(_deepkit_type_spec.ReflectionOp.tuple);
+				program.popFrameImplicit();
+				break;
+			case SyntaxKind.PropertySignature: {
+				const narrowed = node;
+				if (narrowed.type) {
+					const description = this.withJSDocTypeAnnotations(program, narrowed, () => {
+						this.extractPackStructOfType(narrowed.type, program);
+					}, { applyDescriptionOp: false });
+					const name = getPropertyName(this.f, narrowed.name);
+					program.pushOp(_deepkit_type_spec.ReflectionOp.propertySignature, program.findOrAddStackEntry(name));
+					if (narrowed.questionToken) program.pushOp(_deepkit_type_spec.ReflectionOp.optional);
+					if (hasModifier(narrowed, SyntaxKind.ReadonlyKeyword)) program.pushOp(_deepkit_type_spec.ReflectionOp.readonly);
+					if (description) program.pushOp(_deepkit_type_spec.ReflectionOp.description, program.findOrAddStackEntry(description));
+				} else program.pushOp(_deepkit_type_spec.ReflectionOp.unknown);
+				break;
+			}
+			case SyntaxKind.PropertyDeclaration: {
+				const narrowed = node;
+				if (false === this.getExplicitReflectionMode(program.sourceFile, narrowed)) return;
+				const description = this.withJSDocTypeAnnotations(program, narrowed, () => {
+					if (narrowed.type) this.extractPackStructOfType(narrowed.type, program);
+					else if (narrowed.initializer) this.extractPackStructOfExpression(narrowed.initializer, program);
+					else program.pushOp(_deepkit_type_spec.ReflectionOp.unknown);
+				}, { applyDescriptionOp: false });
+				const name = getPropertyName(this.f, narrowed.name);
+				program.pushOp(_deepkit_type_spec.ReflectionOp.property, program.findOrAddStackEntry(name));
+				if (narrowed.questionToken) program.pushOp(_deepkit_type_spec.ReflectionOp.optional);
+				if (hasModifier(narrowed, SyntaxKind.ReadonlyKeyword)) program.pushOp(_deepkit_type_spec.ReflectionOp.readonly);
+				if (hasModifier(narrowed, SyntaxKind.PrivateKeyword)) program.pushOp(_deepkit_type_spec.ReflectionOp.private);
+				if (hasModifier(narrowed, SyntaxKind.ProtectedKeyword)) program.pushOp(_deepkit_type_spec.ReflectionOp.protected);
+				if (hasModifier(narrowed, SyntaxKind.AbstractKeyword)) program.pushOp(_deepkit_type_spec.ReflectionOp.abstract);
+				if (hasModifier(narrowed, SyntaxKind.StaticKeyword)) program.pushOp(_deepkit_type_spec.ReflectionOp.static);
+				if (narrowed.initializer) program.pushOp(_deepkit_type_spec.ReflectionOp.defaultValue, program.findOrAddStackEntry(this.f.createFunctionExpression(void 0, void 0, void 0, void 0, void 0, void 0, this.f.createBlock([this.f.createReturnStatement(narrowed.initializer)]))));
+				if (description) program.pushOp(_deepkit_type_spec.ReflectionOp.description, program.findOrAddStackEntry(description));
+				break;
+			}
+			case SyntaxKind.ConditionalType: {
+				const narrowed = node;
+				const distributiveOverIdentifier = isTypeReferenceNode(narrowed.checkType) && isIdentifier(narrowed.checkType.typeName) ? narrowed.checkType.typeName : void 0;
+				if (distributiveOverIdentifier) {
+					program.pushFrame();
+					this.extractPackStructOfType(narrowed.checkType, program);
+					program.pushVariable(getIdentifierName(distributiveOverIdentifier));
+					program.pushCoRoutine();
+				}
+				program.pushConditionalFrame();
+				this.extractPackStructOfType(narrowed.checkType, program);
+				this.extractPackStructOfType(narrowed.extendsType, program);
+				program.pushOp(_deepkit_type_spec.ReflectionOp.extends);
+				program.pushCoRoutine();
+				this.extractPackStructOfType(narrowed.trueType, program);
+				const trueProgram = program.popCoRoutine();
+				program.pushCoRoutine();
+				this.extractPackStructOfType(narrowed.falseType, program);
+				const falseProgram = program.popCoRoutine();
+				program.pushOp(_deepkit_type_spec.ReflectionOp.jumpCondition, trueProgram, falseProgram);
+				program.moveFrame();
+				if (distributiveOverIdentifier) {
+					const coRoutineIndex = program.popCoRoutine();
+					program.pushOp(_deepkit_type_spec.ReflectionOp.distribute, coRoutineIndex);
+					program.popFrameImplicit();
+				}
+				break;
+			}
+			case SyntaxKind.InferType: {
+				const narrowed = node;
+				const frame = program.findConditionalFrame();
+				if (frame) {
+					const typeParameterName = getIdentifierName(narrowed.typeParameter.name);
+					let variable = program.findVariable(typeParameterName);
+					if (!variable) {
+						program.pushVariable(typeParameterName, frame);
+						variable = program.findVariable(typeParameterName);
+						if (!variable) throw new Error("Could not find inserted infer variable");
+					}
+					program.pushOp(_deepkit_type_spec.ReflectionOp.infer, variable.frameOffset, variable.stackIndex);
+				} else program.pushOp(_deepkit_type_spec.ReflectionOp.never);
+				break;
+			}
+			case SyntaxKind.MethodSignature:
+			case SyntaxKind.MethodDeclaration:
+			case SyntaxKind.Constructor:
+			case SyntaxKind.ArrowFunction:
+			case SyntaxKind.FunctionExpression:
+			case SyntaxKind.ConstructSignature:
+			case SyntaxKind.ConstructorType:
+			case SyntaxKind.FunctionType:
+			case SyntaxKind.CallSignature:
+			case SyntaxKind.FunctionDeclaration: {
+				const narrowed = node;
+				if (false === this.getExplicitReflectionMode(program.sourceFile, narrowed)) {
+					program.pushOp(_deepkit_type_spec.ReflectionOp.any);
+					return;
+				}
+				const name = isCallSignatureDeclaration(node) ? "" : isConstructorTypeNode(narrowed) || isConstructSignatureDeclaration(node) ? "new" : isConstructorDeclaration(narrowed) ? "constructor" : getPropertyName(this.f, narrowed.name);
+				if (!narrowed.type && narrowed.parameters.length === 0 && !name) return;
+				program.pushFrame();
+				for (let i = 0; i < narrowed.parameters.length; i++) {
+					const parameter = narrowed.parameters[i];
+					const parameterName = isIdentifier(parameter.name) ? getNameAsString(parameter.name) : "param" + i;
+					const type = parameter.type ? parameter.dotDotDotToken && isArrayTypeNode(parameter.type) ? parameter.type.elementType : parameter.type : void 0;
+					const description = this.withJSDocTypeAnnotations(program, parameter, () => {
+						if (type) this.extractPackStructOfType(type, program);
+						else program.pushOp(_deepkit_type_spec.ReflectionOp.any);
+					}, { applyDescriptionOp: false });
+					if (parameter.dotDotDotToken) program.pushOp(_deepkit_type_spec.ReflectionOp.rest);
+					program.pushOp(_deepkit_type_spec.ReflectionOp.parameter, program.findOrAddStackEntry(parameterName));
+					if (parameter.questionToken) program.pushOp(_deepkit_type_spec.ReflectionOp.optional);
+					if (hasModifier(parameter, SyntaxKind.PublicKeyword)) program.pushOp(_deepkit_type_spec.ReflectionOp.public);
+					if (hasModifier(parameter, SyntaxKind.PrivateKeyword)) program.pushOp(_deepkit_type_spec.ReflectionOp.private);
+					if (hasModifier(parameter, SyntaxKind.ProtectedKeyword)) program.pushOp(_deepkit_type_spec.ReflectionOp.protected);
+					if (hasModifier(parameter, SyntaxKind.ReadonlyKeyword)) program.pushOp(_deepkit_type_spec.ReflectionOp.readonly);
+					if (description) program.pushOp(_deepkit_type_spec.ReflectionOp.description, program.findOrAddStackEntry(description));
+					if (parameter.initializer && parameter.type && !getReceiveTypeParameter(parameter.type)) program.pushOp(_deepkit_type_spec.ReflectionOp.defaultValue, program.findOrAddStackEntry(this.f.createArrowFunction(void 0, void 0, [], void 0, void 0, parameter.initializer)));
+				}
+				if (narrowed.type) this.extractPackStructOfType(narrowed.type, program);
+				else program.pushOp(_deepkit_type_spec.ReflectionOp.any);
+				program.pushOp(isCallSignatureDeclaration(node) ? _deepkit_type_spec.ReflectionOp.callSignature : isMethodSignature(narrowed) || isConstructSignatureDeclaration(narrowed) ? _deepkit_type_spec.ReflectionOp.methodSignature : isMethodDeclaration(narrowed) || isConstructorDeclaration(narrowed) ? _deepkit_type_spec.ReflectionOp.method : _deepkit_type_spec.ReflectionOp.function, program.findOrAddStackEntry(name));
+				if ((isMethodSignature(narrowed) || isMethodDeclaration(narrowed)) && narrowed.questionToken) program.pushOp(_deepkit_type_spec.ReflectionOp.optional);
+				if (isMethodDeclaration(narrowed)) {
+					if (hasModifier(narrowed, SyntaxKind.PrivateKeyword)) program.pushOp(_deepkit_type_spec.ReflectionOp.private);
+					if (hasModifier(narrowed, SyntaxKind.ProtectedKeyword)) program.pushOp(_deepkit_type_spec.ReflectionOp.protected);
+					if (hasModifier(narrowed, SyntaxKind.AbstractKeyword)) program.pushOp(_deepkit_type_spec.ReflectionOp.abstract);
+					if (hasModifier(narrowed, SyntaxKind.StaticKeyword)) program.pushOp(_deepkit_type_spec.ReflectionOp.static);
+				}
+				const { description } = this.collectJSDocAnnotations(narrowed);
+				if (description) program.pushOp(_deepkit_type_spec.ReflectionOp.description, program.findOrAddStackEntry(description));
+				program.popFrameImplicit();
+				break;
+			}
+			case SyntaxKind.LiteralType: {
+				const narrowed = node;
+				if (narrowed.literal.kind === SyntaxKind.NullKeyword) program.pushOp(_deepkit_type_spec.ReflectionOp.null);
+				else program.pushOp(_deepkit_type_spec.ReflectionOp.literal, program.findOrAddStackEntry(narrowed.literal));
+				break;
+			}
+			case SyntaxKind.TemplateLiteralType: {
+				const narrowed = node;
+				program.pushFrame();
+				if (narrowed.head.rawText) program.pushOp(_deepkit_type_spec.ReflectionOp.literal, program.findOrAddStackEntry(narrowed.head.rawText));
+				for (const span of narrowed.templateSpans) {
+					this.extractPackStructOfType(span.type, program);
+					if (span.literal.rawText) program.pushOp(_deepkit_type_spec.ReflectionOp.literal, program.findOrAddStackEntry(span.literal.rawText));
+				}
+				program.pushOp(_deepkit_type_spec.ReflectionOp.templateLiteral);
+				program.popFrameImplicit();
+				break;
+			}
+			case SyntaxKind.UnionType: {
+				const narrowed = node;
+				if (narrowed.types.length === 0) {} else if (narrowed.types.length === 1) this.extractPackStructOfType(narrowed.types[0], program);
+				else {
+					program.pushFrame();
+					for (const subType of narrowed.types) this.extractPackStructOfType(subType, program);
+					program.pushOp(_deepkit_type_spec.ReflectionOp.union);
+					program.popFrameImplicit();
+				}
+				break;
+			}
+			case SyntaxKind.EnumDeclaration: {
+				const narrowed = node;
+				program.pushFrame();
+				for (const type of narrowed.members) {
+					const name = getPropertyName(this.f, type.name);
+					program.pushOp(_deepkit_type_spec.ReflectionOp.enumMember, program.findOrAddStackEntry(name));
+					if (type.initializer) program.pushOp(_deepkit_type_spec.ReflectionOp.defaultValue, program.findOrAddStackEntry(this.f.createArrowFunction(void 0, void 0, [], void 0, void 0, type.initializer)));
+				}
+				program.pushOp(_deepkit_type_spec.ReflectionOp.enum);
+				const { description } = this.collectJSDocAnnotations(narrowed);
+				if (description) program.pushOp(_deepkit_type_spec.ReflectionOp.description, program.findOrAddStackEntry(description));
+				if (narrowed.name) this.resolveTypeName(getIdentifierName(narrowed.name), program);
+				program.popFrameImplicit();
+				break;
+			}
+			case SyntaxKind.IndexSignature: {
+				const narrowed = node;
+				if (narrowed.parameters.length && narrowed.parameters[0].type) this.extractPackStructOfType(narrowed.parameters[0].type, program);
+				else program.pushOp(_deepkit_type_spec.ReflectionOp.any);
+				this.extractPackStructOfType(narrowed.type, program);
+				program.pushOp(_deepkit_type_spec.ReflectionOp.indexSignature);
+				break;
+			}
+			case SyntaxKind.TypeQuery: {
+				const narrowed = node;
+				if (isIdentifier(narrowed.exprName)) {
+					const resolved = this.resolveDeclaration(narrowed.exprName);
+					if (resolved && findSourceFile(resolved.declaration) !== this.sourceFile && resolved.importDeclaration) ensureImportIsEmitted(resolved.importDeclaration, narrowed.exprName);
+				}
+				const expression = serializeEntityNameAsExpression(this.f, narrowed.exprName);
+				program.pushOp(_deepkit_type_spec.ReflectionOp.typeof, program.pushStack(this.f.createArrowFunction(void 0, void 0, [], void 0, void 0, expression)));
+				break;
+			}
+			case SyntaxKind.TypeOperator: {
+				const narrowed = node;
+				if (narrowed.type.kind === SyntaxKind.ThisType) {
+					program.pushOp(_deepkit_type_spec.ReflectionOp.any);
+					break;
+				}
+				switch (narrowed.operator) {
+					case SyntaxKind.KeyOfKeyword:
+						this.extractPackStructOfType(narrowed.type, program);
+						program.pushOp(_deepkit_type_spec.ReflectionOp.keyof);
+						break;
+					case SyntaxKind.ReadonlyKeyword:
+						this.extractPackStructOfType(narrowed.type, program);
+						program.pushOp(_deepkit_type_spec.ReflectionOp.readonly);
+						break;
+					default: program.pushOp(_deepkit_type_spec.ReflectionOp.never);
+				}
+				break;
+			}
+			case SyntaxKind.IndexedAccessType: {
+				const narrowed = node;
+				this.extractPackStructOfType(narrowed.objectType, program);
+				this.extractPackStructOfType(narrowed.indexType, program);
+				program.pushOp(_deepkit_type_spec.ReflectionOp.indexAccess);
+				break;
+			}
+			case SyntaxKind.Identifier: {
+				const narrowed = node;
+				const variable = program.findVariable(getIdentifierName(narrowed));
+				if (variable) program.pushOp(_deepkit_type_spec.ReflectionOp.loads, variable.frameOffset, variable.stackIndex);
+				else program.pushOp(_deepkit_type_spec.ReflectionOp.never);
+				break;
+			}
+			default: program.pushOp(_deepkit_type_spec.ReflectionOp.never);
+		}
+	}
+	getGlobalLibs() {
+		if (this.cache.globalSourceFiles) return this.cache.globalSourceFiles;
+		this.cache.globalSourceFiles = [];
+		const options = { ...this.compilerOptions };
+		if (options.target && options.target === ScriptTarget.ESNext) options.target = ScriptTarget.ES2022;
+		const libs = (0, _typescript_vfs.knownLibFilesForCompilerOptions)(options, typescript.default);
+		for (const lib of libs) {
+			if (this.isExcluded(lib)) continue;
+			const sourceFile = this.resolver.resolveSourceFile(this.sourceFile, this.f.createStringLiteral("typescript/lib/" + lib.replace(".d.ts", "")));
+			if (!sourceFile) continue;
+			this.cache.globalSourceFiles.push(sourceFile);
+		}
+		return this.cache.globalSourceFiles;
+	}
+	/**
+	* This is a custom resolver based on populated `locals` from the binder. It uses a custom resolution algorithm since
+	* we have no access to the binder/TypeChecker directly and instantiating a TypeChecker per file/transformer is incredible slow.
+	*/
+	resolveDeclaration(typeName) {
+		let current = typeName.parent;
+		if (typeName.kind === SyntaxKind.QualifiedName) return;
+		let declaration = void 0;
+		while (current) {
+			if (isNodeWithLocals(current) && current.locals) {
+				const found = current.locals.get(typeName.escapedText);
+				if (found && found.declarations && found.declarations[0]) {
+					/**
+					* Discard parameters, since they can not be referenced from inside
+					*
+					* ```typescript
+					* type B = string;
+					* function a(B: B) {}
+					*
+					* class A {
+					*    constructor(B: B) {}
+					* }
+					* ```
+					*
+					*/
+					if (!isParameter(found.declarations[0])) {
+						declaration = found.declarations[0];
+						break;
+					}
+				}
+			}
+			if (current.kind === SyntaxKind.SourceFile) break;
+			current = current.parent;
+		}
+		if (!declaration) for (const file of this.getGlobalLibs()) {
+			const globals = getGlobalsOfSourceFile(file);
+			if (!globals) continue;
+			const symbol = globals.get(typeName.escapedText);
+			if (symbol && symbol.declarations && symbol.declarations[0]) {
+				declaration = symbol.declarations[0];
+				break;
+			}
+		}
+		let importDeclaration = void 0;
+		let typeOnly = false;
+		if (declaration && isImportSpecifier(declaration)) {
+			if (declaration.isTypeOnly) typeOnly = true;
+			importDeclaration = declaration.parent.parent.parent;
+		} else if (declaration && isImportDeclaration(declaration)) importDeclaration = declaration;
+		else if (declaration && isImportClause(declaration)) importDeclaration = declaration.parent;
+		if (importDeclaration) {
+			if (importDeclaration.importClause && importDeclaration.importClause.isTypeOnly) typeOnly = true;
+			declaration = this.resolveImportSpecifier(getEscapedText(typeName), importDeclaration, this.sourceFile);
+		}
+		if (declaration && declaration.kind === SyntaxKind.TypeParameter && declaration.parent.kind === SyntaxKind.TypeAliasDeclaration) declaration = declaration.parent;
+		if (!declaration) return;
+		return {
+			declaration,
+			importDeclaration,
+			typeOnly
+		};
+	}
+	getDeclarationVariableName(typeName) {
+		if (isIdentifier(typeName)) return this.f.createIdentifier("__Ω" + getIdentifierName(typeName));
+		function joinQualifiedName(name) {
+			if (isIdentifier(name)) return getIdentifierName(name);
+			return joinQualifiedName(name.left) + "_" + getIdentifierName(name.right);
+		}
+		return this.f.createIdentifier("__Ω" + joinQualifiedName(typeName));
+	}
+	/**
+	* The semantic of isExcluded is different from checking if the fileName is part
+	* of reflection config option. isExcluded checks if the file should be excluded
+	* via the exclude option. mainly used to exclude globals and external libraries.
+	*/
+	isExcluded(fileName) {
+		const resolver = this.overriddenConfigResolver || getConfigResolver(this.cache.resolver, this.parseConfigHost, this.compilerOptions, this.sourceFile);
+		return reflectionModeMatcher({
+			reflection: "default",
+			exclude: resolver.config.exclude
+		}, fileName) === "never";
+	}
+	extractPackStructOfTypeReference(type, program) {
+		const typeName = isTypeReferenceNode(type) ? type.typeName : isIdentifier(type.expression) ? type.expression : void 0;
+		if (!typeName) {
+			program.pushOp(_deepkit_type_spec.ReflectionOp.any);
+			return;
+		}
+		if (isIdentifier(typeName) && getIdentifierName(typeName) === "InlineRuntimeType" && type.typeArguments && type.typeArguments[0] && isTypeQueryNode(type.typeArguments[0])) {
+			const expression = serializeEntityNameAsExpression(this.f, type.typeArguments[0].exprName);
+			program.pushOp(_deepkit_type_spec.ReflectionOp.arg, program.pushStack(expression));
+			return;
+		}
+		if (isIdentifier(typeName) && getIdentifierName(typeName) !== "constructor" && this.knownClasses[getIdentifierName(typeName)]) {
+			const name = getIdentifierName(typeName);
+			const op = this.knownClasses[name];
+			program.pushOp(op);
+		} else if (isIdentifier(typeName) && getIdentifierName(typeName) === "Promise") {
+			if (type.typeArguments && type.typeArguments[0]) this.extractPackStructOfType(type.typeArguments[0], program);
+			else program.pushOp(_deepkit_type_spec.ReflectionOp.any);
+			program.pushOp(_deepkit_type_spec.ReflectionOp.promise);
+		} else if (isIdentifier(typeName) && getIdentifierName(typeName) === "integer") program.pushOp(_deepkit_type_spec.ReflectionOp.numberBrand, _deepkit_type_spec.TypeNumberBrand.integer);
+		else if (isIdentifier(typeName) && getIdentifierName(typeName) !== "constructor" && _deepkit_type_spec.TypeNumberBrand[getIdentifierName(typeName)] !== void 0) program.pushOp(_deepkit_type_spec.ReflectionOp.numberBrand, _deepkit_type_spec.TypeNumberBrand[getIdentifierName(typeName)]);
+		else {
+			if (isIdentifier(typeName)) {
+				const variable = program.findVariable(getIdentifierName(typeName));
+				if (variable) {
+					program.pushOp(_deepkit_type_spec.ReflectionOp.loads, variable.frameOffset, variable.stackIndex);
+					return;
+				}
+			} else if (isInferTypeNode(typeName)) {
+				this.extractPackStructOfType(typeName, program);
+				return;
+			}
+			const resolved = this.resolveDeclaration(typeName);
+			if (!resolved) {
+				if (isQualifiedName(typeName)) {
+					if (isIdentifier(typeName.left)) {
+						const resolved = this.resolveDeclaration(typeName.left);
+						if (resolved && isEnumDeclaration(resolved.declaration)) {
+							let lastExpression;
+							let indexValue = 0;
+							for (const member of resolved.declaration.members) if (getNameAsString(member.name) === getNameAsString(typeName.right)) {
+								if (member.initializer) program.pushOp(_deepkit_type_spec.ReflectionOp.arg, program.pushStack(this.nodeConverter.toExpression(member.initializer)));
+								else if (lastExpression) {
+									const exp = this.nodeConverter.toExpression(lastExpression);
+									program.pushOp(_deepkit_type_spec.ReflectionOp.arg, program.pushStack(this.f.createBinaryExpression(exp, SyntaxKind.PlusToken, this.nodeConverter.toExpression(indexValue))));
+								} else program.pushOp(_deepkit_type_spec.ReflectionOp.arg, program.pushStack(this.nodeConverter.toExpression(indexValue)));
+								return;
+							} else {
+								indexValue++;
+								if (member.initializer) {
+									lastExpression = member.initializer;
+									indexValue = 0;
+								}
+							}
+						}
+					}
+				}
+				program.pushOp(_deepkit_type_spec.ReflectionOp.never);
+				debug2(`Could not resolve ${getNameAsString(typeName)} in ${program.sourceFile?.fileName || "intrinsic"}`);
+				return;
+			}
+			let declaration = resolved.declaration;
+			const declarationSourceFile = findSourceFile(declaration);
+			const isGlobal = !declarationSourceFile || resolved.importDeclaration === void 0 && declarationSourceFile.fileName !== this.sourceFile.fileName;
+			const isFromImport = resolved.importDeclaration !== void 0;
+			if (isVariableDeclaration(declaration)) {
+				if (declaration.type) declaration = declaration.type;
+				else if (declaration.initializer) declaration = declaration.initializer;
+			}
+			if (isModuleDeclaration(declaration) && resolved.importDeclaration) {
+				if (isIdentifier(typeName)) ensureImportIsEmitted(resolved.importDeclaration, typeName);
+				program.pushOp(_deepkit_type_spec.ReflectionOp.typeof, program.pushStack(this.f.createArrowFunction(void 0, void 0, [], void 0, void 0, serializeEntityNameAsExpression(this.f, typeName))));
+			} else if (isTypeAliasDeclaration(declaration) || isInterfaceDeclaration(declaration) || isEnumDeclaration(declaration)) {
+				const name = getNameAsString(typeName);
+				if (name === "Array") {
+					if (type.typeArguments && type.typeArguments[0]) this.extractPackStructOfType(type.typeArguments[0], program);
+					else program.pushOp(_deepkit_type_spec.ReflectionOp.any);
+					program.pushOp(_deepkit_type_spec.ReflectionOp.array);
+					return;
+				} else if (name === "Function") {
+					program.pushFrame();
+					const index = program.pushStack(this.f.createArrowFunction(void 0, void 0, [], void 0, void 0, this.f.createIdentifier("Function")));
+					program.pushOp(_deepkit_type_spec.ReflectionOp.functionReference, index);
+					program.popFrameImplicit();
+					return;
+				} else if (name === "Set") {
+					if (type.typeArguments && type.typeArguments[0]) this.extractPackStructOfType(type.typeArguments[0], program);
+					else program.pushOp(_deepkit_type_spec.ReflectionOp.any);
+					program.pushOp(_deepkit_type_spec.ReflectionOp.set);
+					return;
+				} else if (name === "Map") {
+					if (type.typeArguments && type.typeArguments[0]) this.extractPackStructOfType(type.typeArguments[0], program);
+					else program.pushOp(_deepkit_type_spec.ReflectionOp.any);
+					if (type.typeArguments && type.typeArguments[1]) this.extractPackStructOfType(type.typeArguments[1], program);
+					else program.pushOp(_deepkit_type_spec.ReflectionOp.any);
+					program.pushOp(_deepkit_type_spec.ReflectionOp.map);
+					return;
+				}
+				const runtimeTypeName = this.getDeclarationVariableName(typeName);
+				if (!this.compiledDeclarations.has(declaration) && !this.compileDeclarations.has(declaration)) {
+					if (declarationSourceFile && this.isExcluded(declarationSourceFile.fileName)) {
+						program.pushOp(_deepkit_type_spec.ReflectionOp.any);
+						return;
+					}
+					if (isGlobal) this.embedDeclarations.set(declaration, {
+						name: typeName,
+						sourceFile: declarationSourceFile
+					});
+					else if (isFromImport) {
+						if (resolved.importDeclaration) {
+							if (resolved.typeOnly) {
+								this.resolveTypeOnlyImport(typeName, program);
+								return;
+							}
+							if (declarationSourceFile.fileName.endsWith(".d.ts")) {
+								if (!this.resolveImportSpecifier(getEscapedText(runtimeTypeName), resolved.importDeclaration, this.sourceFile)) {
+									debug2(`Symbol ${runtimeTypeName.escapedText} not found in ${declarationSourceFile.fileName}`);
+									this.resolveTypeOnlyImport(typeName, program);
+									return;
+								}
+								this.addImports.push({
+									identifier: runtimeTypeName,
+									importDeclaration: resolved.importDeclaration
+								});
+							} else {
+								if (this.getReflectionConfig(declarationSourceFile).mode === "never") {
+									this.resolveTypeOnlyImport(typeName, program);
+									return;
+								}
+								if (!this.isWithReflection(declarationSourceFile, declaration)) {
+									this.resolveTypeOnlyImport(typeName, program);
+									return;
+								}
+								this.addImports.push({
+									identifier: runtimeTypeName,
+									importDeclaration: resolved.importDeclaration
+								});
+							}
+						}
+					} else {
+						if (!this.isWithReflection(program.sourceFile, declaration)) {
+							this.resolveTypeOnlyImport(typeName, program);
+							return;
+						}
+						this.compileDeclarations.set(declaration, {
+							name: typeName,
+							sourceFile: declarationSourceFile
+						});
+					}
+				}
+				const index = program.pushStack(program.forNode === declaration ? 0 : this.f.createArrowFunction(void 0, void 0, [], void 0, void 0, runtimeTypeName));
+				if (type.typeArguments) {
+					for (const argument of type.typeArguments) this.extractPackStructOfType(argument, program);
+					program.pushOp(_deepkit_type_spec.ReflectionOp.inlineCall, index, type.typeArguments.length);
+				} else program.pushOp(_deepkit_type_spec.ReflectionOp.inline, index);
+			} else if (isClassDeclaration(declaration) || isFunctionDeclaration(declaration) || isFunctionExpression(declaration) || isArrowFunction(declaration)) {
+				if (resolved.typeOnly) {
+					this.resolveTypeOnlyImport(typeName, program);
+					return;
+				}
+				if (!(declarationSourceFile?.fileName.endsWith(".d.ts") || this.isWithReflection(program.sourceFile, declaration))) {
+					this.resolveTypeOnlyImport(typeName, program);
+					return;
+				}
+				if (resolved.importDeclaration && isIdentifier(typeName)) ensureImportIsEmitted(resolved.importDeclaration, typeName);
+				program.pushFrame();
+				if (type.typeArguments) for (const typeArgument of type.typeArguments) this.extractPackStructOfType(typeArgument, program);
+				const body = isIdentifier(typeName) ? typeName : this.createAccessorForEntityName(typeName);
+				const index = program.pushStack(this.f.createArrowFunction(void 0, void 0, [], void 0, void 0, body));
+				program.pushOp(isClassDeclaration(declaration) ? _deepkit_type_spec.ReflectionOp.classReference : _deepkit_type_spec.ReflectionOp.functionReference, index);
+				program.popFrameImplicit();
+			} else if (isTypeParameterDeclaration(declaration)) this.resolveTypeParameter(declaration, type, program);
+			else this.extractPackStructOfType(declaration, program);
+		}
+	}
+	/**
+	* Returns the class declaration, function/arrow declaration, or block where type was used.
+	*/
+	getTypeUser(type) {
+		let current = type;
+		while (current) {
+			if (current.kind === SyntaxKind.Block) return current;
+			if (current.kind === SyntaxKind.ClassDeclaration) return current;
+			if (current.kind === SyntaxKind.ClassExpression) return current;
+			if (current.kind === SyntaxKind.Constructor) return current.parent;
+			if (current.kind === SyntaxKind.MethodDeclaration) return current.parent;
+			if (current.kind === SyntaxKind.ArrowFunction || current.kind === SyntaxKind.FunctionDeclaration || current.kind === SyntaxKind.FunctionExpression) return current;
+			current = current.parent;
+		}
+		return current;
+	}
+	/**
+	* With this function we want to check if `type` is used in the signature itself from the parent of `declaration`.
+	* If so, we do not try to infer the type from runtime values.
+	*
+	* Examples where we do not infer from runtime, `type` being `T` and `declaration` being `<T>` (return false):
+	*
+	* ```typescript
+	* class User<T> {
+	*     config: T;
+	* }
+	*
+	* class User<T> {
+	*    constructor(public config: T) {}
+	* }
+	*
+	* function do<T>(item: T): void {}
+	* function do<T>(item: T): T {}
+	* ```
+	*
+	* Examples where we infer from runtime (return true):
+	*
+	* ```typescript
+	* function do<T>(item: T) {
+	*     return typeOf<T>; //<-- because of that
+	* }
+	*
+	* function do<T>(item: T) {
+	*     class A {
+	*         config: T; //<-- because of that
+	*     }
+	*     return A;
+	* }
+	*
+	* function do<T>(item: T) {
+	*     class A {
+	*         doIt() {
+	*             class B {
+	*                 config: T; //<-- because of that
+	*             }
+	*             return B;
+	*         }
+	*     }
+	*     return A;
+	* }
+	*
+	* function do<T>(item: T) {
+	*     class A {
+	*         doIt(): T { //<-- because of that
+	*         }
+	*     }
+	*     return A;
+	* }
+	* ```
+	*/
+	needsToBeInferred(declaration, type) {
+		return this.getTypeUser(declaration) !== this.getTypeUser(type);
+	}
+	resolveTypeOnlyImport(entityName, program) {
+		program.pushOp(_deepkit_type_spec.ReflectionOp.any);
+		const typeName = typescript.default.isIdentifier(entityName) ? getIdentifierName(entityName) : getIdentifierName(entityName.right);
+		this.resolveTypeName(typeName, program);
+	}
+	resolveTypeName(typeName, program) {
+		if (!typeName) return;
+		program.pushOp(_deepkit_type_spec.ReflectionOp.typeName, program.findOrAddStackEntry(typeName));
+	}
+	resolveTypeParameter(declaration, type, program) {
+		const isUsedInFunction = isFunctionLike(declaration.parent);
+		if (isUsedInFunction && program.isResolveFunctionParameters(declaration.parent) || this.needsToBeInferred(declaration, type)) {
+			const argumentName = declaration.name.escapedText;
+			const foundUsers = [];
+			if (isUsedInFunction) for (const parameter of declaration.parent.parameters) {
+				if (!parameter.type) continue;
+				let found = false;
+				const searchArgument = (node) => {
+					node = visitEachChild(node, searchArgument, this.context);
+					if (isIdentifier(node) && node.escapedText === argumentName) {
+						found = true;
+						node = this.f.createInferTypeNode(declaration);
+					}
+					return node;
+				};
+				if (isIdentifier(parameter.name)) {
+					const updatedParameterType = visitEachChild(parameter.type, searchArgument, this.context);
+					if (found) foundUsers.push({
+						type: updatedParameterType,
+						parameterName: parameter.name
+					});
+				}
+			}
+			if (foundUsers.length) {
+				if (foundUsers.length > 1) {}
+				const isReceiveType = foundUsers.find((v) => isTypeReferenceNode(v.type) && isIdentifier(v.type.typeName) && getIdentifierName(v.type.typeName) === "ReceiveType");
+				if (isReceiveType) program.pushOp(_deepkit_type_spec.ReflectionOp.inline, program.pushStack(isReceiveType.parameterName));
+				else for (const foundUser of foundUsers) {
+					program.pushConditionalFrame();
+					program.pushOp(_deepkit_type_spec.ReflectionOp.typeof, program.pushStack(this.f.createArrowFunction(void 0, void 0, [], void 0, void 0, foundUser.parameterName)));
+					this.extractPackStructOfType(foundUser.type, program);
+					program.pushOp(_deepkit_type_spec.ReflectionOp.extends);
+					if (program.findVariable(getIdentifierName(declaration.name))) this.extractPackStructOfType(declaration.name, program);
+					else program.pushOp(_deepkit_type_spec.ReflectionOp.any);
+					this.extractPackStructOfType({ kind: SyntaxKind.NeverKeyword }, program);
+					program.pushOp(_deepkit_type_spec.ReflectionOp.condition);
+					program.popFrameImplicit();
+				}
+				if (foundUsers.length > 1) {}
+			} else if (declaration.constraint) {
+				if (isUsedInFunction) program.resolveFunctionParametersIncrease(declaration.parent);
+				const constraint = getEffectiveConstraintOfTypeParameter(declaration);
+				if (constraint) this.extractPackStructOfType(constraint, program);
+				else program.pushOp(_deepkit_type_spec.ReflectionOp.never);
+				if (isUsedInFunction) program.resolveFunctionParametersDecrease(declaration.parent);
+			} else program.pushOp(_deepkit_type_spec.ReflectionOp.never);
+		} else program.pushOp(_deepkit_type_spec.ReflectionOp.any);
+	}
+	createAccessorForEntityName(e) {
+		return this.f.createPropertyAccessExpression(isIdentifier(e.left) ? e.left : this.createAccessorForEntityName(e.left), e.right);
+	}
+	findDeclarationInFile(sourceFile, declarationName) {
+		if (isNodeWithLocals(sourceFile) && sourceFile.locals) {
+			const declarationSymbol = sourceFile.locals.get(declarationName);
+			if (declarationSymbol && declarationSymbol.declarations && declarationSymbol.declarations[0]) return declarationSymbol.declarations[0];
+		}
+	}
+	resolveImportSpecifier(_declarationName, importOrExport, sourceFile) {
+		const declarationName = "string" === typeof _declarationName ? _declarationName : getIdentifierName(_declarationName);
+		if (!importOrExport.moduleSpecifier || !isStringLiteral(importOrExport.moduleSpecifier)) return;
+		const source = this.resolver.resolve(sourceFile, importOrExport);
+		if (!source) {
+			debug("module not found", importOrExport.moduleSpecifier.text, "Is transpileOnly enabled? It needs to be disabled.");
+			return;
+		}
+		const declaration = this.findDeclarationInFile(source, declarationName);
+		sourceFile = source;
+		/**
+		* declaration could also be `import {PrimaryKey} from 'xy'`, which we want to skip
+		*/
+		if (declaration && !isImportSpecifier(declaration)) {
+			if (isExportDeclaration(declaration)) return this.followExport(declarationName, declaration, sourceFile);
+			return declaration;
+		}
+		if (isSourceFile(sourceFile)) for (const statement of sourceFile.statements) {
+			if (!isExportDeclaration(statement)) continue;
+			const found = this.followExport(declarationName, statement, sourceFile);
+			if (found) return found;
+		}
+	}
+	followExport(declarationName, statement, sourceFile) {
+		if (statement.exportClause) {
+			if (isNamedExports(statement.exportClause)) {
+				for (const element of statement.exportClause.elements) if (getEscapedText(element.name) === declarationName) if (!statement.moduleSpecifier || !isStringLiteral(statement.moduleSpecifier)) {
+					if (!statement.moduleSpecifier || !isStringLiteral(statement.moduleSpecifier)) {
+						if (isNodeWithLocals(sourceFile) && sourceFile.locals) {
+							const found = sourceFile.locals.get(declarationName);
+							if (found && found.declarations && found.declarations[0]) {
+								const declaration = found.declarations[0];
+								if (declaration && isImportSpecifier(declaration)) {
+									const importOrExport = declaration.parent.parent.parent;
+									const found = this.resolveImportSpecifier(element.propertyName ? getEscapedText(element.propertyName) : declarationName, importOrExport, sourceFile);
+									if (found) return found;
+								} else if (declaration) {}
+								return declaration;
+							}
+						}
+					}
+				} else {
+					const found = this.resolveImportSpecifier(element.propertyName ? getEscapedText(element.propertyName) : declarationName, statement, sourceFile);
+					if (found) return found;
+				}
+			}
+		} else {
+			const found = this.resolveImportSpecifier(declarationName, statement, sourceFile);
+			if (found) return found;
+		}
+	}
+	getTypeOfType(type) {
+		if (!this.isWithReflection(this.sourceFile, type)) return;
+		const program = new CompilerProgram(type, this.sourceFile);
+		this.extractPackStructOfType(type, program);
+		return this.packOpsAndStack(program);
+	}
+	packOpsAndStack(program) {
+		const packStruct = program.buildPackStruct();
+		if (packStruct.ops.length === 0) return;
+		const packed = [...packStruct.stack, encodeOps(packStruct.ops)];
+		return this.valueToExpression(packed);
+	}
+	/**
+	* Note: We have to duplicate the expressions as it can be that incoming expression are from another file and contain wrong pos/end properties,
+	* so the code generation is then broken when we simply reuse them. Wrong code like ``User.__type = [.toEqual({`` is then generated.
+	* This function is probably not complete, but we add new copies when required.
+	*/
+	valueToExpression(value) {
+		return this.nodeConverter.toExpression(value);
+	}
+	/**
+	* A class is decorated with type information by adding a static variable.
+	*
+	* class Model {
+	*     static __types = pack(ReflectionOp.string); //<-- encoded type information
+	*     title: string;
+	* }
+	*/
+	decorateClass(sourceFile, node) {
+		if (!this.isWithReflection(sourceFile, node)) return node;
+		const type = this.getTypeOfType(node);
+		const __type = this.f.createPropertyDeclaration(this.f.createModifiersFromModifierFlags(ModifierFlags.Static), "__type", void 0, void 0, type);
+		if (isClassDeclaration(node)) return this.f.updateClassDeclaration(node, node.modifiers, node.name, node.typeParameters, node.heritageClauses, this.f.createNodeArray([...node.members, __type]));
+		return this.f.updateClassExpression(node, node.modifiers, node.name, node.typeParameters, node.heritageClauses, this.f.createNodeArray([...node.members, __type]));
+	}
+	/**
+	* const fn = function() {}
+	*
+	* => const fn = __assignType(function() {}, [34])
+	*/
+	decorateFunctionExpression(expression) {
+		const encodedType = this.getTypeOfType(expression);
+		if (!encodedType) return expression;
+		return this.wrapWithAssignType(expression, encodedType);
+	}
+	/**
+	* function name() {}
+	*
+	* => function name() {}; name.__type = 34;
+	*/
+	decorateFunctionDeclaration(declaration) {
+		const encodedType = this.getTypeOfType(declaration);
+		if (!encodedType) return declaration;
+		if (!declaration.name) {
+			if (!declaration.body) return;
+			const modifier = declaration.modifiers ? declaration.modifiers.filter((v) => v.kind !== SyntaxKind.ExportKeyword && v.kind !== SyntaxKind.DefaultKeyword && v.kind !== SyntaxKind.Decorator) : [];
+			return this.f.createExportAssignment(void 0, void 0, this.wrapWithAssignType(this.f.createFunctionExpression(modifier, declaration.asteriskToken, declaration.name, declaration.typeParameters, declaration.parameters, declaration.type, declaration.body), encodedType));
+		}
+		const statements = [declaration];
+		statements.push(this.f.createExpressionStatement(this.f.createAssignment(this.f.createPropertyAccessExpression(serializeEntityNameAsExpression(this.f, declaration.name), "__type"), encodedType)));
+		return statements;
+	}
+	/**
+	* const fn = () => {}
+	* => const fn = __assignType(() => {}, [34])
+	*/
+	decorateArrowFunction(expression) {
+		const encodedType = this.getTypeOfType(expression);
+		if (!encodedType) return expression;
+		return this.wrapWithAssignType(expression, encodedType);
+	}
+	/**
+	* Object.assign(fn, {__type: []}) is much slower than a custom implementation like
+	*
+	* assignType(fn, [])
+	*
+	* where we embed assignType() at the beginning of the type.
+	*/
+	wrapWithAssignType(fn, type) {
+		this.embedAssignType = true;
+		return this.f.createCallExpression(this.f.createIdentifier("__assignType"), void 0, [fn, type]);
+	}
+	/**
+	* Emit `{ __meta?: never & [name, value] }` — the runtime shape of `TypeAnnotation<name, value>`.
+	* Consumed later via `typeAnnotation.getForName(type, name)`.
+	*/
+	emitTypeAnnotation(program, name, value) {
+		program.pushFrame();
+		program.pushFrame();
+		program.pushOp(_deepkit_type_spec.ReflectionOp.never);
+		program.pushFrame();
+		program.pushOp(_deepkit_type_spec.ReflectionOp.literal, program.findOrAddStackEntry(name));
+		program.pushOp(_deepkit_type_spec.ReflectionOp.literal, program.findOrAddStackEntry(value));
+		program.pushOp(_deepkit_type_spec.ReflectionOp.tuple);
+		program.popFrameImplicit();
+		program.pushOp(_deepkit_type_spec.ReflectionOp.intersection);
+		program.popFrameImplicit();
+		program.pushOp(_deepkit_type_spec.ReflectionOp.propertySignature, program.findOrAddStackEntry("__meta"));
+		program.pushOp(_deepkit_type_spec.ReflectionOp.optional);
+		program.pushOp(_deepkit_type_spec.ReflectionOp.objectLiteral);
+		program.popFrameImplicit();
+	}
+	collectJSDocAnnotations(node) {
+		const parsed = extractJSDocTags(this.sourceFile, node);
+		const annotations = [];
+		const seen = /* @__PURE__ */ new Set();
+		for (const tag of parsed.tags) {
+			annotations.push(tag);
+			seen.add(tag.name);
+		}
+		if (parsed.description && !seen.has("description")) annotations.unshift({
+			name: "description",
+			value: parsed.description
+		});
+		const descriptionTag = annotations.find((v) => v.name === "description");
+		return {
+			description: descriptionTag && typeof descriptionTag.value === "string" ? descriptionTag.value : parsed.description,
+			annotations
+		};
+	}
+	/**
+	* Run `emitType()` then intersect the result with TypeAnnotations derived from JSDoc/TSDoc.
+	* Also sets `ReflectionOp.description` when a description string is available (back-compat).
+	*
+	* @returns The resolved description string, if any.
+	*/
+	withJSDocTypeAnnotations(program, node, emitType, options = {}) {
+		const { description, annotations } = this.collectJSDocAnnotations(node);
+		const applyDescriptionOp = options.applyDescriptionOp !== false;
+		if (annotations.length === 0) {
+			emitType();
+			if (applyDescriptionOp && description) program.pushOp(_deepkit_type_spec.ReflectionOp.description, program.findOrAddStackEntry(description));
+			return description;
+		}
+		program.pushFrame();
+		emitType();
+		for (const annotation of annotations) this.emitTypeAnnotation(program, annotation.name, annotation.value);
+		program.pushOp(_deepkit_type_spec.ReflectionOp.intersection);
+		program.popFrameImplicit();
+		if (applyDescriptionOp && description) program.pushOp(_deepkit_type_spec.ReflectionOp.description, program.findOrAddStackEntry(description));
+		return description;
+	}
+	/**
+	* Checks if reflection was disabled/enabled in file via JSDoc attribute for a particular
+	* Node, e.g `@reflection no`. If nothing is found, "reflection" config option needs to be used.
+	*/
+	getExplicitReflectionMode(sourceFile, node) {
+		let current = node;
+		let reflectionComment = void 0;
+		while ("undefined" === typeof reflectionComment && current) {
+			const next = sourceFile && extractJSDocAttribute(sourceFile, current, "reflection");
+			if ("undefined" !== typeof next) reflectionComment = next;
+			current = current.parent;
+		}
+		if (reflectionComment === "" || reflectionComment === "true" || reflectionComment === "default" || reflectionComment === "enabled" || reflectionComment === "1") return true;
+		if (reflectionComment === "false" || reflectionComment === "disabled" || reflectionComment === "never" || reflectionComment === "no" || reflectionComment === "0") return false;
+	}
+};
+var DeclarationTransformer = class extends ReflectionTransformer {
+	constructor() {
+		super(...arguments);
+		this.addExports = [];
+	}
+	transformSourceFile(sourceFile) {
+		if (sourceFile.deepkitDeclarationTransformed) return sourceFile;
+		this.sourceFile = sourceFile;
+		this.addExports = [];
+		const configResolver = this.getConfigResolver(sourceFile);
+		const reflection = configResolver.match(sourceFile.fileName);
+		Object.assign(this.compilerOptions, configResolver.config.compilerOptions);
+		if (reflection.mode === "never") return sourceFile;
+		const visitor = (node) => {
+			node = visitEachChild(node, visitor, this.context);
+			if ((isTypeAliasDeclaration(node) || isInterfaceDeclaration(node) || isEnumDeclaration(node)) && hasModifier(node, SyntaxKind.ExportKeyword)) {
+				if (this.isWithReflection(sourceFile, node)) this.addExports.push({ identifier: getIdentifierName(this.getDeclarationVariableName(node.name)) });
+			}
+			return node;
+		};
+		this.sourceFile = visitNode(this.sourceFile, visitor);
+		if (this.addExports.length) {
+			const exports = [];
+			const handledIdentifier = [];
+			for (const imp of this.addExports) {
+				if (handledIdentifier.includes(imp.identifier)) continue;
+				handledIdentifier.push(imp.identifier);
+				exports.push(this.f.createTypeAliasDeclaration([this.f.createModifier(SyntaxKind.ExportKeyword), this.f.createModifier(SyntaxKind.DeclareKeyword)], this.f.createIdentifier(imp.identifier), void 0, this.f.createArrayTypeNode(this.f.createKeywordTypeNode(SyntaxKind.AnyKeyword))));
+			}
+			this.sourceFile = this.f.updateSourceFile(this.sourceFile, [...this.sourceFile.statements, ...exports]);
+		}
+		this.sourceFile.deepkitDeclarationTransformed = true;
+		return this.sourceFile;
+	}
+};
+let loaded = false;
+const cache = new Cache();
+const transformer = function deepkitTransformer(context) {
+	if (!loaded) {
+		debug("@deepkit/type transformer loaded\n");
+		loaded = true;
+	}
+	cache.tick();
+	return new ReflectionTransformer(context, cache);
+};
+const declarationTransformer = function deepkitDeclarationTransformer(context) {
+	return new DeclarationTransformer(context, cache);
+};
+
+//#endregion
+//#region ../../../node_modules/.pnpm/@deepkit+type-compiler@1.0.19_patch_hash=bd438188cbc12e606ed4d519c25ab921a833fbc2d92357_e562d261195ccb1f28e41e80fc823414/node_modules/@deepkit/type-compiler/dist/esm/src/loader.js
+var DeepkitLoader = class {
+	constructor() {
+		this.options = {
+			allowJs: true,
+			declaration: false
+		};
+		this.host = typescript.default.createCompilerHost(this.options);
+		this.program = typescript.default.createProgram([], this.options, this.host);
+		this.printer = typescript.default.createPrinter({ newLine: typescript.default.NewLineKind.LineFeed });
+		this.cache = new Cache();
+		this.knownFiles = {};
+		this.sourceFiles = {};
+		const originReadFile = this.host.readFile;
+		this.host.readFile = (fileName) => {
+			if (this.knownFiles[fileName]) return this.knownFiles[fileName];
+			return originReadFile.call(this.host, fileName);
+		};
+		this.host.writeFile = () => {};
+		const originalGetSourceFile = this.host.getSourceFile;
+		this.host.getSourceFile = (fileName, languageVersion, onError, shouldCreateNewSourceFile) => {
+			if (this.sourceFiles[fileName]) return this.sourceFiles[fileName];
+			return originalGetSourceFile.call(this.host, fileName, languageVersion, onError, shouldCreateNewSourceFile);
+		};
+	}
+	transform(source, path) {
+		this.knownFiles[path] = source;
+		const sourceFile = typescript.default.createSourceFile(path, source, typescript.default.ScriptTarget.ESNext, true, path.endsWith(".tsx") ? typescript.default.ScriptKind.TSX : typescript.default.ScriptKind.TS);
+		let newSource = source;
+		typescript.default.transform(sourceFile, [(context) => {
+			const transformer = new ReflectionTransformer(context, this.cache).forHost(this.host).withReflection({ reflection: "default" });
+			return (node) => {
+				const sourceFile = transformer.transformSourceFile(node);
+				newSource = this.printer.printNode(typescript.default.EmitHint.SourceFile, sourceFile, sourceFile);
+				return sourceFile;
+			};
+		}], this.options);
+		return newSource;
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'Cache', {
+  enumerable: true,
+  get: function () {
+    return Cache;
+  }
+});
+Object.defineProperty(exports, 'DeclarationTransformer', {
+  enumerable: true,
+  get: function () {
+    return DeclarationTransformer;
+  }
+});
+Object.defineProperty(exports, 'DeepkitLoader', {
+  enumerable: true,
+  get: function () {
+    return DeepkitLoader;
+  }
+});
+Object.defineProperty(exports, 'ReflectionTransformer', {
+  enumerable: true,
+  get: function () {
+    return ReflectionTransformer;
+  }
+});
+Object.defineProperty(exports, 'debugPackStruct', {
+  enumerable: true,
+  get: function () {
+    return debugPackStruct;
+  }
+});
+Object.defineProperty(exports, 'declarationTransformer', {
+  enumerable: true,
+  get: function () {
+    return declarationTransformer;
+  }
+});
+Object.defineProperty(exports, 'encodeOps', {
+  enumerable: true,
+  get: function () {
+    return encodeOps;
+  }
+});
+Object.defineProperty(exports, 'packSize', {
+  enumerable: true,
+  get: function () {
+    return packSize;
+  }
+});
+Object.defineProperty(exports, 'packSizeByte', {
+  enumerable: true,
+  get: function () {
+    return packSizeByte;
+  }
+});
+Object.defineProperty(exports, 'transformer', {
+  enumerable: true,
+  get: function () {
+    return transformer;
+  }
+});