@powerlines/deepkit 0.5.2 → 0.5.3

package/dist/chunk-W423FBJ2.js

@@ -0,0 +1,2854 @@
+import { ReflectionOp, TypeNumberBrand } from './chunk-XU55W26B.js';
+import { __name, __require } from './chunk-3GQAWCBQ.js';
+import ts4, { isBigIntLiteral } from 'typescript';
+import { knownLibFilesForCompilerOptions } from '@typescript/vfs';
+import { dirname, isAbsolute, join } from 'path';
+import { readFileSync } from 'fs';
+import micromatch from 'micromatch';
+import { cloneNode } from '@marcj/ts-clone-node';
+import defu from 'defu';
+
+// ../../node_modules/.pnpm/@deepkit+type-compiler@1.0.5_patch_hash=88e8267ac73f46799c551ae3696181dc1f272895f490f8c_ef8b874d406bec4900e1fddc1ea375be/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);
+}
+__name(isDebug, "isDebug");
+function debug(...message) {
+  if (isDebug(1)) {
+    console.debug(...message);
+  }
+}
+__name(debug, "debug");
+function debug2(...message) {
+  if (isDebug(2)) {
+    console.debug(...message);
+  }
+}
+__name(debug2, "debug2");
+var { createSourceFile, resolveModuleName, isStringLiteral, JSDocParsingMode, ScriptTarget } = ts4;
+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.isMatch(path, include, {
+    ignore: exclude
+  });
+}
+__name(patternMatch, "patternMatch");
+var Resolver = class {
+  static {
+    __name(this, "Resolver");
+  }
+  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(moduleSpecifier)) return;
+    return this.resolveSourceFile(from, moduleSpecifier);
+  }
+  resolveImpl(modulePath, sourceFile) {
+    if (this.host.resolveModuleNameLiterals !== void 0) {
+      const results = this.host.resolveModuleNameLiterals(
+        [
+          modulePath
+        ],
+        sourceFile.fileName,
+        /*reusedNames*/
+        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,
+        /*reusedNames*/
+        void 0,
+        /*redirectedReference*/
+        void 0,
+        this.compilerOptions
+      )[0];
+    }
+    const result = resolveModuleName(modulePath.text, sourceFile.fileName, this.compilerOptions, this.host);
+    return result.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.ES2018,
+      // JSDocParsingMode is not available in TS < 5.3
+      jsDocParsingMode: JSDocParsingMode ? JSDocParsingMode.ParseNone : void 0
+    }, true);
+    this.sourceFiles[fileName] = moduleSourceFile;
+    ts4.bindSourceFile(moduleSourceFile, this.compilerOptions);
+    return moduleSourceFile;
+  }
+};
+
+// ../../node_modules/.pnpm/@deepkit+type-compiler@1.0.5_patch_hash=88e8267ac73f46799c551ae3696181dc1f272895f490f8c_ef8b874d406bec4900e1fddc1ea375be/node_modules/@deepkit/type-compiler/dist/esm/src/config.js
+function isObject(obj) {
+  if (!obj) {
+    return false;
+  }
+  return typeof obj === "object" && !Array.isArray(obj);
+}
+__name(isObject, "isObject");
+var defaultMergeStrategy = "merge";
+function readTsConfig(parseConfigHost, path) {
+  const configFile = ts4.readConfigFile(path, (path2) => parseConfigHost.readFile(path2));
+  if (configFile.error) {
+    debug(`Failed to read tsconfig ${path}: ${configFile.error.messageText}`);
+    return;
+  }
+  const parsed = ts4.parseJsonConfigFileContent(configFile.config, parseConfigHost, dirname(path));
+  const ignoredErrors = [
+    18003
+    // No inputs were found in config file.
+  ];
+  const softErrors = [
+    18e3
+    // Circularity detected while resolving configuration
+  ];
+  const errors = parsed.errors.filter((v) => !ignoredErrors.includes(v.code));
+  if (errors.length) {
+    debug(`Failed to parse tsconfig ${path}: ${parsed.errors.map((v) => v.messageText).join(", ")}`);
+  }
+  const hardErrors = errors.filter((v) => !softErrors.includes(v.code));
+  if (hardErrors.length) {
+    return;
+  }
+  const json = readFileSync(path, "utf8");
+  const tsconfig = JSON.parse(json);
+  return Object.assign(configFile.config, {
+    compilerOptions: parsed.options,
+    reflectionLevel: tsconfig.reflectionLevel ? String(tsconfig.reflectionLevel) : void 0
+  });
+}
+__name(readTsConfig, "readTsConfig");
+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";
+}
+__name(reflectionModeMatcher, "reflectionModeMatcher");
+function ensureStringArray(value) {
+  if (Array.isArray(value)) return value.map((v) => "" + v);
+  if ("string" === typeof value) return [
+    value
+  ];
+  return [];
+}
+__name(ensureStringArray, "ensureStringArray");
+function parseRawMode(mode) {
+  if ("boolean" === typeof mode) return mode ? "default" : "never";
+  if (mode === "default" || mode === "explicit") return mode;
+  return ensureStringArray(mode);
+}
+__name(parseRawMode, "parseRawMode");
+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 (isAbsolute(paths[i])) continue;
+    let path = paths[i];
+    let exclude = false;
+    if (path.startsWith("!")) {
+      exclude = true;
+      path = path.substring(1);
+    }
+    if (path.startsWith("./") || path.includes("/")) {
+      path = join(baseDir, path);
+    }
+    path = path.replace(/\\/g, "/");
+    if (exclude) path = "!" + path;
+    paths[i] = path;
+  }
+}
+__name(resolvePaths, "resolvePaths");
+function appendPaths(strategy = defaultMergeStrategy, parent, existing) {
+  if (strategy === "replace") {
+    return [
+      ...existing || parent
+    ];
+  }
+  if (!existing) return [
+    ...parent
+  ];
+  return [
+    ...parent,
+    ...existing
+  ];
+}
+__name(appendPaths, "appendPaths");
+function applyConfigValues(existing, parent, baseDir) {
+  const parentReflection = isObject(parent.deepkitCompilerOptions) ? parent.deepkitCompilerOptions?.reflection : parent.reflection;
+  const parentReflectionLevel = parent.deepkitCompilerOptions?.reflectionLevel || parent.reflectionLevel || parent.compilerOptions?.reflectionLevel;
+  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 ("undefined" !== typeof parentReflectionLevel) {
+    if ("undefined" === typeof existing.reflectionLevel) {
+      existing.reflectionLevel = parentReflectionLevel;
+    }
+  }
+  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;
+}
+__name(applyConfigValues, "applyConfigValues");
+var 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(cache3, host, compilerOptions, sourceFile, tsConfigPath = "") {
+  let config = {
+    // We use the parameter `compilerOptions` only for compilerOptions.configFilePath.
+    // We load the compilerOptions manually since transformers don't get the full picture
+    // (path aliases are missing for example).
+    // It's important to load compilerOptions manually if there is compilerOptions.configFilePath
+    // since not all build tools provide the full compilerOptions.
+    compilerOptions: {}
+  };
+  tsConfigPath = tsConfigPath || ("string" === typeof compilerOptions.configFilePath ? compilerOptions.configFilePath : "");
+  if (tsConfigPath) {
+    if (cache3[tsConfigPath]) {
+      return cache3[tsConfigPath];
+    }
+    const configFile = readTsConfig(host, tsConfigPath);
+    if (configFile) applyConfigValues(config, configFile, dirname(tsConfigPath));
+  } else {
+    if (!tsConfigPath && sourceFile) {
+      const baseDir = dirname(sourceFile.fileName);
+      const configPath = ts4.findConfigFile(baseDir, (path) => {
+        path = isAbsolute(path) ? path : join(baseDir, path);
+        return host.fileExists(path);
+      });
+      debug2(`No tsConfigPath|compilerOptions.configFilePath provided. Manually searching for tsconfig.json in ${baseDir} returned ${configPath}`);
+      if (configPath) {
+        tsConfigPath = isAbsolute(configPath) ? configPath : join(baseDir, configPath);
+      }
+    }
+    if (tsConfigPath) {
+      if (cache3[tsConfigPath]) return cache3[tsConfigPath];
+      const configFile = readTsConfig(host, tsConfigPath);
+      if (configFile) applyConfigValues(config, configFile, dirname(tsConfigPath));
+    }
+  }
+  if (tsConfigPath) {
+    let basePath = dirname(tsConfigPath);
+    let currentConfig = config;
+    const seen = /* @__PURE__ */ new Set();
+    seen.add(tsConfigPath);
+    while (currentConfig.extends) {
+      const path = join(basePath, currentConfig.extends);
+      if (seen.has(path)) break;
+      seen.add(path);
+      const nextConfig = ts4.readConfigFile(path, (path2) => host.readFile(path2));
+      if (!nextConfig) break;
+      basePath = dirname(path);
+      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,
+    // we want to maintain options passed from tsc API (transpile, Program)
+    compilerOptions: Object.assign(config.compilerOptions, compilerOptions),
+    exclude: config.exclude,
+    reflection: config.reflection,
+    reflectionLevel: config.reflectionLevel || (config.compilerOptions?.reflectionLevel ? String(config.compilerOptions?.reflectionLevel) : void 0) || "normal",
+    mergeStrategy: config.mergeStrategy || defaultMergeStrategy
+  };
+  if (isDebug()) {
+    debug(`Found config ${resolvedConfig.path}:
+reflection:`, resolvedConfig.reflection, `
+exclude:`, resolvedConfig.exclude, `
+paths:`, resolvedConfig.compilerOptions.paths);
+  }
+  const match = /* @__PURE__ */ __name((path) => {
+    const mode = reflectionModeMatcher(config, path);
+    return {
+      mode,
+      tsConfigPath,
+      level: resolvedConfig.reflectionLevel
+    };
+  }, "match");
+  return cache3[tsConfigPath] = {
+    config: resolvedConfig,
+    match
+  };
+}
+__name(getConfigResolver, "getConfigResolver");
+var { isArrowFunction, isComputedPropertyName, isIdentifier, isNamedImports, isNumericLiteral, isPrivateIdentifier, isStringLiteral: isStringLiteral2, isStringLiteralLike, setOriginalNode, getLeadingCommentRanges, isNoSubstitutionTemplateLiteral, NodeFlags, SyntaxKind } = ts4;
+function is__String(value) {
+  return typeof value === "string";
+}
+__name(is__String, "is__String");
+function getIdentifierName(node) {
+  if (is__String(node)) return node;
+  if (isIdentifier(node) || isPrivateIdentifier(node)) {
+    return ts4.unescapeLeadingUnderscores(node.escapedText);
+  }
+  if (isStringLiteral2(node)) return node.text;
+  return "";
+}
+__name(getIdentifierName, "getIdentifierName");
+function getEscapedText(node) {
+  if (is__String(node)) return node;
+  if (isIdentifier(node) || isPrivateIdentifier(node)) return node.escapedText;
+  return getIdentifierName(node);
+}
+__name(getEscapedText, "getEscapedText");
+function findSourceFile(node) {
+  if (node.kind === SyntaxKind.SourceFile) return node;
+  let current = node.parent;
+  while (current && current.kind !== SyntaxKind.SourceFile) {
+    current = current.parent;
+  }
+  return current;
+}
+__name(findSourceFile, "findSourceFile");
+function joinQualifiedName(name) {
+  if (isIdentifier(name)) return getIdentifierName(name);
+  return joinQualifiedName(name.left) + "_" + getIdentifierName(name.right);
+}
+__name(joinQualifiedName, "joinQualifiedName");
+var BANNER_REGEX = /^\/\*\s---.*\n[\s\S]*\s*---\s*\*\//;
+function getCommentOfNode(sourceFile, node) {
+  const commentLines = getLeadingCommentRanges(sourceFile.text, node.pos);
+  if (!commentLines || commentLines.length === 0) return;
+  const commentLine = commentLines.slice(-1)[0];
+  if (!commentLine) return;
+  const comment = sourceFile.text.slice(commentLine.pos, commentLine.end);
+  if (comment.match(BANNER_REGEX)) {
+    return void 0;
+  }
+  return comment;
+}
+__name(getCommentOfNode, "getCommentOfNode");
+function parseJSDocAttributeFromText(comment, attribute) {
+  const attributeStr = `@${attribute} `;
+  const index = comment.indexOf(attributeStr);
+  if (index === -1) {
+    let start2 = 0;
+    while (true) {
+      const withoutContent = comment.indexOf(`@${attribute}`, start2);
+      if (withoutContent === -1) {
+        return [
+          void 0,
+          -1
+        ];
+      }
+      const nextCharacter = comment[withoutContent + attribute.length + 1];
+      if (!nextCharacter || nextCharacter === " " || nextCharacter === "\n" || nextCharacter === "\r" || nextCharacter === "	") {
+        return [
+          void 0,
+          withoutContent + attribute.length + 1
+        ];
+      }
+      start2 = withoutContent + attribute.length + 1;
+    }
+  }
+  const start = index + attributeStr.length;
+  const nextAttribute = comment.indexOf("@", start);
+  const endOfComment = comment.indexOf("*/", start);
+  const end = nextAttribute === -1 ? endOfComment : Math.min(nextAttribute, endOfComment);
+  const content = comment.substring(start, end).trim();
+  return [
+    content.split("\n").map((v) => {
+      const indexOfStar = v.indexOf("*");
+      if (indexOfStar === -1) {
+        return v.trim();
+      }
+      return v.substring(indexOfStar + 1).trim();
+    }).join("\n").replace(/\n*$/g, ""),
+    end + 1
+  ];
+}
+__name(parseJSDocAttributeFromText, "parseJSDocAttributeFromText");
+function parseJSDocBooleanFromText(comment, attribute) {
+  return new RegExp(`^s*@(${attribute?.trim()})s*(false|False|FALSE|0|n|N|no|No|NO)s*$`, "gm").test(comment?.trim()) ? false : new RegExp(`^s*@(${attribute?.trim()})s*(true|True|TRUE|1|y|Y|yes|Yes|YES)?s*$`, "gm").test(comment?.trim()) ? true : void 0;
+}
+__name(parseJSDocBooleanFromText, "parseJSDocBooleanFromText");
+function parseJSDocDescription(comment) {
+  let lines = comment.split("\n").filter((line) => line && !line.includes("/**") && !line.includes("*/")).map((line) => line.replace(/^\s*\*\s*/g, "").replace(/^\*\s*/g, "").trim());
+  const attribute = lines.findIndex((line) => line.startsWith("@"));
+  if (attribute !== -1) {
+    lines = lines.slice(0, attribute);
+  }
+  return lines.join("\n").trim() || void 0;
+}
+__name(parseJSDocDescription, "parseJSDocDescription");
+function extractJSDocAttribute(sourceFile, node, attribute) {
+  if (!node) return void 0;
+  const comment = getCommentOfNode(sourceFile, node);
+  if (!comment) return void 0;
+  let result = parseJSDocAttributeFromText(comment, attribute);
+  if (!result[0] && attribute === "description") {
+    result[0] = parseJSDocDescription(comment);
+  }
+  return result[0];
+}
+__name(extractJSDocAttribute, "extractJSDocAttribute");
+function extractJSDocArray(sourceFile, node, attribute) {
+  if (!node) return void 0;
+  const comment = getCommentOfNode(sourceFile, node);
+  if (!comment) return void 0;
+  const results = [];
+  try {
+    let result = parseJSDocAttributeFromText(comment, attribute);
+    if (result.length < 2) {
+      return void 0;
+    }
+    if (result[0] && result[1] > -1) {
+      results.push(result[0]);
+    }
+    let currentComment = comment;
+    while (result[1] > -1 && currentComment.length > result[1]) {
+      currentComment = currentComment.substring(result[1]);
+      result = parseJSDocAttributeFromText(currentComment, attribute);
+      if (result[0]) {
+        results.push(result[0]);
+      }
+    }
+  } catch (error) {
+    console.error("Error parsing JSDoc attribute:", attribute, "in comment:", comment);
+    console.error(error);
+  }
+  return results;
+}
+__name(extractJSDocArray, "extractJSDocArray");
+function extractJSDocBoolean(sourceFile, node, attribute) {
+  if (!node) {
+    return void 0;
+  }
+  const comment = getCommentOfNode(sourceFile, node);
+  if (!comment) {
+    return void 0;
+  }
+  return parseJSDocBooleanFromText(comment, attribute);
+}
+__name(extractJSDocBoolean, "extractJSDocBoolean");
+function getPropertyName(f, node) {
+  if (!node) return "";
+  if (isIdentifier(node)) return getIdentifierName(node);
+  if (isStringLiteral2(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 "";
+}
+__name(getPropertyName, "getPropertyName");
+function getNameAsString(node) {
+  if (!node) return "";
+  if (isIdentifier(node)) return getIdentifierName(node);
+  if (isStringLiteral2(node)) return node.text;
+  if (isNumericLiteral(node)) return node.text;
+  if (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);
+}
+__name(getNameAsString, "getNameAsString");
+function hasModifier(node, modifier) {
+  if (!node.modifiers) return false;
+  return node.modifiers.some((v) => v.kind === modifier);
+}
+__name(hasModifier, "hasModifier");
+var cloneHook = /* @__PURE__ */ __name((node, payload) => {
+  if (isIdentifier(node)) {
+    return {
+      text: /* @__PURE__ */ __name(() => {
+        return getIdentifierName(node);
+      }, "text")
+    };
+  }
+  return;
+}, "cloneHook");
+var NodeConverter = class {
+  static {
+    __name(this, "NodeConverter");
+  }
+  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(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.Identifier:
+        return finish(node, this.f.createIdentifier(getIdentifierName(node)));
+      case SyntaxKind.StringLiteral:
+        return finish(node, this.f.createStringLiteral(node.text));
+      case SyntaxKind.NumericLiteral:
+        return finish(node, this.f.createNumericLiteral(node.text));
+      case SyntaxKind.BigIntLiteral:
+        return finish(node, this.f.createBigIntLiteral(node.text));
+      case SyntaxKind.TrueKeyword:
+        return finish(node, this.f.createTrue());
+      case SyntaxKind.FalseKeyword:
+        return finish(node, this.f.createFalse());
+    }
+    try {
+      return 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;
+}
+__name(isExternalOrCommonJsModule, "isExternalOrCommonJsModule");
+function isNodeWithLocals(node) {
+  return "locals" in node;
+}
+__name(isNodeWithLocals, "isNodeWithLocals");
+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;
+}
+__name(getGlobalsOfSourceFile, "getGlobalsOfSourceFile");
+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.Synthesized;
+          return;
+        }
+      }
+    }
+  }
+  importDeclaration.flags |= NodeFlags.Synthesized;
+}
+__name(ensureImportIsEmitted, "ensureImportIsEmitted");
+function serializeEntityNameAsExpression(f, node) {
+  switch (node.kind) {
+    case SyntaxKind.Identifier:
+      return finish(node, f.createIdentifier(getIdentifierName(node)));
+    case SyntaxKind.QualifiedName:
+      return finish(node, serializeQualifiedNameAsExpression(f, node));
+  }
+  return node;
+}
+__name(serializeEntityNameAsExpression, "serializeEntityNameAsExpression");
+function serializeQualifiedNameAsExpression(f, node) {
+  return f.createPropertyAccessExpression(serializeEntityNameAsExpression(f, node.left), node.right);
+}
+__name(serializeQualifiedNameAsExpression, "serializeQualifiedNameAsExpression");
+function finish(oldNode, newNode) {
+  setOriginalNode(newNode, oldNode);
+  newNode._original = newNode.original;
+  newNode._symbol = oldNode._symbol ?? oldNode.symbol;
+  newNode.symbol = newNode._symbol;
+  return newNode;
+}
+__name(finish, "finish");
+
+// ../../node_modules/.pnpm/@deepkit+type-compiler@1.0.5_patch_hash=88e8267ac73f46799c551ae3696181dc1f272895f490f8c_ef8b874d406bec4900e1fddc1ea375be/node_modules/@deepkit/type-compiler/dist/esm/src/compiler.js
+var { visitEachChild, visitNode, isPropertyAssignment, isArrayTypeNode, isArrowFunction: isArrowFunction2, isBlock, isCallExpression, isCallSignatureDeclaration, isClassDeclaration, isClassExpression, isConstructorDeclaration, isConstructorTypeNode, isConstructSignatureDeclaration, isEnumDeclaration, isExportDeclaration, isExpression, isExpressionWithTypeArguments, isFunctionDeclaration, isFunctionExpression, isFunctionLike, isIdentifier: isIdentifier2, isImportClause, isImportDeclaration, isImportSpecifier, isInferTypeNode, isInterfaceDeclaration, isMethodDeclaration, isMethodSignature, isModuleDeclaration, isNamedExports, isNamedTupleMember, isNewExpression, isObjectLiteralExpression, isOptionalTypeNode, isParameter, isParenthesizedExpression, isParenthesizedTypeNode, isPropertyAccessExpression, isQualifiedName, isSourceFile, isStringLiteral: isStringLiteral3, isTypeAliasDeclaration, isTypeLiteralNode, isTypeParameterDeclaration, isTypeQueryNode, isTypeReferenceNode, isUnionTypeNode, isExpressionStatement, isVariableDeclaration, getEffectiveConstraintOfTypeParameter, addSyntheticLeadingComment, createCompilerHost, createPrinter, escapeLeadingUnderscores, EmitHint, NodeFlags: NodeFlags2, SyntaxKind: SyntaxKind2, ScriptTarget: ScriptTarget2, ModifierFlags, ScriptKind } = ts4;
+function encodeOps(ops) {
+  return ops.map((v) => String.fromCharCode(v + 33)).join("");
+}
+__name(encodeOps, "encodeOps");
+function filterUndefined(object) {
+  return Object.fromEntries(Object.entries(object).filter(([, v]) => v !== void 0));
+}
+__name(filterUndefined, "filterUndefined");
+({
+  [ReflectionOp.literal]: {
+    },
+  // [ReflectionOp.pointer]: { params: 1 },
+  // [ReflectionOp.arg]: { params: 1 },
+  [ReflectionOp.classReference]: {
+    },
+  [ReflectionOp.propertySignature]: {
+    },
+  [ReflectionOp.property]: {
+    },
+  [ReflectionOp.jump]: {
+    },
+  [ReflectionOp.enum]: {
+    },
+  [ReflectionOp.enumMember]: {
+    },
+  [ReflectionOp.typeParameter]: {
+    },
+  [ReflectionOp.typeParameterDefault]: {
+    },
+  [ReflectionOp.mappedType]: {
+    },
+  [ReflectionOp.call]: {
+    },
+  [ReflectionOp.inline]: {
+    },
+  [ReflectionOp.inlineCall]: {
+    },
+  [ReflectionOp.loads]: {
+    },
+  [ReflectionOp.extends]: {
+    },
+  [ReflectionOp.infer]: {
+    },
+  [ReflectionOp.defaultValue]: {
+    },
+  [ReflectionOp.parameter]: {
+    },
+  [ReflectionOp.method]: {
+    },
+  [ReflectionOp.function]: {
+    },
+  [ReflectionOp.description]: {
+    },
+  [ReflectionOp.numberBrand]: {
+    },
+  [ReflectionOp.typeof]: {
+    },
+  [ReflectionOp.classExtends]: {
+    },
+  [ReflectionOp.distribute]: {
+    },
+  [ReflectionOp.jumpCondition]: {
+    },
+  [ReflectionOp.typeName]: {
+    },
+  [ReflectionOp.implements]: {
+    },
+  [ReflectionOp.tags]: {
+    }
+});
+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);
+  return;
+}
+__name(findVariable, "findVariable");
+function findConditionalFrame(frame) {
+  if (frame.conditional) return frame;
+  if (frame.previous) return findConditionalFrame(frame.previous);
+  return;
+}
+__name(findConditionalFrame, "findConditionalFrame");
+var CompilerProgram = class CompilerProgram2 {
+  static {
+    __name(this, "CompilerProgram");
+  }
+  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(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(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(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(ReflectionOp.moveFrame);
+    if (this.frame.previous) this.frame = this.frame.previous;
+  }
+  pushVariable(name, frame = this.frame) {
+    this.pushOpAtFrame(frame, ReflectionOp.var);
+    frame.variables.push({
+      index: frame.variables.length,
+      name
+    });
+    return frame.variables.length - 1;
+  }
+  pushTemplateParameter(name, withDefault = false) {
+    this.pushOp(withDefault ? ReflectionOp.typeParameterDefault : 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) && isIdentifier2(call.expression) && getIdentifierName(call.expression) === "__assignType" && call.arguments.length > 0) {
+    return call.arguments[0];
+  }
+  return;
+}
+__name(getAssignTypeExpression, "getAssignTypeExpression");
+function getReceiveTypeParameter(type) {
+  if (isUnionTypeNode(type)) {
+    for (const t of type.types) {
+      const rfn = getReceiveTypeParameter(t);
+      if (rfn) return rfn;
+    }
+  } else if (isTypeReferenceNode(type) && isIdentifier2(type.typeName) && getIdentifierName(type.typeName) === "ReceiveType" && !!type.typeArguments && type.typeArguments.length === 1) return type;
+  return;
+}
+__name(getReceiveTypeParameter, "getReceiveTypeParameter");
+var Cache = class {
+  static {
+    __name(this, "Cache");
+  }
+  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 = {};
+    }
+  }
+};
+var ReflectionTransformer = class {
+  static {
+    __name(this, "ReflectionTransformer");
+  }
+  constructor(context, cache3 = new Cache()) {
+    this.context = context;
+    this.cache = cache3;
+    this.embedAssignType = false;
+    this.compileDeclarations = /* @__PURE__ */ new Map();
+    this.embedDeclarations = /* @__PURE__ */ new Map();
+    this.compiledDeclarations = /* @__PURE__ */ new Set();
+    this.addImports = [];
+    this.overriddenHost = false;
+    this.knownClasses = {
+      "Int8Array": ReflectionOp.int8Array,
+      "Uint8Array": ReflectionOp.uint8Array,
+      "Uint8ClampedArray": ReflectionOp.uint8ClampedArray,
+      "Int16Array": ReflectionOp.int16Array,
+      "Uint16Array": ReflectionOp.uint16Array,
+      "Int32Array": ReflectionOp.int32Array,
+      "Uint32Array": ReflectionOp.uint32Array,
+      "Float32Array": ReflectionOp.float32Array,
+      "Float64Array": ReflectionOp.float64Array,
+      "ArrayBuffer": ReflectionOp.arrayBuffer,
+      "BigInt64Array": ReflectionOp.bigInt64Array,
+      "Date": ReflectionOp.date,
+      "RegExp": ReflectionOp.regexp,
+      "String": ReflectionOp.string,
+      "Number": ReflectionOp.number,
+      "BigInt": ReflectionOp.bigint,
+      "Boolean": 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: /* @__PURE__ */ __name((path) => this.host.fileExists(path), "fileExists"),
+      readFile: /* @__PURE__ */ __name((path) => this.host.readFile(path), "readFile"),
+      readDirectory: /* @__PURE__ */ __name((path, extensions, exclude, include, depth) => {
+        if (!this.host.readDirectory) return [];
+        return this.host.readDirectory(path, extensions || [], exclude, include || [], depth);
+      }, "readDirectory")
+    };
+    {
+      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(SyntaxKind2.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 configResolver = {
+      reflectionLevel: "normal",
+      ...config,
+      path: "",
+      mergeStrategy: "replace",
+      compilerOptions: this.compilerOptions
+    };
+    const match = /* @__PURE__ */ __name((path) => {
+      const mode = reflectionModeMatcher(config, path);
+      return {
+        mode,
+        tsConfigPath: "",
+        level: configResolver.reflectionLevel
+      };
+    }, "match");
+    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 = "\u03A9r";
+      for (let i = 0; ; i++) {
+        found = "\u03A9r" + (i ? i : "");
+        if (!locals.has(escapeLeadingUnderscores(found))) break;
+      }
+      this.tempResultIdentifier = this.f.createIdentifier(found);
+    } else {
+      this.tempResultIdentifier = this.f.createIdentifier("\u03A9r");
+    }
+    return this.tempResultIdentifier;
+  }
+  getConfigResolver(sourceFile) {
+    if (this.overriddenConfigResolver) {
+      return this.overriddenConfigResolver;
+    }
+    return getConfigResolver(this.cache.resolver, this.parseConfigHost, this.compilerOptions, sourceFile);
+  }
+  getReflectionConfig(sourceFile) {
+    const configResolver = this.getConfigResolver(sourceFile);
+    return configResolver.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 = [];
+    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) {
+      ts4.bindSourceFile(sourceFile, this.compilerOptions);
+    }
+    if (sourceFile.kind !== SyntaxKind2.SourceFile) {
+      if ("undefined" === typeof __require) {
+        throw new Error(`Invalid TypeScript library imported. SyntaxKind different ${sourceFile.kind} !== ${SyntaxKind2.SourceFile}.`);
+      }
+      const path = __require.resolve("typescript");
+      throw new Error(`Invalid TypeScript library imported. SyntaxKind different ${sourceFile.kind} !== ${SyntaxKind2.SourceFile}. typescript package path: ${path}`);
+    }
+    const visitor = /* @__PURE__ */ __name((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 === SyntaxKind2.Identifier && getIdentifierName(node.name) === "default") valid = false;
+        if (valid) {
+          const method = this.decorateFunctionExpression(this.f.createFunctionExpression(node.modifiers, node.asteriskToken, isIdentifier2(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) && isIdentifier2(first.typeName)) {
+            const name = getIdentifierName(first.typeName);
+            const index = typeParameters.findIndex((v) => getIdentifierName(v.name) === name);
+            let container = this.f.createIdentifier("globalThis");
+            if (isArrowFunction2(node.parent)) {
+              const next = this.getArrowFunction\u03A9PropertyAccessIdentifier(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) && isIdentifier2(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("\u03A9")), this.f.createToken(SyntaxKind2.QuestionDotToken), this.f.createNumericLiteral(index)));
+          }
+        }
+      } else if (isClassExpression(node)) {
+        return this.decorateClass(sourceFile, node);
+      } else if (isFunctionExpression(node)) {
+        return this.decorateFunctionExpression(this.injectReset\u03A9(node));
+      } else if (isFunctionDeclaration(node)) {
+        return this.decorateFunctionDeclaration(this.injectReset\u03A9(node));
+      } else if (isMethodDeclaration(node) || isConstructorDeclaration(node)) {
+        return this.injectReset\u03A9(node);
+      } else if (isArrowFunction2(node)) {
+        return this.decorateArrowFunction(this.injectReset\u03A9(node));
+      } else if ((isNewExpression(node) || isCallExpression(node)) && node.typeArguments && node.typeArguments.length > 0) {
+        if (isCallExpression(node)) {
+          const autoTypeFunctions = [
+            "valuesOf",
+            "propertiesOf",
+            "typeOf"
+          ];
+          if (isIdentifier2(node.expression) && autoTypeFunctions.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 (isArrowFunction2(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 (isIdentifier2(node.expression)) {
+          container = node.expression;
+        } else if (isPropertyAccessExpression(node.expression)) {
+          container = node.expression;
+        }
+        const assignQ = this.f.createBinaryExpression(this.f.createPropertyAccessExpression(container, "\u03A9"), this.f.createToken(SyntaxKind2.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 assignQ2 = this.f.createBinaryExpression(this.f.createPropertyAccessExpression(this.f.createPropertyAccessExpression(r, node.expression.name), "\u03A9"), this.f.createToken(SyntaxKind2.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(ts4.SyntaxKind.EqualsToken), node.expression.expression), this.f.createToken(ts4.SyntaxKind.CommaToken), assignQ2), this.f.createToken(ts4.SyntaxKind.CommaToken), r)), node.expression.name), node.typeArguments, node.arguments);
+          } else if (isParenthesizedExpression(node.expression.expression)) {
+            const r = this.getTempResultIdentifier();
+            const assignQ2 = this.f.createBinaryExpression(this.f.createPropertyAccessExpression(this.f.createPropertyAccessExpression(r, node.expression.name), "\u03A9"), this.f.createToken(SyntaxKind2.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(SyntaxKind2.EqualsToken), node.expression.expression.expression), this.f.createToken(SyntaxKind2.CommaToken), assignQ2), this.f.createToken(SyntaxKind2.CommaToken), r)), node.expression.name), node.typeArguments, node.arguments);
+            return this.f.createParenthesizedExpression(updatedNode);
+          } else ;
+        }
+        return this.f.createParenthesizedExpression(this.f.createBinaryExpression(assignQ, this.f.createToken(SyntaxKind2.CommaToken), node));
+      }
+      return node;
+    }, "visitor");
+    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 = /* @__PURE__ */ __name((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;
+    }, "compileDeclarations");
+    this.sourceFile = visitNode(this.sourceFile, compileDeclarations);
+    if (this.addImports.length) {
+      const handledIdentifier = [];
+      for (const imp of this.addImports) {
+        if (handledIdentifier.includes(getIdentifierName(imp.identifier))) continue;
+        handledIdentifier.push(getIdentifierName(imp.identifier));
+        if (this.getModuleType() === "cjs") {
+          const test = this.f.createIdentifier(getIdentifierName(imp.identifier));
+          const variable = this.f.createVariableStatement(void 0, this.f.createVariableDeclarationList([
+            this.f.createVariableDeclaration(this.f.createObjectBindingPattern([
+              this.f.createBindingElement(void 0, void 0, test)
+            ]), void 0, void 0, this.f.createCallExpression(this.f.createIdentifier("require"), void 0, [
+              imp.from
+            ]))
+          ], NodeFlags2.Const));
+          const typeDeclWithComment = addSyntheticLeadingComment(variable, SyntaxKind2.MultiLineCommentTrivia, "@ts-ignore", true);
+          newTopStatements.push(typeDeclWithComment);
+        } else {
+          const specifier = this.f.createImportSpecifier(false, void 0, imp.identifier);
+          const namedImports = this.f.createNamedImports([
+            specifier
+          ]);
+          const importStatement = this.f.createImportDeclaration(void 0, this.f.createImportClause(false, void 0, namedImports), imp.from);
+          const typeDeclWithComment = addSyntheticLeadingComment(importStatement, SyntaxKind2.MultiLineCommentTrivia, "@ts-ignore", true);
+          newTopStatements.push(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(SyntaxKind2.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)
+      ], ts4.NodeFlags.None)));
+    }
+    if (newTopStatements.length) {
+      const indexOfFirstLiteralExpression = this.sourceFile.statements.findIndex((v) => isExpressionStatement(v) && isStringLiteral3(v.expression));
+      const newStatements = indexOfFirstLiteralExpression === -1 ? [
+        ...newTopStatements,
+        ...this.sourceFile.statements
+      ] : [
+        ...this.sourceFile.statements.slice(0, indexOfFirstLiteralExpression + 1),
+        ...newTopStatements,
+        ...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;
+  }
+  getModuleType() {
+    if (this.compilerOptions.module === ts4.ModuleKind.Node16 || this.compilerOptions.module === ts4.ModuleKind.NodeNext) {
+      if (this.sourceFile.impliedNodeFormat === ts4.ModuleKind.ESNext) {
+        return "esm";
+      }
+      return "cjs";
+    }
+    return this.compilerOptions.module === ts4.ModuleKind.CommonJS ? "cjs" : "esm";
+  }
+  getArrowFunction\u03A9PropertyAccessIdentifier(node) {
+    let { parent } = node.original || node;
+    if (isVariableDeclaration(parent) && isIdentifier2(parent.name)) {
+      return parent.name;
+    } else if (isPropertyAssignment(parent) && isIdentifier2(parent.name)) {
+      const names = [];
+      while (parent) {
+        if (isObjectLiteralExpression(parent)) {
+          parent = parent.parent;
+        } else if (isVariableDeclaration(parent)) {
+          names.unshift(getIdentifierName(parent.name));
+          break;
+        } else if (isIdentifier2(parent.name)) {
+          names.unshift(getIdentifierName(parent.name));
+          parent = parent.parent;
+        } else {
+          return;
+        }
+      }
+      return this.f.createIdentifier(names.join("."));
+    }
+    return;
+  }
+  injectReset\u03A9(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 (isArrowFunction2(node)) {
+      const next = this.getArrowFunction\u03A9PropertyAccessIdentifier(node);
+      if (!next) return node;
+      container = next;
+    } else if ((isFunctionDeclaration(node) || isFunctionExpression(node)) && node.name) {
+      container = node.name;
+    } else if (isMethodDeclaration(node) && isIdentifier2(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("\u03A9")), this.f.createToken(ts4.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 (isArrowFunction2(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(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)
+    ], NodeFlags2.Const));
+    if (hasModifier(node, SyntaxKind2.ExportKeyword)) {
+      const exportNode = this.f.createExportDeclaration(void 0, false, this.f.createNamedExports([
+        this.f.createExportSpecifier(false, this.getDeclarationVariableName(name), this.getDeclarationVariableName(name))
+      ]));
+      return [
+        variable,
+        exportNode
+      ];
+    }
+    return [
+      variable
+    ];
+  }
+  extractPackStructOfExpression(node, program) {
+    switch (node.kind) {
+      case SyntaxKind2.StringLiteral: {
+        program.pushOp(ReflectionOp.string);
+        return;
+      }
+      case SyntaxKind2.NumericLiteral: {
+        program.pushOp(ReflectionOp.number);
+        return;
+      }
+      case SyntaxKind2.FalseKeyword:
+      case SyntaxKind2.TrueKeyword: {
+        program.pushOp(ReflectionOp.boolean);
+        return;
+      }
+      case SyntaxKind2.BigIntLiteral: {
+        program.pushOp(ReflectionOp.bigint);
+        return;
+      }
+      //Symbol() is a function call, so we need to check for that
+      case SyntaxKind2.CallExpression: {
+        const call = node;
+        if (isIdentifier2(call.expression) && getIdentifierName(call.expression) === "Symbol") {
+          program.pushOp(ReflectionOp.symbol);
+          return;
+        }
+        break;
+      }
+      //new Date()
+      case SyntaxKind2.NewExpression: {
+        const call = node;
+        if (isIdentifier2(call.expression)) {
+          const map = {
+            "Date": ReflectionOp.date,
+            "RegExp": ReflectionOp.regexp,
+            "Uint8Array": ReflectionOp.uint8Array,
+            "Uint8ClampedArray": ReflectionOp.uint8ClampedArray,
+            "Uint16Array": ReflectionOp.uint16Array,
+            "Uint32Array": ReflectionOp.uint32Array,
+            "Int8Array": ReflectionOp.int8Array,
+            "Int16Array": ReflectionOp.int16Array,
+            "Int32Array": ReflectionOp.int32Array,
+            "Float32Array": ReflectionOp.float32Array,
+            "Float64Array": ReflectionOp.float64Array,
+            "ArrayBuffer": ReflectionOp.arrayBuffer
+          };
+          const op = map[getIdentifierName(call.expression)];
+          if (op) {
+            program.pushOp(op);
+            return;
+          }
+        }
+        break;
+      }
+    }
+    program.pushOp(ReflectionOp.never);
+  }
+  parseDefaultValue(kind, defaultValue) {
+    switch (kind) {
+      case SyntaxKind2.NumberKeyword: {
+        return Number.isInteger(Number.parseFloat(defaultValue)) ? Number.parseInt(defaultValue) : Number.parseFloat(defaultValue);
+      }
+      case SyntaxKind2.BooleanKeyword: {
+        return Boolean(defaultValue?.trim());
+      }
+      case SyntaxKind2.BigIntKeyword: {
+        return Number.parseInt(defaultValue);
+      }
+      case SyntaxKind2.ObjectKeyword: {
+        return JSON.parse(defaultValue);
+      }
+      case SyntaxKind2.NullKeyword: {
+        return null;
+      }
+      case SyntaxKind2.TrueKeyword: {
+        return true;
+      }
+      case SyntaxKind2.FalseKeyword: {
+        return false;
+      }
+      case SyntaxKind2.UndefinedKeyword: {
+        return void 0;
+      }
+      case SyntaxKind2.StringLiteral:
+      case SyntaxKind2.StringKeyword:
+      default: {
+        if (defaultValue?.trim().toLowerCase() === "false") {
+          return false;
+        } else if (defaultValue?.trim().toLowerCase() === "true") {
+          return true;
+        }
+        return defaultValue;
+      }
+    }
+  }
+  parseTagReflection(node) {
+    const tags = {};
+    tags.hidden = extractJSDocBoolean(this.sourceFile, node, "hidden");
+    tags.ignore = extractJSDocBoolean(this.sourceFile, node, "ignore");
+    tags.internal = extractJSDocBoolean(this.sourceFile, node, "internal");
+    tags.alias = extractJSDocArray(this.sourceFile, node, "alias");
+    tags.permission = extractJSDocArray(this.sourceFile, node, "permission");
+    tags.domain = extractJSDocAttribute(this.sourceFile, node, "domain");
+    if (this.getReflectionConfig(this.sourceFile).level === "verbose") {
+      tags.title = extractJSDocAttribute(this.sourceFile, node, "title");
+    }
+    return tags;
+  }
+  extractTagReflections(program, node) {
+    if (!node) return;
+    const tags = this.parseTagReflection(node);
+    if (Object.entries(tags).filter(([, value]) => value !== void 0 && (!Array.isArray(value) || value.length > 0) && (typeof value !== "string" || value?.trim().replace(/^"/gm, "").replace(/"$/gm, ""))).length > 0) {
+      program.pushOp(ReflectionOp.tags, program.findOrAddStackEntry(this.f.createObjectLiteralExpression(this.f.createNodeArray(Object.entries(tags).filter(([, value]) => value !== void 0 && (!Array.isArray(value) || value.length > 0) && (typeof value !== "string" || value.trim().replace(/^"/gm, "").replace(/"$/gm, ""))).map(([key, value]) => {
+        return this.f.createPropertyAssignment(key, Array.isArray(value) ? this.f.createArrayLiteralExpression(value.map((item) => this.valueToExpression(item))) : typeof value === "boolean" ? value ? this.f.createTrue() : this.f.createFalse() : this.valueToExpression(value));
+      })))));
+    }
+  }
+  extractDefaultValueReflection(program, node) {
+    if (!node) return;
+    let defaultValue = extractJSDocAttribute(this.sourceFile, node, "defaultValue");
+    if (!defaultValue) {
+      defaultValue = extractJSDocAttribute(this.sourceFile, node, "default");
+    }
+    if (defaultValue) {
+      program.pushOp(ReflectionOp.defaultValue, program.findOrAddStackEntry(this.parseDefaultValue((node.kind === SyntaxKind2.ClassDeclaration || node.kind === SyntaxKind2.ClassExpression ? node?.name?.parent?.kind : node.kind === SyntaxKind2.PropertySignature || node.kind === SyntaxKind2.PropertyDeclaration ? node.type?.kind : node.kind) || SyntaxKind2.StringKeyword, defaultValue.trim().replace(/^"/gm, "").replace(/"$/gm, ""))));
+    }
+  }
+  extractDescriptionReflection(program, node) {
+    if (!node || this.getReflectionConfig(this.sourceFile).level !== "verbose") return;
+    const description = extractJSDocAttribute(this.sourceFile, node, "description");
+    if (description) {
+      program.pushOp(ReflectionOp.description, program.findOrAddStackEntry(description.trim().replace(/^"/gm, "").replace(/"$/gm, "")));
+    }
+  }
+  extractPackStructOfType(node, program) {
+    if (isParenthesizedTypeNode(node)) return this.extractPackStructOfType(node.type, program);
+    switch (node.kind) {
+      case SyntaxKind2.StringKeyword: {
+        program.pushOp(ReflectionOp.string);
+        break;
+      }
+      case SyntaxKind2.NumberKeyword: {
+        program.pushOp(ReflectionOp.number);
+        break;
+      }
+      case SyntaxKind2.BooleanKeyword: {
+        program.pushOp(ReflectionOp.boolean);
+        break;
+      }
+      case SyntaxKind2.BigIntKeyword: {
+        program.pushOp(ReflectionOp.bigint);
+        break;
+      }
+      case SyntaxKind2.VoidKeyword: {
+        program.pushOp(ReflectionOp.void);
+        break;
+      }
+      case SyntaxKind2.UnknownKeyword: {
+        program.pushOp(ReflectionOp.unknown);
+        break;
+      }
+      case SyntaxKind2.ObjectKeyword: {
+        program.pushOp(ReflectionOp.object);
+        break;
+      }
+      case SyntaxKind2.SymbolKeyword: {
+        program.pushOp(ReflectionOp.symbol);
+        break;
+      }
+      case SyntaxKind2.NullKeyword: {
+        program.pushOp(ReflectionOp.null);
+        break;
+      }
+      case SyntaxKind2.NeverKeyword: {
+        program.pushOp(ReflectionOp.never);
+        break;
+      }
+      case SyntaxKind2.AnyKeyword: {
+        program.pushOp(ReflectionOp.any);
+        break;
+      }
+      case SyntaxKind2.UndefinedKeyword: {
+        program.pushOp(ReflectionOp.undefined);
+        break;
+      }
+      case SyntaxKind2.TrueKeyword: {
+        program.pushOp(ReflectionOp.literal, program.pushStack(this.f.createTrue()));
+        break;
+      }
+      case SyntaxKind2.FalseKeyword: {
+        program.pushOp(ReflectionOp.literal, program.pushStack(this.f.createFalse()));
+        break;
+      }
+      case SyntaxKind2.ClassDeclaration:
+      case SyntaxKind2.ClassExpression: {
+        const narrowed = node;
+        if (node) {
+          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 === SyntaxKind2.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(ReflectionOp.classReference, index);
+                  program.popFrameImplicit();
+                }
+              }
+            }
+          }
+          for (const member of narrowed.members) {
+            const name = getNameAsString(member.name);
+            if (name) {
+              const has = members.some((v) => getNameAsString(v.name) === name);
+              if (has) continue;
+            }
+            members.push(member);
+            this.extractPackStructOfType(member, program);
+          }
+          program.pushOp(ReflectionOp.class);
+          if (narrowed.heritageClauses) {
+            for (const heritageClause of narrowed.heritageClauses) {
+              if (heritageClause.token === SyntaxKind2.ExtendsKeyword) {
+                const first = heritageClause.types[0];
+                if (isExpressionWithTypeArguments(first) && first.typeArguments) {
+                  for (const typeArgument of first.typeArguments) {
+                    this.extractPackStructOfType(typeArgument, program);
+                  }
+                  program.pushOp(ReflectionOp.classExtends, first.typeArguments.length);
+                }
+              } else if (heritageClause.token === SyntaxKind2.ImplementsKeyword) {
+                for (const type of heritageClause.types) {
+                  this.extractPackStructOfTypeReference(type, program);
+                }
+                program.pushOp(ReflectionOp.implements, heritageClause.types.length);
+              }
+            }
+          }
+          if (narrowed.name) this.resolveTypeName(getIdentifierName(narrowed.name), program);
+          this.extractDefaultValueReflection(program, narrowed.name?.parent);
+          this.extractDescriptionReflection(program, narrowed.name?.parent);
+          this.extractTagReflections(program, narrowed.name?.parent);
+        }
+        break;
+      }
+      case SyntaxKind2.IntersectionType: {
+        const narrowed = node;
+        program.pushFrame();
+        for (const type of narrowed.types) {
+          this.extractPackStructOfType(type, program);
+        }
+        program.pushOp(ReflectionOp.intersection);
+        program.popFrameImplicit();
+        break;
+      }
+      case SyntaxKind2.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(ReflectionOp.never);
+        }
+        let modifier = 0;
+        if (narrowed.questionToken) {
+          if (narrowed.questionToken.kind === SyntaxKind2.QuestionToken) {
+            modifier |= 1;
+          }
+          if (narrowed.questionToken.kind === SyntaxKind2.MinusToken) {
+            modifier |= 2;
+          }
+        }
+        if (narrowed.readonlyToken) {
+          if (narrowed.readonlyToken.kind === SyntaxKind2.ReadonlyKeyword) {
+            modifier |= 4;
+          }
+          if (narrowed.readonlyToken.kind === SyntaxKind2.MinusToken) {
+            modifier |= 8;
+          }
+        }
+        program.pushCoRoutine();
+        if (narrowed.nameType) program.pushFrame();
+        if (narrowed.type) {
+          this.extractPackStructOfType(narrowed.type, program);
+        } else {
+          program.pushOp(ReflectionOp.never);
+        }
+        if (narrowed.nameType) {
+          this.extractPackStructOfType(narrowed.nameType, program);
+          program.pushOp(ReflectionOp.tuple);
+          program.popFrameImplicit();
+        }
+        const coRoutineIndex = program.popCoRoutine();
+        if (narrowed.nameType) {
+          program.pushOp(ReflectionOp.mappedType2, coRoutineIndex, modifier);
+        } else {
+          program.pushOp(ReflectionOp.mappedType, coRoutineIndex, modifier);
+        }
+        program.popFrameImplicit();
+        break;
+      }
+      case SyntaxKind2.TypeAliasDeclaration: {
+        let narrowed = node;
+        if (program.sourceFile && getNameAsString(narrowed.name) === "TypeAnnotation") {
+          const attribute = extractJSDocAttribute(program.sourceFile, narrowed, "intrinsic");
+          if (attribute !== void 0) {
+            narrowed = this.intrinsicMetaDeclaration;
+          }
+        }
+        this.extractPackStructOfType(narrowed.type, program);
+        if (narrowed.name) this.resolveTypeName(getIdentifierName(narrowed.name), program);
+        break;
+      }
+      case SyntaxKind2.TypeLiteral:
+      case SyntaxKind2.InterfaceDeclaration: {
+        const narrowed = node;
+        let descriptionNode = narrowed;
+        program.pushFrame();
+        if (isInterfaceDeclaration(narrowed) && narrowed.heritageClauses) {
+          for (const heritage of narrowed.heritageClauses) {
+            if (heritage.token === SyntaxKind2.ExtendsKeyword) {
+              for (const extendType of heritage.types) {
+                this.extractPackStructOfTypeReference(extendType, program);
+              }
+            }
+          }
+        }
+        for (const member of narrowed.members) {
+          this.extractPackStructOfType(member, program);
+        }
+        program.pushOp(ReflectionOp.objectLiteral);
+        if (isTypeLiteralNode(narrowed)) {
+          descriptionNode = narrowed.parent;
+        }
+        this.extractDefaultValueReflection(program, descriptionNode);
+        this.extractDescriptionReflection(program, descriptionNode);
+        this.extractTagReflections(program, descriptionNode);
+        if (isInterfaceDeclaration(narrowed)) {
+          if (narrowed.name) this.resolveTypeName(getIdentifierName(narrowed.name), program);
+        }
+        program.popFrameImplicit();
+        break;
+      }
+      case SyntaxKind2.TypeReference: {
+        this.extractPackStructOfTypeReference(node, program);
+        break;
+      }
+      case SyntaxKind2.ArrayType: {
+        this.extractPackStructOfType(node.elementType, program);
+        program.pushOp(ReflectionOp.array);
+        break;
+      }
+      case SyntaxKind2.RestType: {
+        let type = node.type;
+        if (isArrayTypeNode(type)) {
+          type = type.elementType;
+        }
+        this.extractPackStructOfType(type, program);
+        program.pushOp(ReflectionOp.rest);
+        break;
+      }
+      case SyntaxKind2.TupleType: {
+        program.pushFrame();
+        for (const element of node.elements) {
+          if (isOptionalTypeNode(element)) {
+            this.extractPackStructOfType(element.type, program);
+            program.pushOp(ReflectionOp.tupleMember);
+            program.pushOp(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(ReflectionOp.rest);
+            } else {
+              this.extractPackStructOfType(element.type, program);
+            }
+            const index = program.findOrAddStackEntry(getIdentifierName(element.name));
+            program.pushOp(ReflectionOp.namedTupleMember, index);
+            if (element.questionToken) {
+              program.pushOp(ReflectionOp.optional);
+            }
+          } else {
+            this.extractPackStructOfType(element, program);
+          }
+        }
+        program.pushOp(ReflectionOp.tuple);
+        program.popFrameImplicit();
+        break;
+      }
+      case SyntaxKind2.PropertySignature: {
+        const narrowed = node;
+        if (narrowed.type) {
+          this.extractPackStructOfType(narrowed.type, program);
+          const name = getPropertyName(this.f, narrowed.name);
+          program.pushOp(ReflectionOp.propertySignature, program.findOrAddStackEntry(name));
+          if (narrowed.questionToken) {
+            program.pushOp(ReflectionOp.optional);
+          }
+          if (hasModifier(narrowed, SyntaxKind2.ReadonlyKeyword)) program.pushOp(ReflectionOp.readonly);
+          else {
+            const readonly = extractJSDocBoolean(this.sourceFile, narrowed, "readonly");
+            if (readonly) {
+              program.pushOp(ReflectionOp.readonly);
+            }
+          }
+          this.extractDefaultValueReflection(program, narrowed);
+          this.extractDescriptionReflection(program, narrowed);
+          this.extractTagReflections(program, narrowed);
+        } else {
+          program.pushOp(ReflectionOp.unknown);
+        }
+        break;
+      }
+      case SyntaxKind2.PropertyDeclaration: {
+        const narrowed = node;
+        if (false === this.getExplicitReflectionMode(program.sourceFile, narrowed)) return;
+        if (narrowed.type) {
+          this.extractPackStructOfType(narrowed.type, program);
+        } else if (narrowed.initializer) {
+          this.extractPackStructOfExpression(narrowed.initializer, program);
+        } else {
+          program.pushOp(ReflectionOp.unknown);
+        }
+        program.pushOp(ReflectionOp.property, program.findOrAddStackEntry(getPropertyName(this.f, narrowed.name)));
+        if (narrowed.questionToken) program.pushOp(ReflectionOp.optional);
+        if (hasModifier(narrowed, SyntaxKind2.ReadonlyKeyword)) {
+          program.pushOp(ReflectionOp.readonly);
+        } else {
+          const readonly = extractJSDocBoolean(this.sourceFile, narrowed, "readonly");
+          if (readonly) {
+            program.pushOp(ReflectionOp.readonly);
+          }
+        }
+        if (hasModifier(narrowed, SyntaxKind2.PrivateKeyword)) program.pushOp(ReflectionOp.private);
+        if (hasModifier(narrowed, SyntaxKind2.ProtectedKeyword)) program.pushOp(ReflectionOp.protected);
+        if (hasModifier(narrowed, SyntaxKind2.AbstractKeyword)) program.pushOp(ReflectionOp.abstract);
+        if (hasModifier(narrowed, SyntaxKind2.StaticKeyword)) program.pushOp(ReflectionOp.static);
+        if (narrowed.initializer) {
+          program.pushOp(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)
+          ]))));
+        } else {
+          this.extractDefaultValueReflection(program, narrowed);
+        }
+        this.extractDescriptionReflection(program, narrowed);
+        this.extractTagReflections(program, narrowed);
+        break;
+      }
+      case SyntaxKind2.ConditionalType: {
+        const narrowed = node;
+        const distributiveOverIdentifier = isTypeReferenceNode(narrowed.checkType) && isIdentifier2(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(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(ReflectionOp.jumpCondition, trueProgram, falseProgram);
+        program.moveFrame();
+        if (distributiveOverIdentifier) {
+          const coRoutineIndex = program.popCoRoutine();
+          program.pushOp(ReflectionOp.distribute, coRoutineIndex);
+          program.popFrameImplicit();
+        }
+        break;
+      }
+      case SyntaxKind2.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(ReflectionOp.infer, variable.frameOffset, variable.stackIndex);
+        } else {
+          program.pushOp(ReflectionOp.never);
+        }
+        break;
+      }
+      case SyntaxKind2.MethodSignature:
+      case SyntaxKind2.MethodDeclaration:
+      case SyntaxKind2.Constructor:
+      case SyntaxKind2.ArrowFunction:
+      case SyntaxKind2.FunctionExpression:
+      case SyntaxKind2.ConstructSignature:
+      case SyntaxKind2.ConstructorType:
+      case SyntaxKind2.FunctionType:
+      case SyntaxKind2.CallSignature:
+      case SyntaxKind2.FunctionDeclaration: {
+        const narrowed = node;
+        if (false === this.getExplicitReflectionMode(program.sourceFile, narrowed)) {
+          program.pushOp(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 = isIdentifier2(parameter.name) ? getNameAsString(parameter.name) : "param" + i;
+          const type = parameter.type ? parameter.dotDotDotToken && isArrayTypeNode(parameter.type) ? parameter.type.elementType : parameter.type : void 0;
+          if (type) {
+            this.extractPackStructOfType(type, program);
+          } else {
+            program.pushOp(ReflectionOp.any);
+          }
+          if (parameter.dotDotDotToken) {
+            program.pushOp(ReflectionOp.rest);
+          }
+          program.pushOp(ReflectionOp.parameter, program.findOrAddStackEntry(parameterName));
+          if (parameter.questionToken) program.pushOp(ReflectionOp.optional);
+          if (hasModifier(parameter, SyntaxKind2.PublicKeyword)) program.pushOp(ReflectionOp.public);
+          if (hasModifier(parameter, SyntaxKind2.PrivateKeyword)) program.pushOp(ReflectionOp.private);
+          if (hasModifier(parameter, SyntaxKind2.ProtectedKeyword)) program.pushOp(ReflectionOp.protected);
+          if (hasModifier(parameter, SyntaxKind2.ReadonlyKeyword)) program.pushOp(ReflectionOp.readonly);
+          else {
+            let readonly = extractJSDocBoolean(this.sourceFile, parameter, "readonly");
+            if (readonly) {
+              program.pushOp(ReflectionOp.readonly);
+            } else {
+              readonly = extractJSDocBoolean(this.sourceFile, narrowed, "readonly");
+              if (readonly) {
+                program.pushOp(ReflectionOp.readonly);
+              }
+            }
+          }
+          if (parameter.initializer && parameter.type && !getReceiveTypeParameter(parameter.type)) {
+            program.pushOp(ReflectionOp.defaultValue, program.findOrAddStackEntry(this.f.createArrowFunction(void 0, void 0, [], void 0, void 0, parameter.initializer)));
+          } else {
+            this.extractDefaultValueReflection(program, parameter);
+          }
+          this.extractDescriptionReflection(program, parameter);
+        }
+        if (narrowed.type) {
+          this.extractPackStructOfType(narrowed.type, program);
+        } else {
+          program.pushOp(ReflectionOp.any);
+        }
+        program.pushOp(isCallSignatureDeclaration(node) ? ReflectionOp.callSignature : isMethodSignature(narrowed) || isConstructSignatureDeclaration(narrowed) ? ReflectionOp.methodSignature : isMethodDeclaration(narrowed) || isConstructorDeclaration(narrowed) ? ReflectionOp.method : ReflectionOp.function, program.findOrAddStackEntry(name));
+        if (isMethodDeclaration(narrowed)) {
+          if (hasModifier(narrowed, SyntaxKind2.PrivateKeyword)) program.pushOp(ReflectionOp.private);
+          if (hasModifier(narrowed, SyntaxKind2.ProtectedKeyword)) program.pushOp(ReflectionOp.protected);
+          if (hasModifier(narrowed, SyntaxKind2.AbstractKeyword)) program.pushOp(ReflectionOp.abstract);
+          if (hasModifier(narrowed, SyntaxKind2.StaticKeyword)) program.pushOp(ReflectionOp.static);
+        }
+        this.extractDefaultValueReflection(program, narrowed);
+        this.extractDescriptionReflection(program, narrowed);
+        this.extractTagReflections(program, narrowed);
+        program.popFrameImplicit();
+        break;
+      }
+      case SyntaxKind2.LiteralType: {
+        const narrowed = node;
+        if (narrowed.literal.kind === SyntaxKind2.NullKeyword) {
+          program.pushOp(ReflectionOp.null);
+        } else {
+          program.pushOp(ReflectionOp.literal, program.findOrAddStackEntry(narrowed.literal));
+        }
+        break;
+      }
+      case SyntaxKind2.TemplateLiteralType: {
+        const narrowed = node;
+        program.pushFrame();
+        if (narrowed.head.rawText) {
+          program.pushOp(ReflectionOp.literal, program.findOrAddStackEntry(narrowed.head.rawText));
+        }
+        for (const span of narrowed.templateSpans) {
+          this.extractPackStructOfType(span.type, program);
+          if (span.literal.rawText) {
+            program.pushOp(ReflectionOp.literal, program.findOrAddStackEntry(span.literal.rawText));
+          }
+        }
+        program.pushOp(ReflectionOp.templateLiteral);
+        program.popFrameImplicit();
+        break;
+      }
+      case SyntaxKind2.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(ReflectionOp.union);
+          program.popFrameImplicit();
+        }
+        break;
+      }
+      case SyntaxKind2.EnumDeclaration: {
+        const narrowed = node;
+        program.pushFrame();
+        for (const type of narrowed.members) {
+          const name = getPropertyName(this.f, type.name);
+          program.pushOp(ReflectionOp.enumMember, program.findOrAddStackEntry(name));
+          this.extractDescriptionReflection(program, type);
+          if (type.initializer) {
+            program.pushOp(ReflectionOp.defaultValue, program.findOrAddStackEntry(this.f.createArrowFunction(void 0, void 0, [], void 0, void 0, type.initializer)));
+          }
+        }
+        program.pushOp(ReflectionOp.enum);
+        this.extractDefaultValueReflection(program, narrowed);
+        this.extractDescriptionReflection(program, narrowed);
+        this.extractTagReflections(program, narrowed);
+        if (narrowed.name) this.resolveTypeName(getIdentifierName(narrowed.name), program);
+        program.popFrameImplicit();
+        break;
+      }
+      case SyntaxKind2.IndexSignature: {
+        const narrowed = node;
+        if (narrowed.parameters.length && narrowed.parameters[0].type) {
+          this.extractPackStructOfType(narrowed.parameters[0].type, program);
+        } else {
+          program.pushOp(ReflectionOp.any);
+        }
+        this.extractPackStructOfType(narrowed.type, program);
+        program.pushOp(ReflectionOp.indexSignature);
+        break;
+      }
+      case SyntaxKind2.TypeQuery: {
+        const narrowed = node;
+        if (isIdentifier2(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(ReflectionOp.typeof, program.pushStack(this.f.createArrowFunction(void 0, void 0, [], void 0, void 0, expression)));
+        break;
+      }
+      case SyntaxKind2.TypeOperator: {
+        const narrowed = node;
+        if (narrowed.type.kind === SyntaxKind2.ThisType) {
+          program.pushOp(ReflectionOp.any);
+          break;
+        }
+        switch (narrowed.operator) {
+          case SyntaxKind2.KeyOfKeyword: {
+            this.extractPackStructOfType(narrowed.type, program);
+            program.pushOp(ReflectionOp.keyof);
+            break;
+          }
+          case SyntaxKind2.ReadonlyKeyword: {
+            this.extractPackStructOfType(narrowed.type, program);
+            program.pushOp(ReflectionOp.readonly);
+            break;
+          }
+          default: {
+            program.pushOp(ReflectionOp.never);
+          }
+        }
+        break;
+      }
+      case SyntaxKind2.IndexedAccessType: {
+        const narrowed = node;
+        this.extractPackStructOfType(narrowed.objectType, program);
+        this.extractPackStructOfType(narrowed.indexType, program);
+        program.pushOp(ReflectionOp.indexAccess);
+        break;
+      }
+      case SyntaxKind2.Identifier: {
+        const narrowed = node;
+        const variable = program.findVariable(getIdentifierName(narrowed));
+        if (variable) {
+          program.pushOp(ReflectionOp.loads, variable.frameOffset, variable.stackIndex);
+        } else {
+          program.pushOp(ReflectionOp.never);
+        }
+        break;
+      }
+      default: {
+        program.pushOp(ReflectionOp.never);
+      }
+    }
+  }
+  getGlobalLibs() {
+    if (this.cache.globalSourceFiles) return this.cache.globalSourceFiles;
+    this.cache.globalSourceFiles = [];
+    const options = {
+      ...this.compilerOptions
+    };
+    if (options.target && options.target === ScriptTarget2.ESNext) {
+      options.target = ScriptTarget2.ES2022;
+    }
+    const libs = knownLibFilesForCompilerOptions(options, ts4);
+    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 === SyntaxKind2.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]) {
+          if (!isParameter(found.declarations[0])) {
+            declaration = found.declarations[0];
+            break;
+          }
+        }
+      }
+      if (current.kind === SyntaxKind2.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 === SyntaxKind2.TypeParameter && declaration.parent.kind === SyntaxKind2.TypeAliasDeclaration) {
+      declaration = declaration.parent;
+    }
+    if (!declaration) return;
+    return {
+      declaration,
+      importDeclaration,
+      typeOnly
+    };
+  }
+  getDeclarationVariableName(typeName) {
+    if (isIdentifier2(typeName)) {
+      return this.f.createIdentifier("__\u03A9" + getIdentifierName(typeName));
+    }
+    function joinQualifiedName2(name) {
+      if (isIdentifier2(name)) return getIdentifierName(name);
+      return joinQualifiedName2(name.left) + "_" + getIdentifierName(name.right);
+    }
+    __name(joinQualifiedName2, "joinQualifiedName");
+    return this.f.createIdentifier("__\u03A9" + joinQualifiedName2(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);
+    const res = reflectionModeMatcher({
+      reflection: "default",
+      exclude: resolver.config.exclude
+    }, fileName);
+    return res === "never";
+  }
+  extractPackStructOfTypeReference(type, program) {
+    const typeName = isTypeReferenceNode(type) ? type.typeName : isIdentifier2(type.expression) ? type.expression : void 0;
+    if (!typeName) {
+      program.pushOp(ReflectionOp.any);
+      return;
+    }
+    if (isIdentifier2(typeName) && getIdentifierName(typeName) === "InlineRuntimeType" && type.typeArguments && type.typeArguments[0] && isTypeQueryNode(type.typeArguments[0])) {
+      const expression = serializeEntityNameAsExpression(this.f, type.typeArguments[0].exprName);
+      program.pushOp(ReflectionOp.arg, program.pushStack(expression));
+      return;
+    }
+    if (isIdentifier2(typeName) && getIdentifierName(typeName) !== "constructor" && this.knownClasses[getIdentifierName(typeName)]) {
+      const name = getIdentifierName(typeName);
+      const op = this.knownClasses[name];
+      program.pushOp(op);
+    } else if (isIdentifier2(typeName) && getIdentifierName(typeName) === "Promise") {
+      if (type.typeArguments && type.typeArguments[0]) {
+        this.extractPackStructOfType(type.typeArguments[0], program);
+      } else {
+        program.pushOp(ReflectionOp.any);
+      }
+      program.pushOp(ReflectionOp.promise);
+    } else if (isIdentifier2(typeName) && getIdentifierName(typeName) === "integer") {
+      program.pushOp(ReflectionOp.numberBrand, TypeNumberBrand.integer);
+    } else if (isIdentifier2(typeName) && getIdentifierName(typeName) !== "constructor" && TypeNumberBrand[getIdentifierName(typeName)] !== void 0) {
+      program.pushOp(ReflectionOp.numberBrand, TypeNumberBrand[getIdentifierName(typeName)]);
+    } else {
+      if (isIdentifier2(typeName)) {
+        const variable = program.findVariable(getIdentifierName(typeName));
+        if (variable) {
+          program.pushOp(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 (isIdentifier2(typeName.left)) {
+            const resolved2 = this.resolveDeclaration(typeName.left);
+            if (resolved2 && isEnumDeclaration(resolved2.declaration)) {
+              let lastExpression;
+              let indexValue = 0;
+              for (const member of resolved2.declaration.members) {
+                if (getNameAsString(member.name) === getNameAsString(typeName.right)) {
+                  if (member.initializer) {
+                    program.pushOp(ReflectionOp.arg, program.pushStack(this.nodeConverter.toExpression(member.initializer)));
+                  } else if (lastExpression) {
+                    const exp = this.nodeConverter.toExpression(lastExpression);
+                    program.pushOp(ReflectionOp.arg, program.pushStack(this.f.createBinaryExpression(exp, SyntaxKind2.PlusToken, this.nodeConverter.toExpression(indexValue))));
+                  } else {
+                    program.pushOp(ReflectionOp.arg, program.pushStack(this.nodeConverter.toExpression(indexValue)));
+                  }
+                  return;
+                } else {
+                  indexValue++;
+                  if (member.initializer) {
+                    lastExpression = member.initializer;
+                    indexValue = 0;
+                  }
+                }
+              }
+            }
+          }
+        }
+        program.pushOp(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 (isIdentifier2(typeName)) ensureImportIsEmitted(resolved.importDeclaration, typeName);
+        program.pushOp(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(ReflectionOp.any);
+          }
+          program.pushOp(ReflectionOp.array);
+          return;
+        } else if (name === "Function") {
+          program.pushFrame();
+          const index2 = program.pushStack(this.f.createArrowFunction(void 0, void 0, [], void 0, void 0, this.f.createIdentifier("Function")));
+          program.pushOp(ReflectionOp.functionReference, index2);
+          program.popFrameImplicit();
+          return;
+        } else if (name === "Set") {
+          if (type.typeArguments && type.typeArguments[0]) {
+            this.extractPackStructOfType(type.typeArguments[0], program);
+          } else {
+            program.pushOp(ReflectionOp.any);
+          }
+          program.pushOp(ReflectionOp.set);
+          return;
+        } else if (name === "Map") {
+          if (type.typeArguments && type.typeArguments[0]) {
+            this.extractPackStructOfType(type.typeArguments[0], program);
+          } else {
+            program.pushOp(ReflectionOp.any);
+          }
+          if (type.typeArguments && type.typeArguments[1]) {
+            this.extractPackStructOfType(type.typeArguments[1], program);
+          } else {
+            program.pushOp(ReflectionOp.any);
+          }
+          program.pushOp(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(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")) {
+                const resolverDecVariable = this.resolveImportSpecifier(getEscapedText(runtimeTypeName), resolved.importDeclaration, this.sourceFile);
+                if (!resolverDecVariable) {
+                  debug2(`Symbol ${runtimeTypeName.escapedText} not found in ${declarationSourceFile.fileName}`);
+                  this.resolveTypeOnlyImport(typeName, program);
+                  return;
+                }
+                this.addImports.push({
+                  identifier: runtimeTypeName,
+                  from: resolved.importDeclaration.moduleSpecifier
+                });
+              } else {
+                const reflection = this.getReflectionConfig(declarationSourceFile);
+                if (reflection.mode === "never") {
+                  this.resolveTypeOnlyImport(typeName, program);
+                  return;
+                }
+                const declarationReflection = this.isWithReflection(declarationSourceFile, declaration);
+                if (!declarationReflection) {
+                  this.resolveTypeOnlyImport(typeName, program);
+                  return;
+                }
+                this.addImports.push({
+                  identifier: runtimeTypeName,
+                  from: resolved.importDeclaration.moduleSpecifier
+                });
+              }
+            }
+          } else {
+            const reflection = this.isWithReflection(program.sourceFile, declaration);
+            if (!reflection) {
+              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(ReflectionOp.inlineCall, index, type.typeArguments.length);
+        } else {
+          program.pushOp(ReflectionOp.inline, index);
+        }
+      } else if (isClassDeclaration(declaration) || isFunctionDeclaration(declaration) || isFunctionExpression(declaration) || isArrowFunction2(declaration)) {
+        if (resolved.typeOnly) {
+          this.resolveTypeOnlyImport(typeName, program);
+          return;
+        }
+        const reflection = declarationSourceFile?.fileName.endsWith(".d.ts") || this.isWithReflection(program.sourceFile, declaration);
+        if (!reflection) {
+          this.resolveTypeOnlyImport(typeName, program);
+          return;
+        }
+        if (resolved.importDeclaration && isIdentifier2(typeName)) ensureImportIsEmitted(resolved.importDeclaration, typeName);
+        program.pushFrame();
+        if (type.typeArguments) {
+          for (const typeArgument of type.typeArguments) {
+            this.extractPackStructOfType(typeArgument, program);
+          }
+        }
+        const body = isIdentifier2(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) ? ReflectionOp.classReference : 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 === SyntaxKind2.Block) return current;
+      if (current.kind === SyntaxKind2.ClassDeclaration) return current;
+      if (current.kind === SyntaxKind2.ClassExpression) return current;
+      if (current.kind === SyntaxKind2.Constructor) return current.parent;
+      if (current.kind === SyntaxKind2.MethodDeclaration) return current.parent;
+      if (current.kind === SyntaxKind2.ArrowFunction || current.kind === SyntaxKind2.FunctionDeclaration || current.kind === SyntaxKind2.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) {
+    const declarationUser = this.getTypeUser(declaration);
+    const typeUser = this.getTypeUser(type);
+    return declarationUser !== typeUser;
+  }
+  resolveTypeOnlyImport(entityName, program) {
+    program.pushOp(ReflectionOp.any);
+    const typeName = ts4.isIdentifier(entityName) ? getIdentifierName(entityName) : getIdentifierName(entityName.right);
+    this.resolveTypeName(typeName, program);
+  }
+  resolveTypeName(typeName, program) {
+    if (!typeName) return;
+    program.pushOp(ReflectionOp.typeName, program.findOrAddStackEntry(typeName));
+  }
+  resolveTypeParameter(declaration, type, program) {
+    const isUsedInFunction = isFunctionLike(declaration.parent);
+    const resolveRuntimeTypeParameter = isUsedInFunction && program.isResolveFunctionParameters(declaration.parent) || this.needsToBeInferred(declaration, type);
+    if (resolveRuntimeTypeParameter) {
+      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 = /* @__PURE__ */ __name((node) => {
+            node = visitEachChild(node, searchArgument, this.context);
+            if (isTypeReferenceNode(node) && isIdentifier2(node.typeName) && node.typeName.escapedText === argumentName) {
+              found = true;
+              node = this.f.createInferTypeNode(declaration);
+            }
+            return node;
+          }, "searchArgument");
+          if (isIdentifier2(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) && isIdentifier2(v.type.typeName) && getIdentifierName(v.type.typeName) === "ReceiveType");
+        if (isReceiveType) {
+          program.pushOp(ReflectionOp.inline, program.pushStack(isReceiveType.parameterName));
+        } else {
+          for (const foundUser of foundUsers) {
+            program.pushConditionalFrame();
+            program.pushOp(ReflectionOp.typeof, program.pushStack(this.f.createArrowFunction(void 0, void 0, [], void 0, void 0, foundUser.parameterName)));
+            this.extractPackStructOfType(foundUser.type, program);
+            program.pushOp(ReflectionOp.extends);
+            const found = program.findVariable(getIdentifierName(declaration.name));
+            if (found) {
+              this.extractPackStructOfType(declaration.name, program);
+            } else {
+              program.pushOp(ReflectionOp.any);
+            }
+            this.extractPackStructOfType({
+              kind: SyntaxKind2.NeverKeyword
+            }, program);
+            program.pushOp(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(ReflectionOp.never);
+        }
+        if (isUsedInFunction) program.resolveFunctionParametersDecrease(declaration.parent);
+      } else {
+        program.pushOp(ReflectionOp.never);
+      }
+    } else {
+      program.pushOp(ReflectionOp.any);
+    }
+  }
+  createAccessorForEntityName(e) {
+    return this.f.createPropertyAccessExpression(isIdentifier2(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];
+      }
+    }
+    return;
+  }
+  resolveImportSpecifier(_declarationName, importOrExport, sourceFile) {
+    const declarationName = "string" === typeof _declarationName ? _declarationName : getIdentifierName(_declarationName);
+    if (!importOrExport.moduleSpecifier || !isStringLiteral3(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;
+    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;
+      }
+    }
+    return;
+  }
+  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 || !isStringLiteral3(statement.moduleSpecifier)) {
+              if (!statement.moduleSpecifier || !isStringLiteral3(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 found2 = this.resolveImportSpecifier(element.propertyName ? getEscapedText(element.propertyName) : declarationName, importOrExport, sourceFile);
+                      if (found2) return found2;
+                    }
+                    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;
+      }
+    }
+    return;
+  }
+  getTypeOfType(type) {
+    const reflection = this.isWithReflection(this.sourceFile, type);
+    if (!reflection) 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) {
+    const reflection = this.isWithReflection(sourceFile, node);
+    if (!reflection) {
+      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 !== SyntaxKind2.ExportKeyword && v.kind !== SyntaxKind2.DefaultKeyword && v.kind !== SyntaxKind2.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
+    ]);
+  }
+  /**
+   * 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;
+    }
+    return;
+  }
+};
+var DeclarationTransformer = class extends ReflectionTransformer {
+  static {
+    __name(this, "DeclarationTransformer");
+  }
+  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 = /* @__PURE__ */ __name((node) => {
+      node = visitEachChild(node, visitor, this.context);
+      if ((isTypeAliasDeclaration(node) || isInterfaceDeclaration(node) || isEnumDeclaration(node)) && hasModifier(node, SyntaxKind2.ExportKeyword)) {
+        const reflection2 = this.isWithReflection(sourceFile, node);
+        if (reflection2) {
+          this.addExports.push({
+            identifier: getIdentifierName(this.getDeclarationVariableName(node.name))
+          });
+        }
+      }
+      return node;
+    }, "visitor");
+    this.sourceFile = visitNode(this.sourceFile, visitor);
+    if (this.addExports.length) {
+      const exports$1 = [];
+      const handledIdentifier = [];
+      for (const imp of this.addExports) {
+        if (handledIdentifier.includes(imp.identifier)) continue;
+        handledIdentifier.push(imp.identifier);
+        exports$1.push(this.f.createTypeAliasDeclaration([
+          this.f.createModifier(SyntaxKind2.ExportKeyword),
+          this.f.createModifier(SyntaxKind2.DeclareKeyword)
+        ], this.f.createIdentifier(imp.identifier), void 0, this.f.createArrayTypeNode(this.f.createKeywordTypeNode(SyntaxKind2.AnyKeyword))));
+      }
+      this.sourceFile = this.f.updateSourceFile(this.sourceFile, [
+        ...this.sourceFile.statements,
+        ...exports$1
+      ]);
+    }
+    this.sourceFile.deepkitDeclarationTransformed = true;
+    return this.sourceFile;
+  }
+};
+var cache2 = new Cache();
+function createTransformer(context, options = {}) {
+  return /* @__PURE__ */ __name(function transformer2(ctx) {
+    cache2.tick();
+    return new ReflectionTransformer(ctx, cache2).withReflection(defu(options, {
+      reflection: context.tsconfig.tsconfigJson.compilerOptions?.reflection || context.tsconfig.tsconfigJson.reflection,
+      reflectionLevel: context.tsconfig.tsconfigJson.compilerOptions?.reflectionLevel || context.tsconfig.tsconfigJson.reflectionLevel
+    }, {
+      exclude: [],
+      reflection: "default",
+      reflectionLevel: "minimal"
+    }));
+  }, "transformer");
+}
+__name(createTransformer, "createTransformer");
+function createDeclarationTransformer(context, options = {}) {
+  return /* @__PURE__ */ __name(function declarationTransformer2(ctx) {
+    return new DeclarationTransformer(ctx, cache2).withReflection(defu(options, {
+      reflection: context.tsconfig.tsconfigJson.compilerOptions?.reflection || context.tsconfig.tsconfigJson.reflection,
+      reflectionLevel: context.tsconfig.tsconfigJson.compilerOptions?.reflectionLevel || context.tsconfig.tsconfigJson.reflectionLevel
+    }, {
+      exclude: [],
+      reflection: "default",
+      reflectionLevel: "minimal"
+    }));
+  }, "declarationTransformer");
+}
+__name(createDeclarationTransformer, "createDeclarationTransformer");
+
+export { createDeclarationTransformer, createTransformer };