@d1g1tal/tsbuild 1.9.1 → 1.9.2

package/dist/type-script-project.js

@@ -1,7 +1,3113 @@
 import {
-  TypeScriptProject
-} from "./7G6BAIKH.js";
-import "./XTZ3MYA7.js";
+  BuildError,
+  BundleError,
+  ConfigurationError,
+  TypeCheckError,
+  UnsupportedSyntaxError,
+  castError
+} from "./WE3VBWJ5.js";
+import {
+  BuildMessageType,
+  Encoding,
+  FileExtension,
+  Json,
+  Paths,
+  Platform,
+  buildInfoFile,
+  cacheDirectory,
+  compilerOptionOverrides,
+  dataUnits,
+  defaultCleanOptions,
+  defaultDirOptions,
+  defaultEntryFile,
+  defaultEntryPoint,
+  defaultOutDirectory,
+  defaultSourceDirectory,
+  dtsCacheFile,
+  dtsCacheVersion,
+  format,
+  newLine,
+  outputManifestFile,
+  processEnvExpansionPattern,
+  sourceScriptExtensionExpression,
+  toEsTarget,
+  toJsxRenderingMode,
+  typeMatcher
+} from "./237SIAOE.js";
+import {
+  __decorateElement,
+  __decoratorStart,
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet,
+  __runInitializers
+} from "./HQEQHKVJ.js";
+
+// src/files.ts
+import { dirname, join } from "node:path";
+import { serialize, deserialize } from "node:v8";
+import { brotliDecompress, brotliCompress } from "node:zlib";
+import { access, constants, mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
+var windowsDrivePathRegex = /^[A-Za-z]:[\\/]/;
+var Files = class {
+  constructor() {
+  }
+  /**
+   * Check if a file exists.
+   * @param filePath The path to the file.
+   */
+  static async exists(filePath) {
+    try {
+      await access(filePath, constants.F_OK);
+      return true;
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return false;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Clear a directory by removing all of its entries in parallel.
+   * Uses readdir + parallel rm so libuv's threadpool can unlink subtrees concurrently,
+   * which is significantly faster than a single recursive `rm` for large output trees.
+   * The directory itself is preserved (no mkdir needed afterward).
+   * @param directory The path to the directory to clear.
+   */
+  static async empty(directory) {
+    let entries;
+    try {
+      entries = await readdir(directory);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        await mkdir(directory, defaultDirOptions);
+        return;
+      }
+      throw error;
+    }
+    if (entries.length === 0) {
+      return;
+    }
+    const removals = new Array(entries.length);
+    for (let i = 0, length = entries.length; i < length; i++) {
+      removals[i] = rm(join(directory, entries[i]), defaultCleanOptions);
+    }
+    await Promise.all(removals);
+  }
+  /**
+   * Write data to a file.
+   * Ensures the directory exists before writing.
+   * @param filePath The path to the file.
+   * @param data The data to write to the file.
+   * @param options Optional write file options.
+   */
+  static async write(filePath, data, options = { encoding: Encoding.utf8 }) {
+    await mkdir(dirname(filePath), defaultDirOptions);
+    await writeFile(filePath, data, options);
+  }
+  /**
+   * Load a file and return its contents as a string.
+   * @param filePath The path to the file.
+   * @param encoding The encoding to use when reading the file. Default is UTF-8.
+   * @returns The file contents as a string.
+   */
+  static async read(filePath, encoding = Encoding.utf8) {
+    return await readFile(this.normalizePath(filePath), { encoding });
+  }
+  /**
+   * Reads the contents of a directory.
+   * @param directoryPath The path to the directory.
+   * @returns An array of file and directory names within the specified directory.
+   */
+  static async readDirectory(directoryPath) {
+    return await readdir(directoryPath);
+  }
+  /**
+   * Normalize a file path to an absolute path.
+   * @param path The file path to normalize.
+   * @returns The normalized absolute path.
+   * @throws {TypeError} if path is relative and not a valid URL
+   */
+  static normalizePath(path) {
+    if (path.startsWith("/") || path.startsWith("file://") || windowsDrivePathRegex.test(path)) {
+      return path;
+    }
+    if (!path.includes("://")) {
+      throw new TypeError(`Files.normalizePath requires an absolute path, got: ${path}`);
+    }
+    return new URL(path, import.meta.url).pathname;
+  }
+  /**
+   * Decompress a Brotli-compressed buffer.
+   * Uses callback-based API wrapped in a Promise for faster performance than streaming.
+   * @param buffer The compressed buffer to decompress.
+   * @returns The decompressed buffer.
+   */
+  static decompressBuffer(buffer) {
+    return new Promise((resolve3, reject) => brotliDecompress(buffer, (error, result) => error ? reject(error) : resolve3(result)));
+  }
+  /**
+   * Compress data using Brotli compression.
+   * Uses callback-based API wrapped in a Promise for faster performance than streaming.
+   * @param buffer The buffer to compress.
+   * @returns The compressed buffer.
+   */
+  static compressBuffer(buffer) {
+    return new Promise((resolve3, reject) => brotliCompress(buffer, (error, result) => error ? reject(error) : resolve3(result)));
+  }
+  /**
+   * Load a file and deserialize it using V8 deserialization.
+   * Faster than JSON.parse for complex objects.
+   * @param path The path to the file.
+   * @returns The deserialized object.
+   */
+  static async readCompressed(path) {
+    return deserialize(await this.decompressBuffer(await readFile(this.normalizePath(path))));
+  }
+  /**
+   * Serialize an object using V8 serialization and save to a Brotli-compressed file.
+   * Faster than JSON.stringify for complex objects.
+   * @param path The path to the file.
+   * @param data The object to serialize and save.
+   */
+  static async writeCompressed(path, data) {
+    const normalizedPath = this.normalizePath(path);
+    await mkdir(dirname(normalizedPath), defaultDirOptions);
+    await writeFile(normalizedPath, await this.compressBuffer(serialize(data)));
+  }
+};
+
+// src/text-formatter.ts
+import { isatty } from "node:tty";
+var { env = {}, platform = "" } = process;
+var isDumbTerminal = env["TERM"] === "dumb";
+var isCompatibleTerminal = isatty(1) && env["TERM"] && !isDumbTerminal;
+var isColorSupported = !("NO_COLOR" in env) && ("FORCE_COLOR" in env || platform === "win32" && !isDumbTerminal || isCompatibleTerminal);
+var replaceClose = (index, string, close, replace, head = string.substring(0, index) + replace, tail = string.substring(index + close.length), next = tail.indexOf(close)) => {
+  return head + (next < 0 ? tail : replaceClose(next, tail, close, replace));
+};
+var clearBleed = (index, string, open2, close, replace) => {
+  return index < 0 ? `${open2}${string}${close}` : `${open2}${replaceClose(index, string, close, replace)}${close}`;
+};
+var filterEmpty = (open2, close, replace = open2, at = open2.length + 1) => {
+  return (text) => text.length ? clearBleed(text.indexOf(close, at), text, open2, close, replace) : "";
+};
+var generateTextFormatter = (open2, close, replace) => filterEmpty(`\x1B[${open2}m`, `\x1B[${close}m`, replace);
+var TextFormat = class {
+  static enabled = isColorSupported;
+  static reset = generateTextFormatter(0, 0);
+  static bold = generateTextFormatter(1, 22, "\x1B[22m\x1B[1m");
+  static dim = generateTextFormatter(2, 22, "\x1B[22m\x1B[2m");
+  static italic = generateTextFormatter(3, 23);
+  static underline = generateTextFormatter(4, 24);
+  static inverse = generateTextFormatter(7, 27);
+  static hidden = generateTextFormatter(8, 28);
+  static strikethrough = generateTextFormatter(9, 29);
+  static black = generateTextFormatter(30, 39);
+  static red = generateTextFormatter(31, 39);
+  static green = generateTextFormatter(32, 39);
+  static yellow = generateTextFormatter(33, 39);
+  static blue = generateTextFormatter(34, 39);
+  static magenta = generateTextFormatter(35, 39);
+  static cyan = generateTextFormatter(36, 39);
+  static white = generateTextFormatter(37, 39);
+  static gray = generateTextFormatter(90, 39);
+  static bgBlack = generateTextFormatter(40, 49);
+  static bgRed = generateTextFormatter(41, 49);
+  static bgGreen = generateTextFormatter(42, 49);
+  static bgYellow = generateTextFormatter(43, 49);
+  static bgBlue = generateTextFormatter(44, 49);
+  static bgMagenta = generateTextFormatter(45, 49);
+  static bgCyan = generateTextFormatter(46, 49);
+  static bgWhite = generateTextFormatter(47, 49);
+  static blackBright = generateTextFormatter(90, 39);
+  static redBright = generateTextFormatter(91, 39);
+  static greenBright = generateTextFormatter(92, 39);
+  static yellowBright = generateTextFormatter(93, 39);
+  static blueBright = generateTextFormatter(94, 39);
+  static magentaBright = generateTextFormatter(95, 39);
+  static cyanBright = generateTextFormatter(96, 39);
+  static whiteBright = generateTextFormatter(97, 39);
+  static bgBlackBright = generateTextFormatter(100, 49);
+  static bgRedBright = generateTextFormatter(101, 49);
+  static bgGreenBright = generateTextFormatter(102, 49);
+  static bgYellowBright = generateTextFormatter(103, 49);
+  static bgBlueBright = generateTextFormatter(104, 49);
+  static bgMagentaBright = generateTextFormatter(105, 49);
+  static bgCyanBright = generateTextFormatter(106, 49);
+  static bgWhiteBright = generateTextFormatter(107, 49);
+};
+
+// src/logger.ts
+var LOG_1024 = Math.log(1024);
+var ansiEscapePattern = /\x1b\[[0-9;]*m/g;
+var isWrittenFiles = (data) => {
+  if (!Array.isArray(data)) {
+    return false;
+  }
+  return data.every((writtenFile) => {
+    return writtenFile !== null && typeof writtenFile === "object" && "path" in writtenFile && "size" in writtenFile;
+  });
+};
+var colorize = (type2, data, onlyImportant = false) => {
+  if (onlyImportant && (type2 === "info" || type2 === "success")) {
+    return data;
+  }
+  switch (type2) {
+    case "info":
+      return TextFormat.blue(data);
+    case "error":
+      return TextFormat.red(data);
+    case "warn":
+      return TextFormat.yellow(data);
+    default:
+      return TextFormat.green(data);
+  }
+};
+var prettyBytes = (bytes) => {
+  if (bytes === 0) {
+    return { value: "0", unit: "B" };
+  }
+  const exp = ~~(Math.log(bytes) / LOG_1024);
+  return { value: (bytes / Math.pow(1024, exp)).toFixed(2), unit: dataUnits[exp] };
+};
+var Logger = class _Logger {
+  constructor() {
+  }
+  static EntryType = {
+    Info: "info",
+    Success: "success",
+    Done: "done",
+    Error: "error",
+    Warn: "warn"
+  };
+  /** Clears the console */
+  static clear() {
+    console.log("\x1Bc");
+  }
+  /**
+   * Logs a header box with a message.
+   * The header is styled with a cyan border and the message is centered inside. ANSI escape codes are stripped from the message when calculating the width to ensure proper formatting.
+   * This ensures the header box is sized correctly even when the message contains color codes or other formatting.
+   * @param message The message to display in the header.
+   */
+  static header(message) {
+    const innerWidth = message.replace(ansiEscapePattern, "").length + 2;
+    console.log(TextFormat.cyan(`\u256D${"\u2500".repeat(innerWidth)}\u256E${newLine}\u2502 ${message} \u2502${newLine}\u2570${"\u2500".repeat(innerWidth)}\u256F`));
+  }
+  /**
+   * Logs a separator line.
+   * @param width Optional width of the separator (default: 40).
+   */
+  static separator(width = 40) {
+    console.log(TextFormat.dim("\u2500".repeat(width)));
+  }
+  /**
+   * Logs a success message with a check mark and optional indentation.
+   * @param message The message to log.
+   * @param indent Whether to indent the message (tree structure).
+   */
+  static step(message, indent = false) {
+    const prefix = indent ? "  \u2514\u2500" : "\u2713";
+    console.log(TextFormat.green(`${prefix} ${message}`));
+  }
+  /**
+   * Logs sub-step timing entries in a tree format below a parent step.
+   * @param steps The sub-steps to log.
+   */
+  static subSteps(steps) {
+    const visible = steps.filter(({ ms }) => ms >= 5);
+    if (visible.length === 0) {
+      return;
+    }
+    let maxNameLength = 0;
+    let maxDurationLength = 0;
+    for (let i = 0, length = visible.length; i < length; i++) {
+      const { name, duration } = visible[i];
+      if (name.length > maxNameLength) {
+        maxNameLength = name.length;
+      }
+      if (duration.length > maxDurationLength) {
+        maxDurationLength = duration.length;
+      }
+    }
+    for (let i = 0, length = visible.length; i < length; i++) {
+      const { name, duration } = visible[i];
+      const prefix = i === length - 1 ? "  \u2514\u2500" : "  \u251C\u2500";
+      console.log(`${TextFormat.dim(prefix)} ${TextFormat.bold(name.padEnd(maxNameLength))} ${TextFormat.cyan(duration.padStart(maxDurationLength))}`);
+    }
+  }
+  /**
+   * Logs a success message.
+   * @param message The message to log.
+   * @param args Additional data to log.
+   * @returns void
+   */
+  static success(message, ...args) {
+    return _Logger.log(message, "success", ...args);
+  }
+  /**
+   * Logs an info message.
+   * @param message The message to log.
+   * @param args Additional data to log.
+   * @returns void
+   */
+  static info(message, ...args) {
+    return _Logger.log(message, "info", ...args);
+  }
+  /**
+   * Logs an error message.
+   * @param message The message to log.
+   * @param args Additional data to log.
+   * @returns void
+   */
+  static error(message, ...args) {
+    return _Logger.log(message, "error", ...args);
+  }
+  /**
+   * Logs a warning message.
+   * @param message The message to log.
+   * @param args Additional data to log.
+   * @returns void
+   */
+  static warn(message, ...args) {
+    return _Logger.log(message, "warn", ...args);
+  }
+  /**
+   * Logs a done message.
+   * @param message The message to log.
+   * @param type The type of the log entry.
+   * @param data Additional data to log.
+   */
+  static log(message, type2, ...data) {
+    if (data.length) {
+      if (isWrittenFiles(data)) {
+        if (message) {
+          console.log(colorize(type2, message, true));
+        }
+        _Logger.#files(data);
+      } else {
+        console.log(colorize(type2, message, true), ...data);
+      }
+    } else {
+      console.log(colorize(type2, message, true));
+    }
+  }
+  /**
+   * Logs an array of WrittenFile objects in a formatted manner.
+   * @param files - The array of WrittenFile objects to log.
+   * @internal
+   */
+  static #files(files) {
+    let maxPathLength = 0;
+    let maxValueLength = 0;
+    let maxUnitLength = 0;
+    const formatted = [];
+    for (let i = 0, length = files.length; i < length; i++) {
+      const { path, size } = files[i];
+      const { value, unit } = prettyBytes(size);
+      if (path.length > maxPathLength) {
+        maxPathLength = path.length;
+      }
+      if (value.length > maxValueLength) {
+        maxValueLength = value.length;
+      }
+      if (unit.length > maxUnitLength) {
+        maxUnitLength = unit.length;
+      }
+      formatted.push({ path, value, unit });
+    }
+    for (let i = 0, length = formatted.length; i < length; i++) {
+      const { path, value, unit } = formatted[i];
+      const paddedPath = path.padEnd(maxPathLength);
+      const paddedValue = value.padStart(maxValueLength);
+      const paddedUnit = unit.padEnd(maxUnitLength);
+      const prefix = i === length - 1 ? "  \u2514\u2500" : "  \u251C\u2500";
+      console.log(`${TextFormat.dim(prefix)} ${TextFormat.bold(paddedPath)} ${TextFormat.cyan(paddedValue)} ${TextFormat.dim(paddedUnit)}`);
+    }
+  }
+};
+
+// src/type-script-project.ts
+import { rm as rm2 } from "node:fs/promises";
+
+// src/dts/declaration-bundler.ts
+import MagicString2 from "magic-string";
+import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
+import { basename, posix } from "node:path";
+
+// src/dts/declaration-processor.ts
+import {
+  canHaveModifiers,
+  forEachChild,
+  isClassDeclaration,
+  isEmptyStatement,
+  isEnumDeclaration,
+  isExportDeclaration,
+  isExportSpecifier,
+  isFunctionDeclaration,
+  isIdentifier,
+  isImportDeclaration,
+  isImportTypeNode,
+  isInterfaceDeclaration,
+  isLiteralTypeNode,
+  isModuleBlock,
+  isModuleDeclaration,
+  isNamedExports,
+  isNamespaceExport,
+  isStringLiteral,
+  isTypeAliasDeclaration,
+  isVariableStatement,
+  ModifierFlags,
+  NodeFlags,
+  SyntaxKind,
+  getCombinedModifierFlags
+} from "typescript";
+import MagicString from "magic-string";
+var commaCharacter = 44;
+var DeclarationProcessor = class _DeclarationProcessor {
+  constructor() {
+  }
+  /**
+   * Pre-processes a declaration file before bundling.
+   *
+   * The pre-process step has the following goals:
+   * - Fixes the "modifiers", removing any `export` modifier and adding any missing `declare` modifier
+   * - Splits compound `VariableStatement` into its parts
+   * - Moves declarations for the same "name" to be next to each other
+   * - Removes any triple-slash directives and records them
+   * - Creates a synthetic name for any nameless "export default"
+   * - Resolves inline `import()` statements and generates top-level imports for them
+   * - Generates a separate `export {}` statement for any item which had its modifiers rewritten
+   * - Duplicates the identifiers of a namespace `export`, so that renaming does not break it
+   *
+   * @param sourceFile The source file to process
+   * @returns The pre-processed output, which includes the modified code, type references, and file references
+   */
+  static preProcess(sourceFile) {
+    const code = new MagicString(sourceFile.getFullText());
+    const declaredNames = /* @__PURE__ */ new Set();
+    const exportedNames = /* @__PURE__ */ new Set();
+    let defaultExport = "";
+    const inlineImports = /* @__PURE__ */ new Map();
+    const nameRanges = /* @__PURE__ */ new Map();
+    function newlineAt(node, pos) {
+      return node.getSourceFile().getFullText()[pos] === newLine;
+    }
+    function getStart(node) {
+      const start = node.getFullStart();
+      return start + (newlineAt(node, start) ? 1 : 0);
+    }
+    function getEnd(node) {
+      const end = node.getEnd();
+      return end + (newlineAt(node, end) ? 1 : 0);
+    }
+    function parseReferenceDirectives(fileReferences2) {
+      const referenceDirectives = /* @__PURE__ */ new Set();
+      const lineStarts = sourceFile.getLineStarts();
+      for (const { fileName, pos } of fileReferences2) {
+        referenceDirectives.add(fileName);
+        let end = sourceFile.getLineEndOfPosition(pos);
+        if (code.slice(end, end + 1) === newLine) {
+          end += 1;
+        }
+        code.remove(lineStarts[sourceFile.getLineAndCharacterOfPosition(pos).line], end);
+      }
+      return referenceDirectives;
+    }
+    function createNameRange(node) {
+      return [getStart(node), getEnd(node)];
+    }
+    function checkInlineImport(node) {
+      forEachChild(node, checkInlineImport);
+      if (isImportTypeNode(node)) {
+        if (!isLiteralTypeNode(node.argument) || !isStringLiteral(node.argument.literal)) {
+          throw new UnsupportedSyntaxError(node, "inline imports should have a literal argument");
+        }
+        const children = node.getChildren();
+        const token = children.find(({ kind }) => kind === SyntaxKind.DotToken || kind === SyntaxKind.LessThanToken);
+        code.overwrite(children.find(({ kind }) => kind === SyntaxKind.ImportKeyword).getStart(), token === void 0 ? node.getEnd() : token.getStart(), createNamespaceImport(node.argument.literal.text));
+      }
+    }
+    function createNamespaceImport(fileId) {
+      let importName = inlineImports.get(fileId);
+      if (importName === void 0) {
+        const chars = [];
+        for (let i = 0; i < fileId.length; i++) {
+          const char = fileId[i];
+          const code2 = char.charCodeAt(0);
+          chars.push(code2 >= 97 && code2 <= 122 || code2 >= 65 && code2 <= 90 || code2 >= 48 && code2 <= 57 || code2 === 95 || code2 === 36 ? char : "_");
+        }
+        importName = generateUniqueName(chars.join(""));
+        inlineImports.set(fileId, importName);
+      }
+      return importName;
+    }
+    function generateUniqueName(hint) {
+      while (declaredNames.has(hint)) {
+        hint = `_${hint}`;
+      }
+      declaredNames.add(hint);
+      return hint;
+    }
+    function pushNamedNode(name, range) {
+      const nodes = nameRanges.get(name);
+      if (nodes === void 0) {
+        nameRanges.set(name, [range]);
+      } else {
+        const last = nodes[nodes.length - 1];
+        if (last[1] === range[0]) {
+          last[1] = range[1];
+        } else {
+          nodes.push(range);
+        }
+      }
+    }
+    function fixModifiers(node) {
+      if (!canHaveModifiers(node)) {
+        return;
+      }
+      let hasDeclare = false;
+      for (const modifier of node.modifiers ?? []) {
+        if (modifier.kind === SyntaxKind.DefaultKeyword || modifier.kind === SyntaxKind.ExportKeyword) {
+          code.remove(modifier.getStart(), modifier.getEnd() + getTrailingWhitespaceLength(modifier.getEnd(), node.getEnd()));
+        } else if (modifier.kind === SyntaxKind.DeclareKeyword) {
+          hasDeclare = true;
+        }
+      }
+      const needsDeclare = isEnumDeclaration(node) || isClassDeclaration(node) || isFunctionDeclaration(node) || isModuleDeclaration(node) || isVariableStatement(node);
+      if (needsDeclare && !hasDeclare) {
+        code.appendRight(node.getStart(), "declare ");
+      }
+    }
+    function duplicateExports(module) {
+      if (!module.body || !isModuleBlock(module.body)) {
+        return;
+      }
+      for (const node of module.body.statements) {
+        if (isExportDeclaration(node) && node.exportClause && !isNamespaceExport(node.exportClause)) {
+          for (const { name, propertyName } of node.exportClause.elements) {
+            if (propertyName === void 0) {
+              code.appendLeft(name.getEnd(), ` as ${name.getText()}`);
+            }
+          }
+        }
+      }
+    }
+    function getTrailingWhitespaceLength(start, end) {
+      let length = 0;
+      while (start + length < end) {
+        const char = code.original[start + length];
+        if (char === " " || char === "	" || char === newLine || char === "\r") {
+          length++;
+        } else {
+          break;
+        }
+      }
+      return length;
+    }
+    for (const node of sourceFile.statements) {
+      if (isExportDeclaration(node)) {
+        if (node.exportClause && isNamedExports(node.exportClause) && node.exportClause.elements.length === 0 && !node.moduleSpecifier) {
+          code.remove(getStart(node), getEnd(node));
+        } else if (node.isTypeOnly) {
+          const exportKeywordEnd = node.getStart() + "export".length;
+          const nextTokenStart = node.exportClause?.getStart() ?? node.moduleSpecifier?.getStart() ?? node.getEnd();
+          const typeMatch = code.slice(exportKeywordEnd, nextTokenStart).match(typeMatcher);
+          if (typeMatch?.index !== void 0) {
+            const typeKeywordStart = exportKeywordEnd + typeMatch.index;
+            const typeKeywordEnd = typeKeywordStart + "type".length;
+            const afterType = code.slice(typeKeywordEnd, nextTokenStart);
+            code.remove(typeKeywordStart, typeKeywordEnd + afterType.length - afterType.trimStart().length);
+          }
+        }
+      } else if (isEnumDeclaration(node) || isFunctionDeclaration(node) || isInterfaceDeclaration(node) || isClassDeclaration(node) || isTypeAliasDeclaration(node) || isModuleDeclaration(node)) {
+        if (node.name) {
+          const name = node.name.getText();
+          declaredNames.add(name);
+          if (_DeclarationProcessor.#matchesModifier(node, ModifierFlags.ExportDefault)) {
+            defaultExport = name;
+          } else if (_DeclarationProcessor.#matchesModifier(node, ModifierFlags.Export)) {
+            exportedNames.add(name);
+          }
+          if (!(node.flags & NodeFlags.GlobalAugmentation)) {
+            pushNamedNode(name, createNameRange(node));
+          }
+        }
+        if (isModuleDeclaration(node)) {
+          duplicateExports(node);
+        }
+        fixModifiers(node);
+      } else if (isVariableStatement(node)) {
+        for (const { name } of node.declarationList.declarations) {
+          if (isIdentifier(name)) {
+            const nameText = name.getText();
+            declaredNames.add(nameText);
+            if (node.modifiers?.some((modifier) => modifier.kind === SyntaxKind.DefaultKeyword)) {
+              defaultExport = nameText;
+            } else if (node.modifiers?.some((modifier) => modifier.kind === SyntaxKind.ExportKeyword)) {
+              exportedNames.add(nameText);
+            }
+          }
+        }
+        fixModifiers(node);
+        const { declarations } = node.declarationList;
+        if (declarations.length === 1) {
+          const [{ name }] = declarations;
+          if (isIdentifier(name)) {
+            pushNamedNode(name.getText(), createNameRange(node));
+          }
+        } else {
+          const decls = declarations.slice();
+          const first = decls.shift();
+          pushNamedNode(first.name.getText(), [getStart(node), first.getEnd()]);
+          for (const declaration of decls) {
+            if (isIdentifier(declaration.name)) {
+              pushNamedNode(declaration.name.getText(), [declaration.getFullStart(), declaration.getEnd()]);
+            }
+          }
+        }
+        const { flags } = node.declarationList;
+        const prefix = `declare ${flags & NodeFlags.Let ? "let" : flags & NodeFlags.Const ? "const" : "var"} `;
+        const sourceText = sourceFile.text;
+        for (let i = 1; i < declarations.length; i++) {
+          const prev = declarations[i - 1];
+          const curr = declarations[i];
+          let commaPos = -1;
+          const limit = curr.getStart();
+          for (let p = prev.end; p < limit; p++) {
+            if (sourceText.charCodeAt(p) === commaCharacter) {
+              commaPos = p;
+              break;
+            }
+          }
+          if (commaPos === -1) {
+            continue;
+          }
+          code.remove(commaPos, commaPos + 1);
+          code.appendLeft(commaPos, `;${newLine}`);
+          const start = curr.getFullStart();
+          const slice = sourceText.substring(start, curr.getStart());
+          const whitespace = slice.length - slice.trimStart().length;
+          if (whitespace) {
+            code.overwrite(start, start + whitespace, prefix);
+          } else {
+            code.appendLeft(start, prefix);
+          }
+        }
+      }
+    }
+    for (const node of sourceFile.statements) {
+      checkInlineImport(node);
+      if ((isFunctionDeclaration(node) || isClassDeclaration(node)) && !node.name) {
+        if (defaultExport === "") {
+          defaultExport = generateUniqueName("export_default");
+        }
+        const children = node.getChildren();
+        const index = children.findIndex((node2) => node2.kind === SyntaxKind.ClassKeyword || node2.kind === SyntaxKind.FunctionKeyword);
+        const token = children[index];
+        const nextToken = children[index + 1];
+        if (SyntaxKind.FirstPunctuation <= nextToken.kind && nextToken.kind <= SyntaxKind.LastPunctuation) {
+          code.appendLeft(nextToken.getStart(), `${code.slice(token.getEnd(), nextToken.getStart()) !== " " ? " " : ""}${defaultExport}`);
+        } else {
+          code.appendRight(token.getEnd(), ` ${defaultExport}`);
+        }
+      }
+    }
+    for (const nameRange of nameRanges.values()) {
+      const [start] = nameRange.pop();
+      for (const [rangeStart, rangeEnd] of nameRange) {
+        code.move(rangeStart, rangeEnd, start);
+      }
+    }
+    if (defaultExport !== "") {
+      code.append(`${newLine}export default ${defaultExport};${newLine}`);
+    }
+    if (exportedNames.size) {
+      code.append(`${newLine}export { ${[...exportedNames].join(", ")} };${newLine}`);
+    }
+    for (const [fileId, importName] of inlineImports.entries()) {
+      code.prepend(`import * as ${importName} from "${fileId}";${newLine}`);
+    }
+    const typeReferences = parseReferenceDirectives(sourceFile.typeReferenceDirectives);
+    const fileReferences = parseReferenceDirectives(sourceFile.referencedFiles);
+    return { code: code.toString(), typeReferences, fileReferences };
+  }
+  /**
+   * Check if a TypeScript declaration has specific modifier flags
+   * @param node - The TypeScript declaration node
+   * @param flags - The modifier flags to check for
+   * @returns True if the node has all the specified flags
+   */
+  static #matchesModifier = (node, flags) => (getCombinedModifierFlags(node) & flags) === flags;
+  /**
+   * Post-processes a bundled declaration file to clean up bundling artifacts.
+   *
+   * @param sourceFile The source file to process
+   * @returns The processed source code
+   */
+  static postProcess(sourceFile) {
+    const magic = new MagicString(sourceFile.getFullText());
+    function visitNode(node) {
+      if (isEmptyStatement(node)) {
+        magic.remove(node.getStart(), node.getEnd());
+        return;
+      }
+      if ((isImportDeclaration(node) || isExportDeclaration(node)) && node.moduleSpecifier && isStringLiteral(node.moduleSpecifier)) {
+        const { text } = node.moduleSpecifier;
+        if (text.startsWith(".") && text.endsWith(FileExtension.DTS)) {
+          const replacement = text.endsWith(".d.tsx") ? text.slice(0, -6) + FileExtension.JS : text.slice(0, -5) + FileExtension.JS;
+          magic.overwrite(node.moduleSpecifier.getStart() + 1, node.moduleSpecifier.getEnd() - 1, replacement);
+        }
+      }
+      if (isExportSpecifier(node) && node.propertyName && isIdentifier(node.propertyName) && isIdentifier(node.name) && node.propertyName.text === node.name.text) {
+        magic.remove(node.propertyName.getStart(), node.name.getStart());
+      }
+      forEachChild(node, visitNode);
+    }
+    visitNode(sourceFile);
+    return magic.toString();
+  }
+};
+
+// src/dts/declaration-bundler.ts
+import {
+  sys,
+  createSourceFile,
+  ScriptTarget,
+  isImportDeclaration as isImportDeclaration2,
+  isExportDeclaration as isExportDeclaration2,
+  isInterfaceDeclaration as isInterfaceDeclaration2,
+  isTypeAliasDeclaration as isTypeAliasDeclaration2,
+  isEnumDeclaration as isEnumDeclaration2,
+  isFunctionDeclaration as isFunctionDeclaration2,
+  isClassDeclaration as isClassDeclaration2,
+  isVariableStatement as isVariableStatement2,
+  isModuleDeclaration as isModuleDeclaration2,
+  isModuleBlock as isModuleBlock2,
+  isNamedExports as isNamedExports2,
+  isNamedImports,
+  isIdentifier as isIdentifier2,
+  isNamespaceImport,
+  isQualifiedName,
+  resolveModuleName,
+  isExportAssignment,
+  forEachChild as forEachChild2
+} from "typescript";
+var nodeModules = "/node_modules/";
+var emptySet = /* @__PURE__ */ new Set();
+function mergeImports(imports) {
+  const merged = /* @__PURE__ */ new Map();
+  const raw = /* @__PURE__ */ new Set();
+  for (const imp of imports) {
+    if (imp.kind === "raw") {
+      raw.add(imp.text);
+      continue;
+    }
+    const key = `${imp.isType ? "type:" : ""}${imp.specifier}`;
+    let entry = merged.get(key);
+    if (entry === void 0) {
+      entry = { specifier: imp.specifier, isType: imp.isType, names: /* @__PURE__ */ new Set() };
+      merged.set(key, entry);
+    }
+    for (const name of imp.names) {
+      entry.names.add(name);
+    }
+  }
+  const result = [];
+  for (const { specifier, isType, names } of merged.values()) {
+    const sorted = Array.from(names).sort();
+    result.push(`${isType ? "import type" : "import"} { ${sorted.join(", ")} } from "${specifier}";`);
+  }
+  for (const text of raw) {
+    result.push(text);
+  }
+  return result;
+}
+var DeclarationBundler = class _DeclarationBundler {
+  /** Project declaration files from in-memory FileManager */
+  #declarationFiles = /* @__PURE__ */ new Map();
+  /** External declaration files resolved from disk (node_modules) when resolve is enabled */
+  #externalDeclarationFiles = /* @__PURE__ */ new Map();
+  /** d.ts Bundle Options */
+  #options;
+  /** WeakMap cache for identifier collection to avoid re-parsing same source files */
+  #identifierCache = /* @__PURE__ */ new WeakMap();
+  /** SourceFile cache keyed by path — survives across multiple bundle() calls (entry points) */
+  #sourceFileCache = /* @__PURE__ */ new Map();
+  /** Module resolution cache for this bundler instance */
+  #moduleResolutionCache = /* @__PURE__ */ new Map();
+  /** Pre-computed set of directory prefixes from declaration file paths for O(1) directoryExists lookups */
+  #declarationDirs = /* @__PURE__ */ new Set();
+  /** Pre-built matcher for external patterns — O(1) string lookups + cached regex tests */
+  #matchExternal;
+  /** Pre-built matcher for noExternal patterns — O(1) string lookups + cached regex tests */
+  #matchNoExternal;
+  // Create a proper module resolution host that supports both in-memory files and disk files
+  #moduleResolutionHost = {
+    fileExists: (fileName) => {
+      return this.#declarationFiles.has(fileName) || this.#externalDeclarationFiles.has(fileName) || this.#options.resolve && sys.fileExists(fileName);
+    },
+    readFile: (fileName) => {
+      const cached = this.#declarationFiles.get(fileName) ?? this.#externalDeclarationFiles.get(fileName);
+      if (cached) {
+        return cached.code;
+      }
+      if (!this.#options.resolve) {
+        return void 0;
+      }
+      const rawContent = sys.readFile(fileName, Encoding.utf8);
+      if (rawContent !== void 0) {
+        const preProcessOutput = DeclarationProcessor.preProcess(createSourceFile(fileName, rawContent, ScriptTarget.Latest, true));
+        this.#externalDeclarationFiles.set(fileName, preProcessOutput);
+        return preProcessOutput.code;
+      }
+      return void 0;
+    },
+    directoryExists: (dirName) => {
+      const normalizedDir = dirName.endsWith("/") ? dirName.slice(0, -1) : dirName;
+      return this.#declarationDirs.has(normalizedDir) || (this.#options.resolve ? sys.directoryExists(dirName) : false);
+    },
+    getCurrentDirectory: () => this.#options.currentDirectory,
+    /* v8 ignore next */
+    getDirectories: () => []
+  };
+  /**
+   * Creates a new DTS bundler instance
+   * @param dtsBundleOptions - Options for the DTS bundler
+   */
+  constructor(dtsBundleOptions) {
+    for (const [filePath, cachedDecl] of dtsBundleOptions.declarationFiles) {
+      this.#declarationFiles.set(sys.resolvePath(filePath), cachedDecl);
+    }
+    for (const filePath of this.#declarationFiles.keys()) {
+      let dir = filePath.lastIndexOf("/") !== -1 ? filePath.slice(0, filePath.lastIndexOf("/")) : "";
+      while (dir.length > 0) {
+        if (this.#declarationDirs.has(dir)) {
+          break;
+        }
+        this.#declarationDirs.add(dir);
+        const nextSlash = dir.lastIndexOf("/");
+        dir = nextSlash !== -1 ? dir.slice(0, nextSlash) : "";
+      }
+    }
+    this.#options = dtsBundleOptions;
+    this.#matchExternal = _DeclarationBundler.#buildMatcher(dtsBundleOptions.external);
+    this.#matchNoExternal = _DeclarationBundler.#buildMatcher(dtsBundleOptions.noExternal);
+  }
+  /**
+   * Clears external declaration files and module resolution cache to free memory.
+   * Called after all entry points have been bundled.
+   */
+  clearExternalFiles() {
+    this.#externalDeclarationFiles.clear();
+    this.#moduleResolutionCache.clear();
+    this.#sourceFileCache.clear();
+  }
+  /**
+   * Convert a source file path to its corresponding declaration file path
+   * @param sourcePath - Absolute path to a source file (.ts, .tsx)
+   * @returns The corresponding .d.ts path, or undefined if not found
+   */
+  #sourceToDeclarationPath(sourcePath) {
+    const { outDir, rootDir } = this.#options.compilerOptions;
+    const sourceWithoutExt = sourcePath.substring(0, sourcePath.lastIndexOf(".") || sourcePath.length);
+    if (rootDir) {
+      const dtsPath = posix.normalize(Paths.join(outDir, Paths.relative(rootDir, sourceWithoutExt) + FileExtension.DTS));
+      return this.#declarationFiles.has(dtsPath) ? dtsPath : sourcePath;
+    }
+    let bestMatch;
+    let bestRelativeLength = Infinity;
+    for (const dtsPath of this.#declarationFiles.keys()) {
+      if (!dtsPath.endsWith(FileExtension.DTS)) {
+        continue;
+      }
+      const withoutOutDir = dtsPath.startsWith(outDir + "/") ? dtsPath.slice(outDir.length + 1) : dtsPath;
+      const relativeDtsPath = withoutOutDir.slice(0, -FileExtension.DTS.length);
+      if ((sourceWithoutExt === relativeDtsPath || sourceWithoutExt.endsWith("/" + relativeDtsPath)) && relativeDtsPath.length < bestRelativeLength) {
+        bestRelativeLength = relativeDtsPath.length;
+        bestMatch = dtsPath;
+      }
+    }
+    return bestMatch ?? sourcePath;
+  }
+  /**
+   * Builds an O(1) matcher from a mixed Pattern array by splitting into a Set<string> for
+   * exact/sub-path checks and a RegExp[] for regex tests. Called once per bundler instance.
+   * @param patterns - The array of string and RegExp patterns to match against module specifiers
+   * @returns A function that takes a module specifier and returns true if it matches any of the patterns
+   */
+  static #buildMatcher(patterns) {
+    const exact = /* @__PURE__ */ new Set();
+    const prefixes = [];
+    const regexps = [];
+    for (const p of patterns) {
+      if (typeof p === "string") {
+        exact.add(p);
+        prefixes.push(p + "/");
+      } else {
+        regexps.push(p);
+      }
+    }
+    if (exact.size === 0 && regexps.length === 0) {
+      return () => false;
+    }
+    return (id) => {
+      if (exact.has(id)) {
+        return true;
+      }
+      for (let i = 0; i < prefixes.length; i++) {
+        if (id.startsWith(prefixes[i])) {
+          return true;
+        }
+      }
+      for (let i = 0; i < regexps.length; i++) {
+        if (regexps[i].test(id)) {
+          return true;
+        }
+      }
+      return false;
+    };
+  }
+  /**
+   * Resolve a module import using TypeScript's resolution algorithm with path mapping support
+   * For bundles with resolve enabled, also loads declaration files from node_modules
+   * @param importPath - The module specifier to resolve
+   * @param containingFile - The file containing the import
+   * @returns Resolved file path or undefined
+   */
+  #resolveModule(importPath, containingFile) {
+    const cacheKey = `${importPath}|${containingFile}`;
+    if (this.#moduleResolutionCache.has(cacheKey)) {
+      return this.#moduleResolutionCache.get(cacheKey);
+    }
+    const { resolvedModule } = resolveModuleName(importPath, containingFile, this.#options.compilerOptions, this.#moduleResolutionHost);
+    if (resolvedModule === void 0) {
+      return;
+    }
+    let resolvedFileName = resolvedModule.resolvedFileName;
+    if (this.#options.compilerOptions.paths && resolvedFileName.match(sourceScriptExtensionExpression)) {
+      resolvedFileName = this.#sourceToDeclarationPath(resolvedFileName);
+    }
+    this.#moduleResolutionCache.set(cacheKey, resolvedFileName);
+    return resolvedFileName;
+  }
+  /**
+   * Build a dependency graph of all modules starting from entry point
+   * @param entryPoint - The entry point file path
+   * @returns Map of file paths to module information with bundled specifiers tracked
+   */
+  #buildModuleGraph(entryPoint) {
+    const modules = /* @__PURE__ */ new Map();
+    const visited = /* @__PURE__ */ new Set();
+    const bundledSpecifiers = /* @__PURE__ */ new Map();
+    const visit = (path) => {
+      path = sys.resolvePath(path);
+      if (visited.has(path)) {
+        return;
+      }
+      visited.add(path);
+      const cached = this.#declarationFiles.get(path) ?? this.#externalDeclarationFiles.get(path);
+      if (cached === void 0) {
+        return;
+      }
+      const { code, typeReferences, fileReferences } = cached;
+      let sourceFile = this.#sourceFileCache.get(path);
+      if (sourceFile === void 0) {
+        sourceFile = createSourceFile(path, code, ScriptTarget.Latest, true);
+        this.#sourceFileCache.set(path, sourceFile);
+      }
+      const identifiers = this.#collectIdentifiers(sourceFile.statements, sourceFile);
+      const module = { path, code, imports: /* @__PURE__ */ new Set(), typeReferences: new Set(typeReferences), fileReferences: new Set(fileReferences), sourceFile, identifiers };
+      const bundledSpecs = /* @__PURE__ */ new Set();
+      for (const statement of sourceFile.statements) {
+        if ((isImportDeclaration2(statement) || isExportDeclaration2(statement)) && statement.moduleSpecifier) {
+          const specifier = statement.moduleSpecifier.text;
+          if (this.#matchExternal(specifier)) {
+            continue;
+          }
+          const resolvedPath = this.#resolveModule(specifier, path);
+          if (resolvedPath?.includes(nodeModules) && !this.#matchNoExternal(specifier)) {
+            continue;
+          }
+          if (resolvedPath && (this.#declarationFiles.has(resolvedPath) || this.#externalDeclarationFiles.has(resolvedPath))) {
+            module.imports.add(resolvedPath);
+            bundledSpecs.add(specifier);
+            visit(resolvedPath);
+          }
+        }
+      }
+      modules.set(path, module);
+      bundledSpecifiers.set(path, bundledSpecs);
+    };
+    visit(entryPoint);
+    return { modules, bundledSpecifiers };
+  }
+  /**
+   * Topological sort of modules to ensure dependencies come before dependents
+   * @param modules - Map of all modules
+   * @param entryPoint - Starting point for sorting
+   * @returns Array of modules in dependency order
+   */
+  #sortModules(modules, entryPoint) {
+    const sorted = [];
+    const visited = /* @__PURE__ */ new Set();
+    const visiting = /* @__PURE__ */ new Set();
+    const visitStack = [];
+    const visit = (path) => {
+      if (visited.has(path)) {
+        return;
+      }
+      if (visiting.has(path)) {
+        const cyclePath = [...visitStack.slice(visitStack.indexOf(path)), path].map((p) => Paths.relative(this.#options.currentDirectory, p)).join(" -> ");
+        Logger.warn(`Circular dependency detected: ${cyclePath}`);
+        visited.add(path);
+        return;
+      }
+      visiting.add(path);
+      visitStack.push(path);
+      const module = modules.get(path);
+      if (!module) {
+        visiting.delete(path);
+        visitStack.pop();
+        return;
+      }
+      for (const importPath of module.imports) {
+        visit(importPath);
+      }
+      visiting.delete(path);
+      visitStack.pop();
+      visited.add(path);
+      sorted.push(module);
+    };
+    visit(entryPoint);
+    return sorted;
+  }
+  /**
+   * Recursively collect type and value identifiers from AST statements
+   * This is more robust and performant than regex matching
+   * @param statements - AST statements to analyze
+   * @param sourceFile - Optional source file for caching results
+   * @returns Sets of type and value identifiers
+   */
+  #collectIdentifiers(statements, sourceFile) {
+    let result;
+    if (sourceFile) {
+      result = this.#identifierCache.get(sourceFile);
+      if (result) {
+        return result;
+      }
+    }
+    const types = /* @__PURE__ */ new Set();
+    const values = /* @__PURE__ */ new Set();
+    const collectNestedIdentifiers = (subStatements) => {
+      const { types: subTypes, values: subValues } = this.#collectIdentifiers(subStatements);
+      for (const type2 of subTypes) {
+        types.add(type2);
+      }
+      for (const value of subValues) {
+        values.add(value);
+      }
+    };
+    for (const statement of statements) {
+      if (isImportDeclaration2(statement)) {
+        continue;
+      }
+      if (isInterfaceDeclaration2(statement) || isTypeAliasDeclaration2(statement)) {
+        types.add(statement.name.text);
+      } else if (isEnumDeclaration2(statement) || isFunctionDeclaration2(statement) || isClassDeclaration2(statement)) {
+        if (statement.name) {
+          values.add(statement.name.text);
+        }
+      } else if (isVariableStatement2(statement)) {
+        for (const { name } of statement.declarationList.declarations) {
+          if (isIdentifier2(name)) {
+            values.add(name.text);
+          }
+        }
+      } else if (isModuleDeclaration2(statement)) {
+        if (statement.name && isIdentifier2(statement.name)) {
+          values.add(statement.name.text);
+        }
+        const body = statement.body;
+        if (body && isModuleBlock2(body)) {
+          collectNestedIdentifiers(body.statements);
+        } else if (body && isModuleDeclaration2(body)) {
+          collectNestedIdentifiers([body]);
+        }
+      }
+    }
+    result = { types, values };
+    if (sourceFile) {
+      this.#identifierCache.set(sourceFile, result);
+    }
+    return result;
+  }
+  /**
+   * Remove import/export statements from code, but preserve external imports
+   * Fully AST-based approach using magic-string for efficient code manipulation
+   * @param code - Declaration file content
+   * @param sourceFile - Parsed source file AST (required to avoid re-parsing)
+   * @param identifiers - Pre-computed type and value identifiers (to avoid re-computation)
+   * @param bundledImportPaths - Set of resolved file paths that were bundled (to exclude from external imports)
+   * @param renameMap - Map of renamed identifiers (name:path -> newName)
+   * @param modulePath - Path of current module for looking up renames
+   * @returns Object with processed code, collected external imports, and exported names (separated by type/value)
+   */
+  #stripImportsExports(code, sourceFile, identifiers, bundledImportPaths, renameMap, modulePath) {
+    const externalImports = [];
+    const typeExports = [];
+    const valueExports = [];
+    const { types: typeIdentifiers, values: valueIdentifiers } = identifiers;
+    const magic = new MagicString2(code);
+    const moduleRenames = /* @__PURE__ */ new Map();
+    const exportsMapper = (name) => moduleRenames.get(name) ?? name;
+    for (const name of typeIdentifiers) {
+      const renamed = renameMap.get(`${name}:${modulePath}`);
+      if (renamed) {
+        moduleRenames.set(name, renamed);
+      }
+    }
+    for (const name of valueIdentifiers) {
+      const renamed = renameMap.get(`${name}:${modulePath}`);
+      if (renamed) {
+        moduleRenames.set(name, renamed);
+      }
+    }
+    const bundledNamespaceAliases = /* @__PURE__ */ new Set();
+    for (const statement of sourceFile.statements) {
+      if (isImportDeclaration2(statement)) {
+        const moduleSpecifier = statement.moduleSpecifier.text;
+        if (this.#matchExternal(moduleSpecifier) || !bundledImportPaths.has(moduleSpecifier)) {
+          const importClause = statement.importClause;
+          const isTypeOnly = importClause?.isTypeOnly === true;
+          const namedBindings = importClause?.namedBindings;
+          if (importClause && !importClause.name && namedBindings && isNamedImports(namedBindings)) {
+            const names = [];
+            for (const element of namedBindings.elements) {
+              const local = element.name.text;
+              const original = element.propertyName?.text;
+              const prefix = element.isTypeOnly ? "type " : "";
+              names.push(original ? `${prefix}${original} as ${local}` : `${prefix}${local}`);
+            }
+            externalImports.push({ kind: "named", specifier: moduleSpecifier, isType: isTypeOnly, names });
+          } else {
+            externalImports.push({ kind: "raw", text: code.substring(statement.pos, statement.end).trim() });
+          }
+        } else if (statement.importClause?.namedBindings && isNamespaceImport(statement.importClause.namedBindings)) {
+          bundledNamespaceAliases.add(statement.importClause.namedBindings.name.text);
+        }
+        magic.remove(statement.pos, statement.end);
+      } else if (isExportDeclaration2(statement)) {
+        if (statement.moduleSpecifier) {
+          magic.remove(statement.pos, statement.end);
+          continue;
+        }
+        if (statement.exportClause && isNamedExports2(statement.exportClause)) {
+          if (statement.exportClause.elements.length > 0) {
+            for (const { name, propertyName } of statement.exportClause.elements) {
+              const localName = propertyName?.text ?? name.text;
+              if (valueIdentifiers.has(localName)) {
+                valueExports.push(localName);
+              } else if (typeIdentifiers.has(localName)) {
+                typeExports.push(localName);
+              } else {
+                valueExports.push(localName);
+              }
+            }
+            magic.remove(statement.pos, statement.end);
+          }
+        }
+      } else if (isExportAssignment(statement)) {
+        magic.remove(statement.pos, statement.end);
+      }
+    }
+    const hasRenames = moduleRenames.size > 0;
+    const hasBundledAliases = bundledNamespaceAliases.size > 0;
+    if (hasRenames || hasBundledAliases) {
+      const visit = (node) => {
+        if (hasBundledAliases && isQualifiedName(node) && isIdentifier2(node.left) && bundledNamespaceAliases.has(node.left.text)) {
+          magic.remove(node.left.getStart(), node.right.getStart());
+        } else if (hasRenames && isIdentifier2(node)) {
+          const renamed = moduleRenames.get(node.text);
+          if (renamed) {
+            magic.overwrite(node.getStart(), node.end, renamed);
+          }
+        }
+        forEachChild2(node, visit);
+      };
+      for (const statement of sourceFile.statements) {
+        if (!isImportDeclaration2(statement) && !isExportDeclaration2(statement) && !isExportAssignment(statement)) {
+          visit(statement);
+        }
+      }
+    }
+    const finalValueExportsSet = /* @__PURE__ */ new Set();
+    for (const name of valueExports) {
+      finalValueExportsSet.add(exportsMapper(name));
+    }
+    const finalTypeExports = [];
+    for (const type2 of typeExports) {
+      const mapped = exportsMapper(type2);
+      if (!finalValueExportsSet.has(mapped)) {
+        finalTypeExports.push(mapped);
+      }
+    }
+    return { code: magic.toString(), externalImports, typeExports: finalTypeExports, valueExports: Array.from(finalValueExportsSet) };
+  }
+  /**
+   * Combine modules into a single output string
+   * @param sortedModules - Modules in dependency order
+   * @param bundledSpecifiers - Map of module paths to their bundled import specifiers
+   * @returns Object containing combined code, all exported identifiers, and all declarations from bundled modules
+   */
+  #combineModules(sortedModules, bundledSpecifiers) {
+    const typeReferencesSet = /* @__PURE__ */ new Set();
+    const fileReferencesSet = /* @__PURE__ */ new Set();
+    const allExternalImports = [];
+    const valueExportsSet = /* @__PURE__ */ new Set();
+    const typeExportsSeen = /* @__PURE__ */ new Set();
+    const orderedTypeExports = [];
+    const codeBlocks = [];
+    const allDeclarations = /* @__PURE__ */ new Set();
+    const declarationSources = /* @__PURE__ */ new Map();
+    const renameMap = /* @__PURE__ */ new Map();
+    for (const { path, identifiers: { types, values } } of sortedModules) {
+      for (const name of types) {
+        let set = declarationSources.get(name);
+        if (set === void 0) {
+          declarationSources.set(name, set = /* @__PURE__ */ new Set());
+        }
+        set.add(path);
+      }
+      for (const name of values) {
+        let set = declarationSources.get(name);
+        if (set === void 0) {
+          declarationSources.set(name, set = /* @__PURE__ */ new Set());
+        }
+        set.add(path);
+      }
+    }
+    for (const [name, sourcesSet] of declarationSources) {
+      if (sourcesSet.size > 1) {
+        let suffix = 1;
+        const modulePaths = sourcesSet.values();
+        modulePaths.next();
+        for (const modulePath of modulePaths) {
+          let candidate = `${name}$${suffix}`;
+          while (declarationSources.has(candidate)) {
+            candidate = `${name}$${++suffix}`;
+          }
+          renameMap.set(`${name}:${modulePath}`, candidate);
+          suffix++;
+        }
+      }
+    }
+    for (const { path, typeReferences, fileReferences, sourceFile, code, identifiers: { types, values } } of sortedModules) {
+      for (const r of typeReferences) {
+        typeReferencesSet.add(r);
+      }
+      for (const r of fileReferences) {
+        fileReferencesSet.add(r);
+      }
+      const bundledForThisModule = bundledSpecifiers.get(path) ?? emptySet;
+      const { code: strippedCode, externalImports, typeExports, valueExports } = this.#stripImportsExports(code, sourceFile, { types, values }, bundledForThisModule, renameMap, path);
+      for (const imp of externalImports) {
+        allExternalImports.push(imp);
+      }
+      if (!path.includes(nodeModules)) {
+        for (const exp of valueExports) {
+          valueExportsSet.add(exp);
+        }
+        for (const exp of typeExports) {
+          if (!typeExportsSeen.has(exp)) {
+            typeExportsSeen.add(exp);
+            orderedTypeExports.push(exp);
+          }
+        }
+        for (const name of types) {
+          allDeclarations.add(name);
+        }
+        for (const name of values) {
+          allDeclarations.add(name);
+        }
+      }
+      if (strippedCode.trim().length > 0) {
+        codeBlocks.push(strippedCode.trim());
+      }
+    }
+    const mergedExternalImports = mergeImports(allExternalImports);
+    for (const imp of mergedExternalImports) {
+      if (imp.includes('"node:') || imp.includes("'node:")) {
+        typeReferencesSet.add("node");
+      }
+    }
+    const finalValueExports = [...valueExportsSet];
+    const finalTypeExports = [];
+    for (const typeExport of orderedTypeExports) {
+      if (!valueExportsSet.has(typeExport)) {
+        finalTypeExports.push(typeExport);
+      }
+    }
+    const outputParts = [];
+    if (fileReferencesSet.size > 0) {
+      for (const ref of fileReferencesSet) {
+        outputParts.push(`/// <reference path="${ref}" />`);
+      }
+      outputParts.push("");
+    }
+    if (typeReferencesSet.size > 0) {
+      for (const ref of typeReferencesSet) {
+        outputParts.push(`/// <reference types="${ref}" />`);
+      }
+      outputParts.push("");
+    }
+    if (mergedExternalImports.length > 0) {
+      for (const imp of mergedExternalImports) {
+        outputParts.push(imp);
+      }
+      outputParts.push("");
+    }
+    outputParts.push(codeBlocks.join(newLine + newLine));
+    if (finalTypeExports.length > 0 || finalValueExports.length > 0) {
+      outputParts.push("");
+      if (finalValueExports.length > 0) {
+        outputParts.push(`export { ${finalValueExports.sort().join(", ")} };`);
+      }
+      if (finalTypeExports.length > 0) {
+        outputParts.push(`export type { ${finalTypeExports.sort().join(", ")} };`);
+      }
+    }
+    return { code: outputParts.join(newLine), exports: [...finalTypeExports, ...finalValueExports], allDeclarations };
+  }
+  /**
+   * Main bundling orchestration method
+   * @param entryPoint - The entry point file path
+   * @returns The bundled declaration file content
+   */
+  bundle(entryPoint) {
+    const dtsEntryPoint = this.#resolveEntryPoint(entryPoint, this.#options.compilerOptions);
+    if (dtsEntryPoint === void 0) {
+      return "";
+    }
+    const { modules, bundledSpecifiers } = this.#buildModuleGraph(dtsEntryPoint);
+    const { code } = this.#combineModules(this.#sortModules(modules, dtsEntryPoint), bundledSpecifiers);
+    return DeclarationProcessor.postProcess(createSourceFile(dtsEntryPoint, code, ScriptTarget.Latest, true));
+  }
+  /**
+   * Resolve entry point from source path to declaration path
+   * @param entryPoint - The entry point file path
+   * @param compilerOptions - Minimal compiler options with outDir and rootDir
+   * @returns Resolved declaration entry point path
+   */
+  #resolveEntryPoint(entryPoint, compilerOptions) {
+    const dtsEntryPoint = sys.resolvePath(entryPoint.endsWith(FileExtension.DTS) ? entryPoint : this.#sourceToDeclarationPath(entryPoint));
+    if (this.#declarationFiles.has(dtsEntryPoint)) {
+      return dtsEntryPoint;
+    }
+    if (!entryPoint.endsWith(FileExtension.DTS)) {
+      return void 0;
+    }
+    const availableFiles = Array.from(this.#declarationFiles.keys());
+    const entryPointFilename = basename(entryPoint);
+    const similarFiles = availableFiles.filter((filePath) => filePath.includes(entryPointFilename));
+    throw new BundleError(
+      `Entry point declaration file not found: ${dtsEntryPoint || "unknown"}
+Original entry: ${entryPoint}
+Compiler options: outDir=${compilerOptions.outDir || "dist"}, rootDir=${compilerOptions.rootDir || "not set"}
+Similar files found:
+${similarFiles.map((f) => `  - ${f}`).join("\n")}
+Total available files: ${availableFiles.length}`
+    );
+  }
+};
+async function bundleDeclarations(options) {
+  await mkdir2(options.compilerOptions.outDir, defaultDirOptions);
+  const dtsBundler = new DeclarationBundler(options);
+  const bundleTasks = [];
+  const bundleEntryPoint = (entryName, entryPoint) => {
+    const content = dtsBundler.bundle(entryPoint);
+    if (content.length > 0) {
+      const outPath = Paths.join(options.compilerOptions.outDir, `${entryName}${FileExtension.DTS}`);
+      bundleTasks.push(writeFile2(outPath, content, Encoding.utf8).then(() => ({ path: Paths.relative(options.currentDirectory, outPath), size: content.length })));
+    }
+  };
+  if (options.parallelTranspile) {
+    const queueImmediateTask = (resolve3) => void setImmediate(resolve3);
+    for (const [entryName, entryPoint] of Object.entries(options.entryPoints)) {
+      await new Promise(queueImmediateTask);
+      bundleEntryPoint(entryName, entryPoint);
+    }
+  } else {
+    for (const [entryName, entryPoint] of Object.entries(options.entryPoints)) {
+      bundleEntryPoint(entryName, entryPoint);
+    }
+  }
+  const results = await Promise.all(bundleTasks);
+  dtsBundler.clearExternalFiles();
+  return results;
+}
+
+// src/plugins/output.ts
+import { chmod, open } from "node:fs/promises";
+import { extname } from "node:path";
+async function setShebangPermissions(filePath) {
+  const handle = await open(filePath, "r");
+  try {
+    const buf = Buffer.alloc(2);
+    await handle.read(buf, 0, 2, 0);
+    if (buf[0] === 35 && buf[1] === 33) {
+      await chmod(filePath, 493);
+    }
+  } finally {
+    await handle.close();
+  }
+}
+var outputPlugin = () => {
+  return {
+    name: "esbuild:output-plugin",
+    /**
+     * Checks JS entry points for shebangs and sets executable permissions.
+     * @param build The esbuild plugin build object.
+     */
+    setup(build) {
+      build.onEnd(async ({ metafile }) => {
+        if (!metafile) {
+          return;
+        }
+        const tasks = [];
+        for (const [outputPath, { entryPoint }] of Object.entries(metafile.outputs)) {
+          if (entryPoint && extname(outputPath) === FileExtension.JS) {
+            tasks.push(setShebangPermissions(outputPath));
+          }
+        }
+        if (tasks.length > 0) {
+          await Promise.all(tasks);
+        }
+      });
+    }
+  };
+};
+
+// src/plugins/external-modules.ts
+function packageName(id) {
+  if (id.charCodeAt(0) === 64) {
+    const first = id.indexOf("/");
+    if (first === -1) {
+      return id;
+    }
+    const second = id.indexOf("/", first + 1);
+    return second === -1 ? id : id.slice(0, second);
+  }
+  const slash = id.indexOf("/");
+  return slash === -1 ? id : id.slice(0, slash);
+}
+function buildMatcher(patterns) {
+  const exact = /* @__PURE__ */ new Set();
+  const regexps = [];
+  for (const p of patterns) {
+    if (typeof p === "string") {
+      exact.add(p);
+    } else {
+      regexps.push(p);
+    }
+  }
+  if (exact.size === 0 && regexps.length === 0) {
+    return () => false;
+  }
+  return (id) => {
+    if (exact.has(id)) {
+      return true;
+    }
+    const pkg = packageName(id);
+    if (pkg !== id && exact.has(pkg)) {
+      return true;
+    }
+    return regexps.length > 0 && regexps.some((r) => r.test(id));
+  };
+}
+var externalModulesPlugin = ({ dependencies = [], noExternal = [] }) => {
+  return {
+    name: "esbuild:external-modules",
+    /**
+     * Configure the plugin to handle external modules
+     * @param build The esbuild build instance
+     */
+    setup(build) {
+      const external = true;
+      const matchNoExternal = buildMatcher(noExternal);
+      const matchDependencies = buildMatcher(dependencies);
+      build.onResolve({ filter: /.*/ }, ({ path }) => {
+        switch (true) {
+          case matchNoExternal(path):
+            return;
+          case matchDependencies(path):
+            return { external };
+          case !Paths.isPath(path):
+            return { path, external };
+          default:
+            return;
+        }
+      });
+    }
+  };
+};
+
+// src/plugins/resolve-plugin.ts
+import { resolve } from "node:path";
+function isPlugin(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  return "name" in value && typeof value.name === "string" && "setup" in value && typeof value.setup === "function";
+}
+function isFactory(value) {
+  return typeof value === "function";
+}
+async function resolveReference(reference, projectDir) {
+  const [specifier, options] = typeof reference === "string" ? [reference, void 0] : reference;
+  const resolved = Paths.isPath(specifier) ? resolve(projectDir, specifier) : specifier;
+  let module;
+  try {
+    module = await import(resolved);
+  } catch (error) {
+    throw new ConfigurationError(`Failed to load plugin "${specifier}": ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const defaultExport = module["default"];
+  if (defaultExport === void 0) {
+    throw new ConfigurationError(`Plugin "${specifier}" has no default export. The module must export a plugin factory function or Plugin object as its default export.`);
+  }
+  if (isFactory(defaultExport)) {
+    const result = defaultExport(options);
+    if (!isPlugin(result)) {
+      throw new ConfigurationError(`Plugin "${specifier}" factory did not return a valid esbuild Plugin (expected { name: string, setup: function }).`);
+    }
+    return result;
+  }
+  if (isPlugin(defaultExport)) {
+    if (options !== void 0) {
+      Logger.warn(`Plugin "${specifier}" is a Plugin object, not a factory function. The provided options will be ignored.`);
+    }
+    return defaultExport;
+  }
+  throw new ConfigurationError(`Plugin "${specifier}" default export is not a function or valid esbuild Plugin object.`);
+}
+async function resolvePlugins(plugins, projectDir) {
+  const resolved = [];
+  for (const entry of plugins) {
+    if (isPlugin(entry)) {
+      resolved.push(entry);
+    } else {
+      resolved.push(await resolveReference(entry, projectDir));
+    }
+  }
+  return resolved;
+}
+
+// src/plugins/iife.ts
+import { mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
+import { basename as basename2, dirname as dirname2, join as join2, resolve as resolve2 } from "node:path";
+var namespace = "iife";
+var fileExtensionRegex = /\.[^.]+$/;
+var textDecoder = new TextDecoder();
+function iifePlugin(options) {
+  const files = [];
+  return {
+    files,
+    plugin: {
+      name: "esbuild:iife",
+      /**
+       * Configures the esbuild build instance to produce IIFE output.
+       * @param build The esbuild plugin build object.
+       */
+      setup(build) {
+        const outdir = build.initialOptions.outdir;
+        if (!outdir) {
+          return;
+        }
+        build.initialOptions.write = false;
+        const sourcemap = build.initialOptions.sourcemap;
+        const minify = build.initialOptions.minify;
+        const entryPointNames = extractEntryNames(build.initialOptions.entryPoints);
+        build.onEnd(async ({ outputFiles }) => {
+          if (!outputFiles || outputFiles.length === 0 || entryPointNames.length === 0) {
+            return;
+          }
+          files.push(...await buildIife(outputFiles, entryPointNames, outdir, options?.globalName, sourcemap, minify));
+        });
+      }
+    }
+  };
+}
+function extractEntryNames(entryPoints) {
+  if (!entryPoints) {
+    return [];
+  }
+  if (Array.isArray(entryPoints)) {
+    const names = [];
+    for (const entry of entryPoints) {
+      if (typeof entry === "string") {
+        names.push(basename2(entry).replace(fileExtensionRegex, ""));
+      } else {
+        names.push(entry.out ?? basename2(entry.in).replace(fileExtensionRegex, ""));
+      }
+    }
+    return names;
+  }
+  return Object.keys(entryPoints);
+}
+function wrapAsIife(text, globalName) {
+  const exportStart = text.lastIndexOf("export");
+  if (exportStart === -1) {
+    return text;
+  }
+  const openBrace = text.indexOf("{", exportStart + 6);
+  const closeBrace = text.indexOf("}", openBrace + 1);
+  if (openBrace === -1 || closeBrace === -1 || text.slice(exportStart + 6, openBrace).trim() !== "") {
+    return text;
+  }
+  let exportEnd = closeBrace + 1;
+  while (exportEnd < text.length && /[ \t]/.test(text[exportEnd] ?? "")) {
+    exportEnd += 1;
+  }
+  if (text[exportEnd] === ";") {
+    exportEnd += 1;
+  }
+  const properties = [];
+  for (const rawMember of text.slice(openBrace + 1, closeBrace).split(",")) {
+    const member = rawMember.trim();
+    if (!member) {
+      continue;
+    }
+    const asIndex = member.indexOf(" as ");
+    if (asIndex <= 0) {
+      properties.push(member);
+      continue;
+    }
+    const localName = member.slice(0, asIndex).trim();
+    const exportName = member.slice(asIndex + 4).trim();
+    properties.push(localName && exportName ? `${exportName}: ${localName}` : member);
+  }
+  if (properties.length === 0) {
+    return text;
+  }
+  const exportedObject = properties.join(", ");
+  const assignment = globalName ? `globalThis.${globalName} = { ${exportedObject} };` : `Object.assign(globalThis, { ${exportedObject} });`;
+  return `(() => {
+${text.slice(0, exportStart)}
+	${assignment}
+})();${text.slice(exportEnd)}`;
+}
+async function buildIife(primaryOutputs, entryPointNames, outdir, globalName, sourcemap, minify) {
+  const { build: esbuild } = await import("esbuild");
+  const fileContents = /* @__PURE__ */ new Map();
+  const primaryWrites = [];
+  const ensuredDirs = /* @__PURE__ */ new Map();
+  for (const file of primaryOutputs) {
+    const absolute = resolve2(file.path);
+    if (absolute.endsWith(FileExtension.JS)) {
+      fileContents.set(absolute, file.text);
+    }
+    const dir = dirname2(absolute);
+    let dirReady = ensuredDirs.get(dir);
+    if (dirReady === void 0) {
+      dirReady = mkdir3(dir, { recursive: true });
+      ensuredDirs.set(dir, dirReady);
+    }
+    primaryWrites.push(dirReady.then(() => writeFile3(absolute, file.contents)));
+  }
+  const validEntries = [];
+  for (const name of entryPointNames) {
+    const path = Paths.absolute(outdir, name + FileExtension.JS);
+    if (fileContents.has(path)) {
+      validEntries.push({ name, path });
+    }
+  }
+  if (validEntries.length === 0) {
+    await Promise.all(primaryWrites);
+    return [];
+  }
+  const sourcemapValue = sourcemap !== void 0 && sourcemap !== false ? "external" : false;
+  const plugins = [virtualLoaderPlugin(fileContents)];
+  const iifeOutdir = join2(outdir, namespace);
+  await mkdir3(iifeOutdir, { recursive: true });
+  const results = await Promise.all(validEntries.map(({ name, path }) => {
+    return esbuild({
+      entryPoints: { [name]: path },
+      bundle: true,
+      format,
+      splitting: false,
+      outdir: iifeOutdir,
+      sourcemap: sourcemapValue,
+      minify,
+      write: false,
+      logLevel: "warning",
+      plugins
+    });
+  }));
+  const written = [];
+  const writes = [];
+  const cwd = process.cwd();
+  for (const { outputFiles } of results) {
+    const outputFilePaths = new Set(outputFiles.map(({ path }) => path));
+    for (const { path, contents } of outputFiles) {
+      let text, size = contents.byteLength;
+      if (path.endsWith(FileExtension.JS)) {
+        text = wrapAsIife(textDecoder.decode(contents), globalName);
+        if (outputFilePaths.has(`${path}.map`)) {
+          text += `
+//# sourceMappingURL=${basename2(path)}.map`;
+          size = Buffer.byteLength(text);
+        }
+      } else {
+        text = contents;
+      }
+      writes.push(writeFile3(path, text));
+      written.push({ path: Paths.relative(cwd, path), size });
+    }
+  }
+  await Promise.all([...writes, ...primaryWrites]);
+  return written;
+}
+function virtualLoaderPlugin(fileContents) {
+  return {
+    name: "iife:virtual-loader",
+    /**
+     * Registers onResolve and onLoad hooks for virtual file loading
+     * @param build The esbuild build instance
+     */
+    setup(build) {
+      build.onResolve({ filter: /.*/ }, (args) => {
+        if (args.kind === "entry-point") {
+          return { path: args.path, namespace };
+        }
+        if (!args.path.startsWith(".") && !args.path.startsWith("/")) {
+          return { external: true };
+        }
+        const resolved = resolve2(args.resolveDir, args.path);
+        return fileContents.has(resolved) ? { path: resolved, namespace } : { external: true };
+      });
+      build.onLoad({ filter: /.*/, namespace }, (args) => {
+        const contents = fileContents.get(args.path);
+        return contents === void 0 ? null : { contents, loader: "js", resolveDir: dirname2(args.path) };
+      });
+    }
+  };
+}
+
+// src/process-manager.ts
+var ProcessEvent = {
+  exit: "exit",
+  sigint: "SIGINT",
+  uncaughtException: "uncaughtException"
+};
+var ProcessManager = class {
+  #hasHandledExit = false;
+  #closeableClasses = [];
+  constructor() {
+    process.addListener(ProcessEvent.exit, this.#handleExit);
+    process.addListener(ProcessEvent.sigint, this.#consoleExit);
+    process.addListener(ProcessEvent.uncaughtException, this.#handleUncaughtException);
+  }
+  /**
+   * Adds a closeable class to be closed on exit.
+   * @param closeable The closeable class to add.
+   */
+  addCloseable(closeable) {
+    this.#closeableClasses.push(closeable);
+  }
+  /** Closes the process manager and removes all listeners */
+  close() {
+    this.#closeableClasses.length = 0;
+    process.removeListener(ProcessEvent.exit, this.#handleExit);
+    process.removeListener(ProcessEvent.sigint, this.#consoleExit);
+    process.removeListener(ProcessEvent.uncaughtException, this.#handleUncaughtException);
+  }
+  /** Handles normal process exit */
+  #handleExit = () => {
+    if (this.#hasHandledExit) {
+      return;
+    }
+    for (const closeable of this.#closeableClasses) {
+      closeable.close();
+    }
+    this.close();
+  };
+  /** Handles SIGINT (ctrl+c) */
+  #consoleExit = () => {
+    Logger.warn("\nProcess terminated by user");
+    this.#hasHandledExit = true;
+    for (const closeable of this.#closeableClasses) {
+      closeable.close();
+    }
+    this.close();
+    process.exit(130);
+  };
+  /**
+   * Handles uncaught exceptions and exits the process.
+   * @param e The error that was uncaught.
+   */
+  #handleUncaughtException = (e) => {
+    Logger.error("Uncaught Exception...", e.stack);
+    process.exit(99);
+  };
+};
+var processManager = new ProcessManager();
+
+// src/decorators/close-on-exit.ts
+function closeOnExit(value, _context) {
+  return class extends value {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    constructor(...args) {
+      super(...args);
+      processManager.addCloseable(this);
+    }
+  };
+}
+
+// src/decorators/performance-logger.ts
+import { PerformanceObserver, performance } from "perf_hooks";
+var type = "measure";
+var pendingSteps = [];
+var _PerformanceLogger_decorators, _init;
+_PerformanceLogger_decorators = [closeOnExit];
+var _PerformanceLogger = class _PerformanceLogger {
+  #performanceObserver;
+  constructor() {
+    this.#performanceObserver = new PerformanceObserver((list) => {
+      for (const { name, duration, detail: { message, result = [], steps } } of list.getEntriesByType(type).reverse()) {
+        if (message === "Build") {
+          Logger.separator();
+          if (process.exitCode) {
+            Logger.error(`\u2717 Build failed in ${TextFormat.cyan(_PerformanceLogger.#formatDuration(duration))}
+`);
+          } else {
+            Logger.step(`Completed in ${TextFormat.cyan(_PerformanceLogger.#formatDuration(duration))}
+`);
+          }
+        } else {
+          Logger.step(`${message} ${TextFormat.dim(`(${_PerformanceLogger.#formatDuration(duration)})`)}`);
+          if (steps?.length) {
+            Logger.subSteps(steps);
+          }
+          if (result.length > 0) {
+            Logger.success("", ...result);
+          }
+        }
+        performance.clearResourceTimings(name);
+      }
+    });
+    this.#performanceObserver.observe({ type });
+  }
+  /**
+   * Measures the performance of a method and logs the result.
+   * @param message - The message to log with the performance measurement
+   * @param logResult - Whether to include the method return value in the log output
+   * @returns A Stage 3 method decorator that measures execution time of the decorated method
+   */
+  measure(message, logResult = false) {
+    const _measure = (propertyKey, result, options) => {
+      if (logResult) {
+        options.detail.result = result;
+      }
+      if (pendingSteps.length > 0) {
+        options.detail.steps = pendingSteps.splice(0);
+      }
+      ({ startTime: options.end } = performance.mark(propertyKey));
+      performance.measure(propertyKey, options);
+      return result;
+    };
+    return function(targetMethod, context) {
+      const propertyKey = String(context.name);
+      return function(...args) {
+        const options = { start: performance.mark(propertyKey).startTime, detail: { message } };
+        const result = targetMethod.apply(this, args);
+        return result instanceof Promise ? result.then((r) => _measure(propertyKey, r, options)) : _measure(propertyKey, result, options);
+      };
+    };
+  }
+  /**
+   * Closes the performance logger.
+   */
+  close() {
+    this.#performanceObserver.disconnect();
+  }
+  /**
+   * Formats the duration into a human-readable string.
+   * @param duration - The duration to format.
+   * @returns The formatted duration string.
+   */
+  static #formatDuration(duration) {
+    const minutes = ~~(duration / 6e4) % 60;
+    const seconds = ~~(duration / 1e3) % 60;
+    const ms = ~~duration % 1e3;
+    if (minutes > 0) {
+      return `${minutes}m${seconds}s${ms}ms`;
+    }
+    if (seconds > 0) {
+      return `${seconds}s${ms}ms`;
+    }
+    return `${ms}ms`;
+  }
+};
+_init = __decoratorStart(null);
+_PerformanceLogger = __decorateElement(_init, 0, "PerformanceLogger", _PerformanceLogger_decorators, _PerformanceLogger);
+__runInitializers(_init, 1, _PerformanceLogger);
+var PerformanceLogger = _PerformanceLogger;
+var measure = new PerformanceLogger().measure;
+
+// src/decorators/debounce.ts
+var _DebounceManager_decorators, _init2;
+_DebounceManager_decorators = [closeOnExit];
+var _DebounceManager = class _DebounceManager {
+  static #timers = /* @__PURE__ */ new Set();
+  /**
+   * Creates a debounced version of a function.
+   * @param func - The function to debounce.
+   * @param wait - The number of milliseconds to wait before invoking the function.
+   * @returns A debounced version of the function that returns a Promise.
+   */
+  debounce(func, wait) {
+    let timeoutId;
+    let pendingResolve;
+    return function(...args) {
+      return new Promise((resolve3, reject) => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+          _DebounceManager.#timers.delete(timeoutId);
+        }
+        if (pendingResolve) {
+          pendingResolve(void 0);
+        }
+        pendingResolve = resolve3;
+        timeoutId = setTimeout(() => {
+          if (timeoutId) {
+            _DebounceManager.#timers.delete(timeoutId);
+          }
+          try {
+            resolve3(func.apply(this, args));
+          } catch (error) {
+            reject(castError(error));
+          } finally {
+            pendingResolve = void 0;
+            timeoutId = void 0;
+          }
+        }, wait);
+        _DebounceManager.#timers.add(timeoutId);
+      });
+    };
+  }
+  /** Closes the manager by clearing all active timers. */
+  close() {
+    for (const timer of _DebounceManager.#timers) {
+      clearTimeout(timer);
+    }
+    _DebounceManager.#timers.clear();
+  }
+};
+_init2 = __decoratorStart(null);
+_DebounceManager = __decorateElement(_init2, 0, "DebounceManager", _DebounceManager_decorators, _DebounceManager);
+__runInitializers(_init2, 1, _DebounceManager);
+var DebounceManager = _DebounceManager;
+var debounceManager = new DebounceManager();
+function debounce(wait) {
+  if (wait < 0) {
+    throw new Error("\u{1F6A8} wait must be non-negative.");
+  }
+  return function(targetMethod, context) {
+    context.addInitializer(function() {
+      Object.defineProperty(this, context.name, { writable: true, configurable: true, value: debounceManager.debounce(targetMethod.bind(this), wait) });
+    });
+    return targetMethod;
+  };
+}
+
+// src/file-manager.ts
+import { createSourceFile as createSourceFile2, ScriptTarget as ScriptTarget2 } from "typescript";
+var localFileIdentifier = /\.[a-z]+$/i;
+var relativeSpecifierPattern = /(from\s*['"])(\.\.?\/[^'"]*?)(['"])/g;
+function rewriteRelativeSpecifiers(code) {
+  return code.replace(relativeSpecifierPattern, (_, before, path, after) => localFileIdentifier.test(path) ? before + path + after : `${before}${path}.js${after}`);
+}
+var FileManager = class {
+  #hasEmittedFiles = false;
+  #declarationFiles = /* @__PURE__ */ new Map();
+  #cache;
+  /** Raw declaration text captured during emit, pending pre-processing */
+  #pendingFiles = [];
+  /** Buffered .tsbuildinfo content for async write (avoids sync I/O during emit) */
+  #pendingBuildInfo;
+  /** Background cache save promise — awaited in initialize() and close() */
+  #pendingSave;
+  /**
+   * Creates a new file manager.
+   * @param buildCache - Optional build cache for incremental builds
+   */
+  constructor(buildCache) {
+    this.#cache = buildCache;
+  }
+  /**
+   * Prepares the manager for a new TypeScript emit operation.
+   * For incremental builds, restores cached (pre-processed) declarations before emit.
+   * For non-incremental builds, clears all stored files.
+   *
+   * @example
+   * ```typescript
+   * await manager.initialize();
+   * program.emit(undefined, manager.fileWriter, undefined, true);
+   * await manager.finalize();
+   * ```
+   */
+  async initialize() {
+    if (this.#pendingSave) {
+      await this.#pendingSave;
+      this.#pendingSave = void 0;
+    }
+    this.#hasEmittedFiles = false;
+    this.#pendingFiles.length = 0;
+    this.#pendingBuildInfo = void 0;
+    if (this.#cache) {
+      await this.#cache.restore(this.#declarationFiles);
+    } else {
+      this.#declarationFiles.clear();
+    }
+  }
+  /**
+   * Finalizes the emit operation by saving the cache if files were emitted.
+   * Must be called after program.emit() to ensure cache is properly saved.
+   *
+   * @returns True if files were emitted (or non-incremental build), false if no changes detected
+   * @example
+   * ```typescript
+   * await manager.initialize();
+   * program.emit(undefined, manager.fileWriter, undefined, true);
+   * const hasEmitted = manager.finalize();
+   * if (hasEmitted) { // Continue with build }
+   * ```
+   */
+  finalize() {
+    this.#processEmittedFiles();
+    return this.#cache === void 0 || this.#hasEmittedFiles;
+  }
+  /**
+   * Persists the .tsbuildinfo file and the dts cache to disk in the background. Call this
+   * AFTER the build's parallel phases (transpile + dts bundling) have completed so the writes
+   * (and Brotli compression for the dts cache) don't compete with esbuild for libuv threadpool slots.
+   * @param fingerprint Build configuration fingerprint for cache invalidation on config change
+   * @param configChanged True when the build configuration fingerprint changed — forces the new
+   *   fingerprint to be saved even when TypeScript did not re-emit any files, preventing the
+   *   mismatch from triggering unnecessary forced rebuilds on every subsequent build.
+   */
+  persistCache(fingerprint, configChanged = false) {
+    const tasks = [];
+    if (this.#pendingBuildInfo) {
+      tasks.push(Files.write(this.#pendingBuildInfo.path, this.#pendingBuildInfo.text));
+      this.#pendingBuildInfo = void 0;
+    }
+    if (this.#cache !== void 0 && (this.#hasEmittedFiles || configChanged)) {
+      tasks.push(this.#cache.save(this.#declarationFiles, fingerprint));
+    }
+    if (tasks.length === 0) {
+      return;
+    }
+    const save = tasks.length === 1 ? tasks[0].then(() => {
+    }, () => {
+    }) : Promise.all(tasks).then(() => {
+    }, () => {
+    });
+    this.#pendingSave = this.#pendingSave === void 0 ? save : Promise.all([this.#pendingSave, save]).then(() => {
+    }, () => {
+    });
+  }
+  /**
+   * Retrieves all stored declaration files.
+   * Files are already pre-processed and ready for bundling or writing to disk.
+   * This is a pure getter with no side effects.
+   *
+   * @returns A read-only map of file paths to their pre-processed content with extracted references
+   */
+  getDeclarationFiles() {
+    return this.#declarationFiles;
+  }
+  /**
+   * Writes all stored declaration files to disk.
+   * Files are already pre-processed, so this just writes them directly.
+   *
+   * @param projectDirectory - Project root for calculating relative paths
+   * @returns Array of written file metadata
+   */
+  async writeFiles(projectDirectory) {
+    if (this.#declarationFiles.size === 0) {
+      return [];
+    }
+    const writeTasks = [];
+    for (const [filePath, { code }] of this.#declarationFiles) {
+      if (code.length > 0) {
+        writeTasks.push(this.#writeFile(projectDirectory, filePath, code));
+      }
+    }
+    return Promise.all(writeTasks);
+  }
+  /**
+   * Resolves entry points for declaration bundling.
+   * This is a utility method that filters project entry points based on DTS configuration.
+   *
+   * @param projectEntryPoints - All entry points from project configuration
+   * @param dtsEntryPoints - Optional list of entry point names to include for DTS bundling
+   * @returns Filtered entry points for declaration bundling
+   */
+  resolveEntryPoints(projectEntryPoints, dtsEntryPoints) {
+    if (!dtsEntryPoints) {
+      return defaultEntryPoint in projectEntryPoints ? { [defaultEntryPoint]: projectEntryPoints[defaultEntryPoint] } : projectEntryPoints;
+    }
+    const result = {};
+    const allowedEntryPoints = new Set(dtsEntryPoints);
+    for (const [name, path] of Object.entries(projectEntryPoints)) {
+      if (allowedEntryPoints.has(name)) {
+        result[name] = path;
+      }
+    }
+    return result;
+  }
+  /**
+   * Closes the file manager and releases resources.
+   * Clears all stored declaration files.
+   */
+  close() {
+    this.#pendingSave?.then(() => {
+    }, () => {
+    });
+    this.#pendingSave = void 0;
+    this.#pendingFiles.length = 0;
+    this.#pendingBuildInfo = void 0;
+    this.#declarationFiles.clear();
+  }
+  /**
+   * Awaits any in-flight background I/O (cache save, .tsbuildinfo write).
+   * Call this when you need to guarantee all pending writes have completed,
+   * e.g., before reading the cache file from a different instance.
+   */
+  async flush() {
+    if (this.#pendingSave) {
+      await this.#pendingSave;
+      this.#pendingSave = void 0;
+    }
+  }
+  /**
+   * Writes a single declaration file to disk.
+   * @param projectDirectory - Project root for calculating relative paths
+   * @param filePath - The full path of the declaration file to write
+   * @param content - The pre-processed content of the declaration file
+   * @returns Metadata of the written file
+   */
+  async #writeFile(projectDirectory, filePath, content) {
+    const rewritten = rewriteRelativeSpecifiers(content);
+    await Files.write(filePath, rewritten);
+    return { path: Paths.relative(projectDirectory, filePath), size: rewritten.length };
+  }
+  /**
+   * Function that intercepts file writes during TypeScript emit.
+   * Captures raw text for deferred pre-processing and buffers .tsbuildinfo for async I/O.
+   * Designed to be as fast as possible since it runs inside TypeScript's synchronous emit() call.
+   * @param filePath - The path of the file being written
+   * @param text - The content of the file being written
+   */
+  fileWriter = (filePath, text) => {
+    if (this.#cache?.isBuildInfoFile(filePath)) {
+      this.#pendingBuildInfo = { path: filePath, text };
+    } else {
+      this.#pendingFiles.push({ path: filePath, text });
+      if (!this.#hasEmittedFiles) {
+        this.#hasEmittedFiles = true;
+      }
+    }
+  };
+  /**
+   * Pre-processes all declaration files captured during emit.
+   * Runs createSourceFile + DeclarationProcessor.preProcess for each pending file,
+   * then clears the pending queue.
+   */
+  #processEmittedFiles() {
+    for (const { path, text } of this.#pendingFiles) {
+      const result = DeclarationProcessor.preProcess(createSourceFile2(path, text, ScriptTarget2.Latest, true));
+      if (result.code.length > 0) {
+        this.#declarationFiles.set(path, result);
+      }
+    }
+    this.#pendingFiles.length = 0;
+  }
+  /**
+   * Custom inspection method for better type representation.
+   * @returns The string 'FileManager'
+   */
+  get [Symbol.toStringTag]() {
+    return "FileManager";
+  }
+};
+
+// src/incremental-build-cache.ts
+import { existsSync, readFileSync, rmSync } from "node:fs";
+import { mkdir as mkdir4, writeFile as writeFile4 } from "node:fs/promises";
+var IncrementalBuildCache = class _IncrementalBuildCache {
+  #buildInfoPath;
+  #cacheDirectoryPath;
+  #cacheFilePath;
+  #outputsManifestPath;
+  /** Pre-loading promise started in constructor for async cache restoration */
+  #cacheLoaded;
+  /**
+   * Manifest snapshot captured synchronously at construction. Held in memory so it survives
+   * `invalidate()` (which deletes the on-disk manifest as part of clearing `.tsbuild`) and so
+   * subsequent in-process reads are race-free.
+   */
+  #outputsSnapshot;
+  /** Set to true when invalidate() is called to prevent stale cache from being restored */
+  #invalidated = false;
+  /** Updated synchronously in save() so fingerprintMatches() sees fresh data without re-reading from disk. */
+  #savedFingerprint;
+  /**
+   * Creates a new build cache instance and begins pre-loading the cache asynchronously.
+   * @param projectRoot - Root directory of the project
+   * @param tsBuildInfoFile - Path to the TypeScript build info file
+   */
+  constructor(projectRoot, tsBuildInfoFile) {
+    this.#buildInfoPath = Paths.join(projectRoot, tsBuildInfoFile);
+    this.#cacheDirectoryPath = Paths.join(projectRoot, cacheDirectory);
+    this.#cacheFilePath = Paths.join(this.#cacheDirectoryPath, dtsCacheFile);
+    this.#outputsManifestPath = Paths.join(this.#cacheDirectoryPath, outputManifestFile);
+    this.#cacheLoaded = this.#loadCache();
+    this.#outputsSnapshot = _IncrementalBuildCache.#loadOutputsSync(this.#outputsManifestPath);
+  }
+  /**
+   * Loads the cache file asynchronously using V8 deserialization.
+   * @returns The cache or undefined if cache doesn't exist, is corrupted, or has incompatible version.
+   */
+  async #loadCache() {
+    try {
+      const cache = await Files.readCompressed(this.#cacheFilePath);
+      if (cache.version !== dtsCacheVersion) {
+        return void 0;
+      }
+      return cache;
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Restores cached declaration files into the provided map.
+   * Waits for the pre-load promise started in constructor to complete.
+   * TypeScript's incremental compilation handles staleness - it re-emits only changed files,
+   * which overwrite cached entries. Unchanged files remain valid and skip re-emission.
+   * @param target - The map to populate with cached declarations
+   */
+  async restore(target) {
+    if (this.#invalidated) {
+      return;
+    }
+    const cache = await this.#cacheLoaded;
+    if (cache === void 0) {
+      return;
+    }
+    for (const [fileName, content] of cache.files) {
+      target.set(fileName, content);
+    }
+  }
+  /**
+   * Saves declaration files to the compressed cache file with version and fingerprint information.
+   * Uses V8 serialization for faster read performance on subsequent builds.
+   * @param source - The declaration files to cache
+   * @param fingerprint - Deterministic hash of build configuration for cache invalidation on config change
+   */
+  async save(source, fingerprint) {
+    this.#savedFingerprint = fingerprint;
+    await Files.writeCompressed(this.#cacheFilePath, { version: dtsCacheVersion, files: source, fingerprint });
+  }
+  /**
+   * Checks whether the build configuration has changed since the cache was last saved.
+   * Returns true if the cache is valid and fingerprints match, false if config changed or cache is invalid.
+   * @param currentFingerprint - The fingerprint of the current build configuration
+   * @returns True if the cached configuration matches the current configuration
+   */
+  async fingerprintMatches(currentFingerprint) {
+    if (this.#invalidated) {
+      return false;
+    }
+    if (!this.hasPersistedState()) {
+      return false;
+    }
+    if (this.#savedFingerprint !== void 0) {
+      return this.#savedFingerprint === currentFingerprint;
+    }
+    const cache = await this.#cacheLoaded;
+    return cache?.fingerprint === currentFingerprint;
+  }
+  /**
+   * Loads the previous build's output manifest synchronously.
+   * @param manifestPath - Absolute path to the manifest file
+   * @returns The recorded outputs, or undefined when missing/unreadable/malformed.
+   */
+  static #loadOutputsSync(manifestPath) {
+    try {
+      const parsed = JSON.parse(readFileSync(manifestPath, "utf8"));
+      return Array.isArray(parsed) ? parsed : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Returns the project-relative output paths recorded by the previous build, or undefined if none.
+   * The snapshot is captured at construction time and survives `invalidate()`.
+   * @returns The recorded outputs from the prior build, or undefined when unavailable.
+   */
+  getPreviousOutputs() {
+    return this.#outputsSnapshot;
+  }
+  /**
+   * Persists the project-relative output paths produced by the current build.
+   * Updates the in-memory snapshot immediately so subsequent getPreviousOutputs() calls
+   * (in watch mode) return the freshly written list without re-reading disk.
+   * @param outputs - Project-relative output paths
+   */
+  async saveOutputs(outputs) {
+    this.#outputsSnapshot = outputs.slice();
+    await mkdir4(this.#cacheDirectoryPath, defaultDirOptions);
+    await writeFile4(this.#outputsManifestPath, JSON.stringify(this.#outputsSnapshot), "utf8");
+  }
+  /**
+   * Checks if the cache is valid (not invalidated).
+   * @returns True if the cache is valid, false if it has been invalidated
+   */
+  isValid() {
+    return !this.#invalidated;
+  }
+  /** Invalidates the build cache by removing the cache directory. */
+  invalidate() {
+    this.#invalidated = true;
+    try {
+      rmSync(this.#cacheDirectoryPath, defaultCleanOptions);
+    } catch {
+    }
+  }
+  /**
+   * Checks if a file path is the TypeScript build info file.
+   * @param filePath - The file path to check
+   * @returns True if the path matches the build info file
+   */
+  isBuildInfoFile(filePath) {
+    return filePath === this.#buildInfoPath;
+  }
+  /**
+   * Synchronously checks whether persisted incremental state exists on disk.
+   * When the .tsbuildinfo file is missing, the next typecheck will perform a full emit,
+   * making it safe to clean the output directory eagerly in parallel with type checking.
+   * @returns True when the .tsbuildinfo file is present and the cache hasn't been invalidated.
+   */
+  hasPersistedState() {
+    return !this.#invalidated && existsSync(this.#buildInfoPath);
+  }
+  /**
+   * Synchronously checks whether a manifest snapshot from a prior build is available.
+   * Survives `invalidate()` so the manifest-driven cleanup path can be used on
+   * `--clearCache` and `--force` runs as well.
+   * @returns True when an output manifest snapshot is held in memory.
+   */
+  hasPersistedManifest() {
+    return this.#outputsSnapshot !== void 0;
+  }
+  /**
+   * Custom inspection tag for type.
+   * @returns The string 'IncrementalBuildCache'
+   */
+  get [Symbol.toStringTag]() {
+    return "IncrementalBuildCache";
+  }
+};
+
+// src/entry-points.ts
+var importConditions = ["import", "node", "module", "default"];
+function stemOf(filePath) {
+  const base = filePath.split("/").at(-1) ?? "";
+  const dot = base.indexOf(".");
+  return dot === -1 ? base : base.slice(0, dot);
+}
+var outputToSourceExtension = /* @__PURE__ */ new Map([
+  [".js", ".ts"],
+  [".jsx", ".tsx"],
+  [".d.ts", ".ts"]
+]);
+function unscope(name) {
+  const slash = name.indexOf("/");
+  return slash === -1 ? name : name.slice(slash + 1);
+}
+function outputToSourcePath(outputPath, outDir, sourceDir) {
+  const normalizedOutput = outputPath.replace(/^\.\//, "");
+  const normalizedOutDir = outDir.replace(/^\.\//, "").replace(/\/$/, "");
+  if (!normalizedOutput.startsWith(normalizedOutDir + "/") && normalizedOutput !== normalizedOutDir) {
+    return void 0;
+  }
+  const relativePortion = normalizedOutput.slice(normalizedOutDir.length + 1);
+  for (const [outExt, srcExt] of outputToSourceExtension) {
+    if (relativePortion.endsWith(outExt)) {
+      return `./${sourceDir}/${relativePortion.slice(0, -outExt.length)}${srcExt}`;
+    }
+  }
+  return void 0;
+}
+function resolveConditionalExport(exportValue) {
+  if (typeof exportValue === "string") {
+    return exportValue;
+  }
+  for (const condition of importConditions) {
+    const value = exportValue[condition];
+    if (value === void 0) {
+      continue;
+    }
+    const resolved = resolveConditionalExport(value);
+    if (resolved !== void 0) {
+      return resolved;
+    }
+  }
+  return void 0;
+}
+function subpathToEntryName(subpath, packageName2) {
+  if (subpath === ".") {
+    return packageName2 !== void 0 ? unscope(packageName2) : "index";
+  }
+  const withoutPrefix = subpath.replace(/^\.\//, "");
+  const lastSegment = withoutPrefix.lastIndexOf("/");
+  return lastSegment === -1 ? withoutPrefix : withoutPrefix.slice(lastSegment + 1);
+}
+function inferEntryPoints(packageJson, outDir, sourceDir = "src") {
+  const entryPoints = {};
+  if (packageJson.exports !== void 0) {
+    if (typeof packageJson.exports === "string") {
+      const sourcePath = outputToSourcePath(packageJson.exports, outDir, sourceDir);
+      if (sourcePath) {
+        entryPoints[stemOf(sourcePath)] = sourcePath;
+      }
+    } else {
+      for (const [subpath, exportValue] of Object.entries(packageJson.exports)) {
+        if (subpath.includes("*")) {
+          continue;
+        }
+        const outputPath = resolveConditionalExport(exportValue);
+        if (outputPath === void 0) {
+          continue;
+        }
+        const sourcePath = outputToSourcePath(outputPath, outDir, sourceDir);
+        if (sourcePath) {
+          entryPoints[subpath === "." ? stemOf(sourcePath) : subpathToEntryName(subpath, packageJson.name)] = sourcePath;
+        }
+      }
+    }
+  }
+  if (packageJson.bin !== void 0) {
+    const binEntries = typeof packageJson.bin === "string" ? { [packageJson.name ?? "cli"]: packageJson.bin } : packageJson.bin;
+    for (const [name, outputPath] of Object.entries(binEntries)) {
+      if (entryPoints[name] === void 0) {
+        const sourcePath = outputToSourcePath(outputPath, outDir, sourceDir);
+        if (sourcePath) {
+          entryPoints[name] = sourcePath;
+        }
+      }
+    }
+  }
+  let hasEntries = false;
+  for (const _ in entryPoints) {
+    hasEntries = true;
+    break;
+  }
+  if (!hasEntries) {
+    const legacyPath = packageJson.module ?? packageJson.main;
+    if (legacyPath !== void 0) {
+      const sourcePath = outputToSourcePath(legacyPath, outDir, sourceDir);
+      if (sourcePath) {
+        entryPoints["index"] = sourcePath;
+      }
+    }
+  }
+  for (const _ in entryPoints) {
+    return entryPoints;
+  }
+  return void 0;
+}
+
+// src/type-script-project.ts
+import { performance as performance2 } from "node:perf_hooks";
+import { sys as sys2, createIncrementalProgram, formatDiagnostics, formatDiagnosticsWithColorAndContext, parseJsonConfigFileContent, readConfigFile, findConfigFile } from "typescript";
+var globCharacters = /[*?\\[\]!].*$/;
+var domPredicate = (lib) => lib.toUpperCase() === "DOM";
+var tsLogo = TextFormat.bgBlue(TextFormat.bold(TextFormat.whiteBright(" TS ")));
+var diagnosticsHost = { getNewLine: () => sys2.newLine, getCurrentDirectory: sys2.getCurrentDirectory, getCanonicalFileName: (fileName) => fileName };
+var serializePattern = (p) => p instanceof RegExp ? `/${p.source}/${p.flags}` : p;
+function buildFingerprint(buildConfig, compilerOptions) {
+  return JSON.stringify({
+    minify: buildConfig.minify,
+    iife: buildConfig.iife,
+    declaration: compilerOptions.declaration,
+    emitDeclarationOnly: compilerOptions.emitDeclarationOnly,
+    emitDecoratorMetadata: compilerOptions.emitDecoratorMetadata,
+    bundle: buildConfig.bundle,
+    splitting: buildConfig.splitting,
+    format,
+    target: buildConfig.target,
+    platform: buildConfig.platform,
+    sourceMap: buildConfig.sourceMap,
+    banner: buildConfig.banner,
+    footer: buildConfig.footer,
+    noExternal: buildConfig.noExternal.map(serializePattern),
+    dtsResolve: buildConfig.dts.resolve,
+    dtsEntryPoints: buildConfig.dts.entryPoints,
+    env: buildConfig.env
+  });
+}
+var _triggerRebuild_dec, _processDeclarations_dec, _transpile_dec, _typeCheck_dec, _build_dec, _TypeScriptProject_decorators, _fileWatcher, _builderProgram, _directory, _configuration, _fileManager, _buildConfiguration, _pendingChanges, _buildDependencies, _pendingStaleOutputsCleanup, _buildDependenciesProgram, _dependencyPaths, _TypeScriptProject_instances, cleanupStaleOutputs_fn, _init3, typeCheck_fn, transpile_fn, watch_fn, processDeclarations_fn, triggerRebuild_fn, _TypeScriptProject_static, resolveConfiguration_fn, getEntryPoints_fn, handleBuildError_fn, handleTypeErrors_fn;
+_TypeScriptProject_decorators = [closeOnExit], _build_dec = [measure("Build")], _typeCheck_dec = [measure("Type-checking/Emit", true)], _transpile_dec = [measure("Transpile", true)], _processDeclarations_dec = [measure("Bundle Declarations", true)], _triggerRebuild_dec = [debounce(100)];
+var _TypeScriptProject = class _TypeScriptProject {
+  /**
+   * Creates a TypeScript project and prepares it for building/bundling.
+   * @param directory - Project root directory (defaults to current working directory)
+   * @param options - Project options to merge with tsconfig.json
+   */
+  constructor(directory = sys2.getCurrentDirectory(), options = {}) {
+    __runInitializers(_init3, 5, this);
+    __privateAdd(this, _TypeScriptProject_instances);
+    __privateAdd(this, _fileWatcher);
+    __privateAdd(this, _builderProgram);
+    __privateAdd(this, _directory);
+    __privateAdd(this, _configuration);
+    __privateAdd(this, _fileManager);
+    __privateAdd(this, _buildConfiguration);
+    __privateAdd(this, _pendingChanges, []);
+    __privateAdd(this, _buildDependencies, /* @__PURE__ */ new Set());
+    __privateAdd(this, _pendingStaleOutputsCleanup);
+    /** Identity of the Program that populated buildDependencies — skip re-walking when unchanged */
+    __privateAdd(this, _buildDependenciesProgram);
+    __privateAdd(this, _dependencyPaths);
+    var _a;
+    __privateSet(this, _directory, Paths.absolute(directory));
+    __privateSet(this, _configuration, __privateMethod(_a = _TypeScriptProject, _TypeScriptProject_static, resolveConfiguration_fn).call(_a, __privateGet(this, _directory), options));
+    const { buildCache, rootNames, projectReferences, configFileParsingDiagnostics, tsbuild: { entryPoints, ...tsbuildOptions }, compilerOptions: { target, outDir } } = __privateGet(this, _configuration);
+    if (buildCache !== void 0 && options.clearCache) {
+      buildCache.invalidate();
+    }
+    __privateSet(this, _fileManager, new FileManager(buildCache));
+    __privateSet(this, _builderProgram, createIncrementalProgram({ rootNames, options: __privateGet(this, _configuration).compilerOptions, projectReferences, configFileParsingDiagnostics }));
+    __privateSet(this, _buildConfiguration, { entryPoints: __privateMethod(this, _TypeScriptProject_instances, getEntryPoints_fn).call(this, entryPoints), target: toEsTarget(target), outDir, ...tsbuildOptions });
+    __privateSet(this, _dependencyPaths, Files.read(Paths.absolute(__privateGet(this, _directory), "package.json")).then((content) => {
+      const { dependencies = {}, peerDependencies = {} } = Json.parse(content);
+      const dependencySet = /* @__PURE__ */ new Set();
+      for (const key of Object.keys(dependencies)) {
+        dependencySet.add(key);
+      }
+      for (const key of Object.keys(peerDependencies)) {
+        dependencySet.add(key);
+      }
+      return Array.from(dependencySet);
+    }).catch(() => []));
+  }
+  /**
+   * Cleans the output directory
+   * @returns A promise that resolves when the cleaning is complete.
+   */
+  async clean() {
+    return Files.empty(__privateGet(this, _buildConfiguration).outDir);
+  }
+  async build() {
+    Logger.header(`${tsLogo} tsbuild v${"1.9.2"}${__privateGet(this, _configuration).compilerOptions.incremental && __privateGet(this, _configuration).buildCache?.isValid() ? " [incremental]" : ""}`);
+    try {
+      const processes = [];
+      const buildCache = __privateGet(this, _configuration).buildCache;
+      const currentFingerprint = buildFingerprint(__privateGet(this, _buildConfiguration), __privateGet(this, _configuration).compilerOptions);
+      const fingerprintMatched = buildCache !== void 0 && await buildCache.fingerprintMatches(currentFingerprint);
+      const force = __privateGet(this, _configuration).tsbuild.force || !fingerprintMatched;
+      const cleanEnabled = __privateGet(this, _configuration).clean && !__privateGet(this, _configuration).compilerOptions.noEmit;
+      const useManifest = cleanEnabled && buildCache !== void 0 && buildCache.hasPersistedManifest();
+      const previousOutputs = useManifest ? buildCache.getPreviousOutputs() : void 0;
+      const willEmit = force || buildCache?.hasPersistedState() !== true;
+      const eagerCleanPromise = cleanEnabled && willEmit && !useManifest ? this.clean() : void 0;
+      const filesWereEmitted = await __privateMethod(this, _TypeScriptProject_instances, typeCheck_fn).call(this);
+      if ((filesWereEmitted || force) && !__privateGet(this, _configuration).compilerOptions.noEmit) {
+        if (eagerCleanPromise !== void 0) {
+          await eagerCleanPromise;
+        } else if (cleanEnabled && !useManifest) {
+          await this.clean();
+        }
+        if (__privateGet(this, _configuration).compilerOptions.declaration) {
+          processes.push(__privateMethod(this, _TypeScriptProject_instances, processDeclarations_fn).call(this));
+        }
+        if (!__privateGet(this, _configuration).compilerOptions.emitDeclarationOnly) {
+          processes.push(__privateMethod(this, _TypeScriptProject_instances, transpile_fn).call(this));
+        }
+      } else if (eagerCleanPromise !== void 0) {
+        await eagerCleanPromise;
+      }
+      const settled = await Promise.allSettled(processes);
+      const newOutputs = [];
+      for (const result of settled) {
+        if (result.status === "rejected") {
+          __privateMethod(this, _TypeScriptProject_instances, handleBuildError_fn).call(this, result.reason);
+          continue;
+        }
+        for (const { path } of result.value) {
+          newOutputs.push(path);
+        }
+      }
+      __privateGet(this, _fileManager).persistCache(currentFingerprint, !fingerprintMatched);
+      if (buildCache !== void 0 && newOutputs.length > 0) {
+        if (previousOutputs !== void 0) {
+          __privateMethod(this, _TypeScriptProject_instances, cleanupStaleOutputs_fn).call(this, previousOutputs, newOutputs);
+        }
+        void buildCache.saveOutputs(newOutputs).catch(() => {
+        });
+      }
+    } catch (error) {
+      __privateMethod(this, _TypeScriptProject_instances, handleBuildError_fn).call(this, error);
+    } finally {
+      if (__privateGet(this, _buildConfiguration).watch.enabled) {
+        const program = __privateGet(this, _builderProgram).getProgram();
+        if (__privateGet(this, _buildDependenciesProgram) !== program) {
+          __privateSet(this, _buildDependenciesProgram, program);
+          __privateGet(this, _buildDependencies).clear();
+          const dirWithSlash = __privateGet(this, _directory) + "/";
+          for (const { isDeclarationFile, fileName } of program.getSourceFiles()) {
+            if (!isDeclarationFile && fileName.startsWith(dirWithSlash)) {
+              __privateGet(this, _buildDependencies).add(Paths.relative(__privateGet(this, _directory), fileName));
+            }
+          }
+        }
+        if (__privateGet(this, _fileWatcher) === void 0 || __privateGet(this, _fileWatcher).isClosed()) {
+          setImmediate(() => void __privateMethod(this, _TypeScriptProject_instances, watch_fn).call(this));
+        }
+      }
+    }
+  }
+  /** Closes the project and cleans up resources. */
+  close() {
+    __privateGet(this, _fileWatcher)?.close();
+    __privateGet(this, _fileManager).close();
+    __privateSet(this, _pendingStaleOutputsCleanup, void 0);
+    __privateGet(this, _buildDependencies).clear();
+    __privateSet(this, _buildDependenciesProgram, void 0);
+    __privateGet(this, _pendingChanges).length = 0;
+  }
+};
+_init3 = __decoratorStart(null);
+_fileWatcher = new WeakMap();
+_builderProgram = new WeakMap();
+_directory = new WeakMap();
+_configuration = new WeakMap();
+_fileManager = new WeakMap();
+_buildConfiguration = new WeakMap();
+_pendingChanges = new WeakMap();
+_buildDependencies = new WeakMap();
+_pendingStaleOutputsCleanup = new WeakMap();
+_buildDependenciesProgram = new WeakMap();
+_dependencyPaths = new WeakMap();
+_TypeScriptProject_instances = new WeakSet();
+/**
+ * Removes outputs that the previous build wrote but the current build did not — e.g. renamed
+ * entry points or content-hashed chunks whose hash changed. Restricted to files under outDir
+ * for safety. Fire-and-forget: scheduled after build completion so it never inflates timings.
+ * @param previous - Project-relative paths recorded by the previous build (or undefined)
+ * @param current - Project-relative paths produced by the current build
+ */
+cleanupStaleOutputs_fn = function(previous, current) {
+  if (previous === void 0 || previous.length === 0) {
+    return;
+  }
+  const currentSet = new Set(current);
+  const outDirRel = Paths.relative(__privateGet(this, _directory), __privateGet(this, _buildConfiguration).outDir);
+  const prefix = `${outDirRel}/`;
+  const stale = [];
+  for (const path of previous) {
+    if (currentSet.has(path)) {
+      continue;
+    }
+    if (path !== outDirRel && !path.startsWith(prefix)) {
+      continue;
+    }
+    stale.push(Paths.absolute(__privateGet(this, _directory), path));
+  }
+  if (stale.length === 0) {
+    return;
+  }
+  const removals = new Array(stale.length);
+  for (let i = 0, length = stale.length; i < length; i++) {
+    removals[i] = rm2(stale[i], { force: true });
+  }
+  const cleanup = Promise.all(removals).then(() => void 0).catch(() => void 0).finally(() => {
+    if (__privateGet(this, _pendingStaleOutputsCleanup) === cleanup) {
+      __privateSet(this, _pendingStaleOutputsCleanup, void 0);
+    }
+  });
+  __privateSet(this, _pendingStaleOutputsCleanup, cleanup);
+};
+typeCheck_fn = async function() {
+  var _a;
+  await __privateGet(this, _fileManager).initialize();
+  let allDiagnostics;
+  if (__privateGet(this, _configuration).compilerOptions.noEmit) {
+    performance2.mark("diagnostics:start");
+    allDiagnostics = [
+      ...__privateGet(this, _builderProgram).getConfigFileParsingDiagnostics(),
+      ...__privateGet(this, _builderProgram).getOptionsDiagnostics(),
+      ...__privateGet(this, _builderProgram).getSyntacticDiagnostics(),
+      ...__privateGet(this, _builderProgram).getGlobalDiagnostics(),
+      ...__privateGet(this, _builderProgram).getSemanticDiagnostics(),
+      ...__privateGet(this, _configuration).compilerOptions.declaration ? __privateGet(this, _builderProgram).getDeclarationDiagnostics() : []
+    ];
+    __privateGet(this, _builderProgram).emit(void 0, __privateGet(this, _fileManager).fileWriter, void 0, true);
+  } else {
+    const { diagnostics } = __privateGet(this, _builderProgram).emit(void 0, __privateGet(this, _fileManager).fileWriter, void 0, true);
+    allDiagnostics = [...__privateGet(this, _builderProgram).getSemanticDiagnostics(), ...diagnostics];
+  }
+  if (allDiagnostics.length > 0) {
+    const unique = /* @__PURE__ */ new Map();
+    for (const diagnostic of allDiagnostics) {
+      const key = `${diagnostic.file?.fileName ?? ""}:${diagnostic.start ?? -1}:${diagnostic.code}`;
+      if (!unique.has(key)) {
+        unique.set(key, diagnostic);
+      }
+    }
+    __privateMethod(_a = _TypeScriptProject, _TypeScriptProject_static, handleTypeErrors_fn).call(_a, "Type-checking failed", Array.from(unique.values()), __privateGet(this, _directory));
+  }
+  return __privateGet(this, _fileManager).finalize() || !__privateGet(this, _configuration).compilerOptions.declaration;
+};
+transpile_fn = async function() {
+  const { build: esbuild, formatMessages } = await import("esbuild");
+  const plugins = [];
+  let iife;
+  if (__privateGet(this, _buildConfiguration).iife) {
+    iife = iifePlugin(__privateGet(this, _buildConfiguration).iife === true ? void 0 : __privateGet(this, _buildConfiguration).iife);
+    plugins.push(iife.plugin);
+  }
+  plugins.push(outputPlugin());
+  if (__privateGet(this, _buildConfiguration).noExternal.length > 0) {
+    plugins.push(externalModulesPlugin({ dependencies: await __privateGet(this, _dependencyPaths), noExternal: __privateGet(this, _buildConfiguration).noExternal }));
+  }
+  if (__privateGet(this, _configuration).compilerOptions.emitDecoratorMetadata) {
+    try {
+      const { swcDecoratorMetadataPlugin } = await import("./HDWN4W6U.js");
+      plugins.push(swcDecoratorMetadataPlugin);
+    } catch {
+      throw new ConfigurationError("emitDecoratorMetadata is enabled but @swc/core is not installed. Install it with: pnpm add -D @swc/core");
+    }
+  }
+  if (__privateGet(this, _buildConfiguration).plugins?.length) {
+    plugins.push(...await resolvePlugins(__privateGet(this, _buildConfiguration).plugins, __privateGet(this, _directory)));
+  }
+  const define = {};
+  if (__privateGet(this, _buildConfiguration).env !== void 0) {
+    const envExpansion = new RegExp(processEnvExpansionPattern, "g");
+    for (const [key, value] of Object.entries(__privateGet(this, _buildConfiguration).env)) {
+      define[`import.meta.env.${key}`] = Json.serialize(value.replace(envExpansion, (_, envVar) => process.env[envVar] ?? ""));
+    }
+  }
+  try {
+    const { warnings, errors, metafile: { outputs } } = await esbuild({
+      format,
+      plugins,
+      define,
+      write: true,
+      metafile: true,
+      treeShaking: true,
+      logLevel: "warning",
+      tsconfigRaw: {
+        compilerOptions: {
+          alwaysStrict: __privateGet(this, _configuration).compilerOptions.alwaysStrict,
+          experimentalDecorators: __privateGet(this, _configuration).compilerOptions.experimentalDecorators,
+          jsx: toJsxRenderingMode(__privateGet(this, _configuration).compilerOptions.jsx),
+          jsxFactory: __privateGet(this, _configuration).compilerOptions.jsxFactory,
+          jsxFragmentFactory: __privateGet(this, _configuration).compilerOptions.jsxFragmentFactory,
+          jsxImportSource: __privateGet(this, _configuration).compilerOptions.jsxImportSource,
+          paths: __privateGet(this, _configuration).compilerOptions.paths,
+          strict: __privateGet(this, _configuration).compilerOptions.strict,
+          target: __privateGet(this, _buildConfiguration).target,
+          useDefineForClassFields: __privateGet(this, _configuration).compilerOptions.useDefineForClassFields,
+          verbatimModuleSyntax: __privateGet(this, _configuration).compilerOptions.verbatimModuleSyntax
+        }
+      },
+      entryPoints: await __privateGet(this, _buildConfiguration).entryPoints,
+      bundle: __privateGet(this, _buildConfiguration).bundle,
+      packages: __privateGet(this, _buildConfiguration).packages,
+      platform: __privateGet(this, _buildConfiguration).platform,
+      sourcemap: __privateGet(this, _buildConfiguration).sourceMap,
+      target: __privateGet(this, _buildConfiguration).target,
+      banner: __privateGet(this, _buildConfiguration).banner,
+      footer: __privateGet(this, _buildConfiguration).footer,
+      outdir: __privateGet(this, _buildConfiguration).outDir,
+      splitting: __privateGet(this, _buildConfiguration).splitting,
+      chunkNames: "[hash]",
+      minify: __privateGet(this, _buildConfiguration).minify,
+      // Force decorator transformation even with ESNext target since Node.js doesn't support decorators yet
+      supported: { decorators: false }
+    });
+    for (const [kind, logEntryType, messages] of [[BuildMessageType.WARNING, Logger.EntryType.Warn, warnings], [BuildMessageType.ERROR, Logger.EntryType.Error, errors]]) {
+      if (messages.length > 0) {
+        for (const message of await formatMessages(messages, { kind, color: true })) {
+          Logger.log(message, logEntryType);
+        }
+      }
+      if (kind === BuildMessageType.ERROR && errors.length > 0) {
+        return [];
+      }
+    }
+    const writtenFiles = [];
+    for (const outputPath in outputs) {
+      writtenFiles.push({ path: outputPath, size: outputs[outputPath].bytes });
+    }
+    if (iife) {
+      writtenFiles.push(...iife.files);
+    }
+    return writtenFiles;
+  } catch (error) {
+    Logger.error("Transpile failed", error);
+    throw error;
+  }
+};
+watch_fn = async function() {
+  const { Watchr } = await import("@d1g1tal/watchr");
+  const targets = [];
+  for (const path of __privateGet(this, _configuration).include ?? [defaultSourceDirectory]) {
+    targets.push(Paths.absolute(__privateGet(this, _directory), path.replace(globCharacters, "")));
+  }
+  const rebuild = (event, stats, path, nextPath) => {
+    if (stats?.size === 0 && (event === Watchr.FileEvent.add || event === Watchr.FileEvent.unlink)) {
+      return;
+    }
+    if (__privateGet(this, _configuration).compilerOptions.noEmit || __privateGet(this, _buildDependencies).has(Paths.relative(__privateGet(this, _directory), path))) {
+      __privateGet(this, _pendingChanges).push({ event, path, nextPath });
+      void __privateMethod(this, _TypeScriptProject_instances, triggerRebuild_fn).call(this);
+    }
+  };
+  const pathsToIgnore = [...__privateGet(this, _configuration).exclude ?? [], ...__privateGet(this, _buildConfiguration).watch.ignore ?? []];
+  __privateSet(this, _fileWatcher, new Watchr(targets, { ...__privateGet(this, _buildConfiguration).watch, ignore: (path) => pathsToIgnore.some((p) => path.includes(`/${p}/`) || path.endsWith(`/${p}`)) }, rebuild));
+  Logger.info(`Watching for changes in: ${targets.join(", ")}`);
+};
+processDeclarations_fn = async function() {
+  if (!__privateGet(this, _buildConfiguration).bundle) {
+    return __privateGet(this, _fileManager).writeFiles(__privateGet(this, _directory));
+  }
+  return bundleDeclarations({
+    currentDirectory: __privateGet(this, _directory),
+    declarationFiles: __privateGet(this, _fileManager).getDeclarationFiles(),
+    entryPoints: __privateGet(this, _fileManager).resolveEntryPoints(await __privateGet(this, _buildConfiguration).entryPoints, __privateGet(this, _buildConfiguration).dts.entryPoints),
+    resolve: __privateGet(this, _buildConfiguration).dts.resolve,
+    external: __privateGet(this, _buildConfiguration).external ?? [],
+    noExternal: __privateGet(this, _buildConfiguration).noExternal,
+    // Extract only the minimal compiler options needed for DTS bundling from configuration
+    // All these properties are guaranteed to exist in TypeScriptConfiguration
+    compilerOptions: {
+      paths: __privateGet(this, _configuration).compilerOptions.paths,
+      rootDir: __privateGet(this, _configuration).compilerOptions.rootDir,
+      outDir: __privateGet(this, _configuration).compilerOptions.outDir,
+      moduleResolution: __privateGet(this, _configuration).compilerOptions.moduleResolution
+    },
+    // Only yield to event loop if transpile is running in parallel
+    parallelTranspile: !__privateGet(this, _configuration).compilerOptions.emitDeclarationOnly
+  });
+};
+triggerRebuild_fn = async function() {
+  if (__privateGet(this, _pendingChanges).length === 0) {
+    return;
+  }
+  Logger.clear();
+  Logger.info(`Rebuilding project: ${__privateGet(this, _pendingChanges).length} file changes detected.`);
+  const rootNames = [...__privateGet(this, _builderProgram).getProgram().getRootFileNames()];
+  for (const { event, path, nextPath } of __privateGet(this, _pendingChanges)) {
+    if (nextPath !== void 0 && (event === "rename" || event === "renameDir")) {
+      __privateGet(this, _buildDependencies).delete(Paths.relative(__privateGet(this, _directory), path));
+      __privateGet(this, _buildDependencies).add(Paths.relative(__privateGet(this, _directory), nextPath));
+      const index = rootNames.indexOf(path);
+      if (index !== -1) {
+        rootNames.splice(index, 1, nextPath);
+      }
+    } else {
+      const index = rootNames.indexOf(path);
+      if (event === "unlink" && index !== -1) {
+        rootNames.splice(index, 1);
+      } else if (event === "add" && index === -1) {
+        rootNames.push(path);
+      }
+    }
+  }
+  __privateGet(this, _pendingChanges).length = 0;
+  await __privateGet(this, _fileManager).flush();
+  __privateSet(this, _builderProgram, createIncrementalProgram({ rootNames, options: __privateGet(this, _configuration).compilerOptions, projectReferences: __privateGet(this, _configuration).projectReferences, configFileParsingDiagnostics: __privateGet(this, _configuration).configFileParsingDiagnostics }));
+  await this.build();
+};
+_TypeScriptProject_static = new WeakSet();
+resolveConfiguration_fn = function(directory, typeScriptOptions) {
+  const configResult = readConfigFile(findConfigFile(directory, sys2.fileExists) ?? "./tsconfig.json", sys2.readFile);
+  if (configResult.error !== void 0) {
+    throw new ConfigurationError(formatDiagnostics([configResult.error], diagnosticsHost));
+  }
+  const bundle = typeScriptOptions.tsbuild?.bundle ?? configResult.config.tsbuild?.bundle ?? true;
+  const platform2 = configResult.config.compilerOptions?.lib?.some(domPredicate) ? Platform.BROWSER : Platform.NODE;
+  const noExternal = typeScriptOptions.tsbuild?.noExternal ?? configResult.config.tsbuild?.noExternal ?? [];
+  const hasExplicitEntryPoints = typeScriptOptions.tsbuild?.entryPoints !== void 0 || configResult.config.tsbuild?.entryPoints !== void 0;
+  let inferredEntryPoints;
+  if (!hasExplicitEntryPoints && bundle) {
+    const packageJsonContent = sys2.readFile(Paths.join(directory, "package.json"));
+    if (packageJsonContent) {
+      try {
+        const pkgJson = JSON.parse(packageJsonContent);
+        const outDir = typeScriptOptions.compilerOptions?.outDir ?? configResult.config.compilerOptions?.outDir ?? defaultOutDirectory;
+        const hasExportFields = pkgJson.exports !== void 0 || pkgJson.bin !== void 0 || pkgJson.main !== void 0 || pkgJson.module !== void 0;
+        inferredEntryPoints = inferEntryPoints(pkgJson, outDir);
+        if (hasExportFields && inferredEntryPoints === void 0) {
+          Logger.warn(`Could not infer entry points from package.json exports (output paths do not match outDir "${outDir}"). Add explicit entryPoints to your tsconfig.json tsbuild configuration.`);
+        }
+      } catch {
+      }
+    }
+  }
+  const defaultTsbuildConfig = {
+    splitting: bundle,
+    minify: false,
+    force: false,
+    bundle,
+    sourceMap: typeScriptOptions.compilerOptions?.sourceMap ?? configResult.config.compilerOptions?.sourceMap ?? false,
+    noExternal,
+    packages: noExternal.length > 0 ? void 0 : platform2 === Platform.BROWSER ? "bundle" : "external",
+    platform: platform2,
+    dts: { resolve: platform2 !== Platform.NODE, entryPoints: bundle ? void 0 : [] },
+    watch: { enabled: false, recursive: true, ignoreInitial: true, persistent: true },
+    entryPoints: inferredEntryPoints ?? (bundle ? { [defaultEntryPoint]: defaultEntryFile } : { src: defaultSourceDirectory })
+  };
+  const baseConfig = {
+    ...configResult.config,
+    clean: typeScriptOptions.tsbuild?.clean ?? configResult.config.tsbuild?.clean ?? true,
+    tsbuild: {
+      ...defaultTsbuildConfig,
+      ...configResult.config.tsbuild,
+      ...typeScriptOptions.tsbuild,
+      dts: { ...defaultTsbuildConfig.dts, ...configResult.config.tsbuild?.dts, ...typeScriptOptions.tsbuild?.dts },
+      watch: { ...defaultTsbuildConfig.watch, ...configResult.config.tsbuild?.watch, ...typeScriptOptions.tsbuild?.watch }
+    },
+    compilerOptions: {
+      ...{ outDir: defaultOutDirectory, noEmit: false, sourceMap: false, incremental: true, tsBuildInfoFile: Paths.join(cacheDirectory, buildInfoFile), lib: [] },
+      ...configResult.config.compilerOptions,
+      ...typeScriptOptions.compilerOptions,
+      // Auto-inject 'node' only on Node platform — browser/neutral builds shouldn't pay the
+      // cost of loading @types/node (~3 MB of declarations). Users can still opt in by
+      // listing 'node' explicitly in their tsconfig types array.
+      types: (() => {
+        const typesSet = /* @__PURE__ */ new Set();
+        if (platform2 === Platform.NODE) {
+          typesSet.add("node");
+        }
+        for (const t of configResult.config.compilerOptions?.types ?? []) {
+          typesSet.add(t);
+        }
+        for (const t of typeScriptOptions.compilerOptions?.types ?? []) {
+          typesSet.add(t);
+        }
+        return Array.from(typesSet);
+      })()
+    }
+  };
+  const { options, fileNames, errors } = parseJsonConfigFileContent(baseConfig, sys2, directory);
+  return {
+    ...baseConfig,
+    compilerOptions: {
+      ...baseConfig.compilerOptions,
+      ...options,
+      ...compilerOptionOverrides
+    },
+    directory,
+    rootNames: fileNames,
+    configFileParsingDiagnostics: errors,
+    buildCache: baseConfig.compilerOptions.incremental ? new IncrementalBuildCache(directory, baseConfig.compilerOptions.tsBuildInfoFile) : void 0
+  };
+};
+getEntryPoints_fn = async function(entryPoints) {
+  const expandedEntryPoints = {};
+  for (const [name, entryPoint] of Object.entries(entryPoints)) {
+    const resolvedPath = Paths.absolute(__privateGet(this, _directory), entryPoint);
+    if (await Paths.isDirectory(resolvedPath)) {
+      for (const file of await Files.readDirectory(resolvedPath)) {
+        const filePath = Paths.join(resolvedPath, file);
+        if (await Paths.isFile(filePath)) {
+          expandedEntryPoints[Paths.parse(file).name] = filePath;
+        }
+      }
+    } else if (await Paths.isFile(resolvedPath)) {
+      expandedEntryPoints[name] = resolvedPath;
+    } else {
+      throw new ConfigurationError(`Entry point does not exist: ${entryPoint}. Add explicit entryPoints to your tsconfig.json tsbuild configuration.`);
+    }
+  }
+  return expandedEntryPoints;
+};
+/**
+ * Handles build errors by logging unexpected errors and setting appropriate exit codes.
+ * Expected build failures (TypeCheckError, BundleError) are already logged when they occur,
+ * so this method only logs unexpected errors to avoid duplicate output.
+ * @param error - The error to handle
+ */
+handleBuildError_fn = function(error) {
+  if (error instanceof ConfigurationError) {
+    Logger.error(error.message);
+    if (!__privateGet(this, _buildConfiguration).watch.enabled) {
+      process.exitCode = error.code;
+    }
+    return;
+  }
+  if (error instanceof BuildError) {
+    if (!__privateGet(this, _buildConfiguration).watch.enabled) {
+      process.exitCode = error.code;
+    }
+    return;
+  }
+  Logger.error("Build failed", error);
+  if (!__privateGet(this, _buildConfiguration).watch.enabled) {
+    process.exitCode = 1;
+  }
+};
+handleTypeErrors_fn = function(message, diagnostics, projectDirectory) {
+  Logger.error(formatDiagnosticsWithColorAndContext(diagnostics, diagnosticsHost));
+  const filesWithErrors = /* @__PURE__ */ new Map();
+  for (const { file, start } of diagnostics) {
+    if (file !== void 0) {
+      const { line } = file.getLineAndCharacterOfPosition(start ?? 0);
+      const existing = filesWithErrors.get(file.fileName);
+      if (existing !== void 0) {
+        existing.count++;
+        existing.line = Math.min(existing.line, line);
+      } else {
+        filesWithErrors.set(file.fileName, { count: 1, line });
+      }
+    }
+  }
+  const errorCount = diagnostics.length;
+  const fileCount = filesWithErrors.size;
+  const [[firstFileName, { line: firstLine }] = ["", { line: 0 }]] = filesWithErrors;
+  const relativeFirstFileName = Paths.relative(projectDirectory, firstFileName);
+  if (errorCount === 1) {
+    Logger.error(`Found 1 error in ${relativeFirstFileName}:${firstLine + 1}${sys2.newLine}`);
+  } else if (fileCount === 1) {
+    Logger.error(`Found ${errorCount} errors in the same file, starting at: ${relativeFirstFileName}:${firstLine + 1}${sys2.newLine}`);
+  } else {
+    Logger.error(`Found ${errorCount} errors in ${fileCount} files.${sys2.newLine}`);
+    Logger.error("Errors  Files");
+    for (const [fileName, { count, line }] of filesWithErrors) {
+      Logger.error(`     ${count}  ${fileName}:${line + 1}`);
+    }
+  }
+  throw new TypeCheckError(message, formatDiagnostics(diagnostics, diagnosticsHost));
+};
+__decorateElement(_init3, 1, "build", _build_dec, _TypeScriptProject);
+typeCheck_fn = __decorateElement(_init3, 17, "#typeCheck", _typeCheck_dec, _TypeScriptProject_instances, typeCheck_fn);
+transpile_fn = __decorateElement(_init3, 17, "#transpile", _transpile_dec, _TypeScriptProject_instances, transpile_fn);
+processDeclarations_fn = __decorateElement(_init3, 17, "#processDeclarations", _processDeclarations_dec, _TypeScriptProject_instances, processDeclarations_fn);
+triggerRebuild_fn = __decorateElement(_init3, 17, "#triggerRebuild", _triggerRebuild_dec, _TypeScriptProject_instances, triggerRebuild_fn);
+__privateAdd(_TypeScriptProject, _TypeScriptProject_static);
+_TypeScriptProject = __decorateElement(_init3, 0, "TypeScriptProject", _TypeScriptProject_decorators, _TypeScriptProject);
+__runInitializers(_init3, 1, _TypeScriptProject);
+var TypeScriptProject = _TypeScriptProject;
 export {
   TypeScriptProject
 };