@d1g1tal/tsbuild 1.2.1 → 1.2.2

package/dist/SYNDYAJC.js

@@ -0,0 +1,2401 @@
+import {
+  BuildMessageType,
+  Encoding,
+  FileExtension,
+  Json,
+  Paths,
+  Platform,
+  __decorateElement,
+  __decoratorStart,
+  __publicField,
+  __runInitializers,
+  buildInfoFile,
+  cacheDirectory,
+  compilerOptionOverrides,
+  dataUnits,
+  defaultCleanOptions,
+  defaultDirOptions,
+  defaultEntryFile,
+  defaultEntryPoint,
+  defaultOutDirectory,
+  defaultSourceDirectory,
+  dtsCacheFile,
+  dtsCacheVersion,
+  format,
+  inlineTypePattern,
+  newLine,
+  processEnvExpansionPattern,
+  sourceScriptExtensionExpression,
+  toEsTarget,
+  toJsxRenderingMode,
+  typeMatcher
+} from "./7FPDHUPW.js";
+
+// src/errors.ts
+import { SyntaxKind } from "typescript";
+var BuildError = class extends Error {
+  /**
+   * Creates a new BuildError
+   * @param message - Error message
+   * @param code - Exit code (default: 1)
+   */
+  constructor(message, code = 1) {
+    super(message);
+    this.code = code;
+    this.name = "BuildError";
+    Error.captureStackTrace(this, this.constructor);
+  }
+};
+var TypeCheckError = class extends BuildError {
+  /**
+   * Creates a new TypeCheckError
+   * @param message - Error message
+   * @param diagnostics - Optional TypeScript diagnostics output
+   */
+  constructor(message, diagnostics) {
+    super(message, 1);
+    this.diagnostics = diagnostics;
+    this.name = "TypeCheckError";
+  }
+};
+var BundleError = class extends BuildError {
+  /**
+   * Creates a new BundleError
+   * @param message - Error message
+   */
+  constructor(message) {
+    super(message, 2);
+    this.name = "BundleError";
+  }
+};
+var ConfigurationError = class extends BuildError {
+  /**
+   * Creates a new ConfigurationError
+   * @param message - Error message
+   */
+  constructor(message) {
+    super(message, 3);
+    this.name = "ConfigurationError";
+  }
+};
+var UnsupportedSyntaxError = class extends BundleError {
+  /**
+   * Creates an instance of UnsupportedSyntaxError.
+   * @param node The node with unsupported syntax
+   * @param message The message to display (default: 'Syntax not yet supported')
+   */
+  constructor(node, message = "Syntax not yet supported") {
+    const syntaxKindName = SyntaxKind[node.kind] ?? `Unknown(${node.kind})`;
+    const nodeText = node.getText ? node.getText().slice(0, 100) : "<no text>";
+    super(`${message}: ${syntaxKindName} - "${nodeText}"`);
+    this.name = "UnsupportedSyntaxError";
+  }
+};
+var castError = (exception) => {
+  if (exception instanceof Error) {
+    return exception;
+  }
+  return new Error(typeof exception === "string" ? exception : "Unknown error");
+};
+
+// src/files.ts
+import { dirname } 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 Files = class _Files {
+  constructor() {
+  }
+  /**
+   * Check if a file exists.
+   * @param filePath The path to the file.
+   * @returns True if the file exists, false otherwise.
+   */
+  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 files and subdirectories.
+   * @param directory The path to the directory to clear.
+   */
+  static async empty(directory) {
+    if (await _Files.exists(directory)) {
+      await Promise.all((await readdir(directory)).map((file) => rm(Paths.join(directory, file), defaultCleanOptions)));
+    }
+  }
+  /**
+   * 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.
+   */
+  static normalizePath(path) {
+    return path.startsWith("/") || path.startsWith("file://") ? path : 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((resolve, reject) => brotliDecompress(buffer, (error, result) => error ? reject(error) : resolve(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((resolve, reject) => brotliCompress(buffer, (error, result) => error ? reject(error) : resolve(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/type-script-project.ts
+import { Watchr } from "@d1g1tal/watchr";
+
+// 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, open, close, replace) => {
+  return index < 0 ? `${open}${string}${close}` : `${open}${replaceClose(index, string, close, replace)}${close}`;
+};
+var filterEmpty = (open, close, replace = open, at = open.length + 1) => {
+  return (text) => text.length ? clearBleed(text.indexOf(close, at), text, open, close, replace) : "";
+};
+var generateTextFormatter = (open, close, replace) => filterEmpty(`\x1B[${open}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 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) / Math.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.
+   * @param message The message to display in the header.
+   */
+  static header(message) {
+    const innerWidth = message.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 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) {
+    const maxPathLength = files.reduce((max, { path }) => Math.max(max, path.length), 0);
+    const formatted = files.map(({ path, size }) => ({ path, ...prettyBytes(size) }));
+    const maxValueLength = formatted.reduce((max, { value }) => Math.max(max, value.length), 0);
+    const maxUnitLength = formatted.reduce((max, { unit }) => Math.max(max, unit.length), 0);
+    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/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,
+  isFunctionDeclaration,
+  isIdentifier,
+  isImportDeclaration,
+  isImportTypeNode,
+  isInterfaceDeclaration,
+  isLiteralTypeNode,
+  isModuleBlock,
+  isModuleDeclaration,
+  isNamedExports,
+  isNamespaceExport,
+  isStringLiteral,
+  isTypeAliasDeclaration,
+  isVariableStatement,
+  ModifierFlags,
+  NodeFlags,
+  SyntaxKind as SyntaxKind2,
+  getCombinedModifierFlags
+} from "typescript";
+import MagicString from "magic-string";
+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 === SyntaxKind2.DotToken || kind === SyntaxKind2.LessThanToken);
+        code.overwrite(children.find(({ kind }) => kind === SyntaxKind2.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) {
+        let sanitized = "";
+        for (let i = 0; i < fileId.length; i++) {
+          const char = fileId[i];
+          const code2 = char.charCodeAt(0);
+          if (code2 >= 97 && code2 <= 122 || code2 >= 65 && code2 <= 90 || code2 >= 48 && code2 <= 57 || code2 === 95 || code2 === 36) {
+            sanitized += char;
+          } else {
+            sanitized += "_";
+          }
+        }
+        importName = generateUniqueName(sanitized);
+        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 === SyntaxKind2.DefaultKeyword || modifier.kind === SyntaxKind2.ExportKeyword) {
+          code.remove(modifier.getStart(), modifier.getEnd() + getTrailingWhitespaceLength(modifier.getEnd(), node.getEnd()));
+        } else if (modifier.kind === SyntaxKind2.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 (isImportDeclaration(node)) {
+        if (node.importClause?.phaseModifier === SyntaxKind2.TypeKeyword) {
+          const importKeywordEnd = node.getStart() + "import".length;
+          const typeMatch = code.slice(importKeywordEnd, node.getEnd()).match(typeMatcher);
+          if (typeMatch?.index !== void 0) {
+            const typeKeywordStart = importKeywordEnd + typeMatch.index;
+            const typeKeywordEnd = typeKeywordStart + "type".length;
+            code.remove(typeKeywordStart, typeKeywordEnd + getTrailingWhitespaceLength(typeKeywordEnd, node.getEnd()));
+          }
+        } else {
+          inlineTypePattern.lastIndex = 0;
+          let match2;
+          const replacements = [];
+          while ((match2 = inlineTypePattern.exec(code.slice(node.getStart(), node.getEnd()))) !== null) {
+            const typeKeywordStart = node.getStart() + match2.index + match2[1].length;
+            const typeKeywordEnd = typeKeywordStart + "type".length;
+            replacements.push({ start: typeKeywordStart, end: typeKeywordEnd + getTrailingWhitespaceLength(typeKeywordEnd, node.getEnd()) });
+          }
+          for (let i = replacements.length - 1; i >= 0; i--) {
+            code.remove(replacements[i].start, replacements[i].end);
+          }
+        }
+      } else 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 === SyntaxKind2.DefaultKeyword)) {
+              defaultExport = nameText;
+            } else if (node.modifiers?.some((modifier) => modifier.kind === SyntaxKind2.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"} `;
+        let commaPos = 0;
+        for (const declarationNode of node.declarationList.getChildren().find((n) => n.kind === SyntaxKind2.SyntaxList)?.getChildren() ?? []) {
+          if (declarationNode.kind === SyntaxKind2.CommaToken) {
+            code.remove(commaPos = declarationNode.getStart(), declarationNode.getEnd());
+          } else if (commaPos) {
+            code.appendLeft(commaPos, `;${newLine}`);
+            const start = declarationNode.getFullStart();
+            const slice = code.slice(start, declarationNode.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 === SyntaxKind2.ClassKeyword || node2.kind === SyntaxKind2.FunctionKeyword);
+        const token = children[index];
+        const nextToken = children[index + 1];
+        if (SyntaxKind2.FirstPunctuation <= nextToken.kind && nextToken.kind <= SyntaxKind2.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 (isModuleDeclaration(node) && node.body && isModuleBlock(node.body)) {
+        for (const bodyStatement of node.body.statements) {
+          if (isExportDeclaration(bodyStatement) && bodyStatement.exportClause && !isNamespaceExport(bodyStatement.exportClause)) {
+            for (const { name, propertyName } of bodyStatement.exportClause.elements) {
+              if (propertyName && isIdentifier(propertyName) && isIdentifier(name) && propertyName.getText() === name.getText()) {
+                magic.remove(propertyName.getStart(), 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,
+  isNamedExports as isNamedExports2,
+  isIdentifier as isIdentifier2,
+  isNamespaceImport,
+  isQualifiedName,
+  resolveModuleName,
+  isExportAssignment,
+  forEachChild as forEachChild2
+} from "typescript";
+var nodeModules = "/node_modules/";
+var importPattern = /^import\s*(?:type\s*)?\{\s*([^}]+)\s*\}\s*from\s*['"]([^'"]+)['"]\s*;?\s*$/;
+var typePrefixPattern = /^type:/;
+function mergeImports(imports) {
+  const moduleImports = /* @__PURE__ */ new Map();
+  const nonMergeableImports = [];
+  for (const importStatement of imports) {
+    const match2 = importPattern.exec(importStatement);
+    if (match2) {
+      const [, namesString, moduleSpecifier] = match2;
+      const isType = importStatement.includes("import type");
+      const key = `${isType ? "type:" : ""}${moduleSpecifier}`;
+      if (!moduleImports.has(key)) {
+        moduleImports.set(key, { names: /* @__PURE__ */ new Set(), isType });
+      }
+      const entry = moduleImports.get(key);
+      for (const name of namesString.split(",")) {
+        entry.names.add(name.trim());
+      }
+    } else {
+      nonMergeableImports.push(importStatement);
+    }
+  }
+  const result = [];
+  for (const [key, { names, isType }] of moduleImports) {
+    result.push(`${isType ? "import type" : "import"} { ${[...names].sort().join(", ")} } from "${key.replace(typePrefixPattern, "")}";`);
+  }
+  result.push(...[...new Set(nonMergeableImports)]);
+  return result;
+}
+var DeclarationBundler = class {
+  /** 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();
+  /** 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();
+  // 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;
+  }
+  /**
+   * 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();
+  }
+  /**
+   * 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;
+  }
+  /**
+   * Extract import statements from declaration file content using AST
+   * Handles: import { X } from 'module', import * as X from 'module', export { X } from 'module'
+   * @param sourceFile - The parsed source file AST
+   * @returns Array of module specifiers that are imported
+   */
+  extractImports({ statements }) {
+    const imports = [];
+    for (const statement of statements) {
+      if ((isImportDeclaration2(statement) || isExportDeclaration2(statement)) && statement.moduleSpecifier) {
+        imports.push(statement.moduleSpecifier.text);
+      }
+    }
+    return imports;
+  }
+  /**
+   * Check if a module specifier matches a pattern list
+   * @param moduleSpecifier - The module specifier to check
+   * @param patterns - Array of patterns to match against
+   * @returns True if the module matches any pattern
+   */
+  matchesPattern(moduleSpecifier, patterns) {
+    return patterns.some((pattern) => {
+      return typeof pattern === "string" ? moduleSpecifier === pattern || moduleSpecifier.startsWith(`${pattern}/`) : pattern.test(moduleSpecifier);
+    });
+  }
+  /**
+   * Check if a module specifier matches explicit external patterns
+   * @param moduleSpecifier - The module specifier to check
+   * @returns True if the module should be treated as external
+   */
+  isExternal(moduleSpecifier) {
+    return this.matchesPattern(moduleSpecifier, this.options.external);
+  }
+  /**
+   * 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;
+      const sourceFile = createSourceFile(path, code, ScriptTarget.Latest, true);
+      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 = [];
+      for (const specifier of this.extractImports(sourceFile)) {
+        if (this.isExternal(specifier)) {
+          continue;
+        }
+        const resolvedPath = this.resolveModule(specifier, path);
+        if (resolvedPath?.includes(nodeModules) && !this.matchesPattern(specifier, this.options.noExternal)) {
+          continue;
+        }
+        if (resolvedPath && (this.declarationFiles.has(resolvedPath) || this.externalDeclarationFiles.has(resolvedPath))) {
+          module.imports.add(resolvedPath);
+          bundledSpecs.push(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}`);
+        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);
+        }
+        collectNestedIdentifiers(statement.getChildren());
+      }
+    }
+    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 - Array 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, ...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.isExternal(moduleSpecifier) || !bundledImportPaths.includes(moduleSpecifier)) {
+          externalImports.push(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);
+      }
+    }
+    if (moduleRenames.size > 0) {
+      const visit = (node) => {
+        if (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);
+        }
+      }
+    }
+    if (bundledNamespaceAliases.size > 0) {
+      const visitQualified = (node) => {
+        if (isQualifiedName(node) && isIdentifier2(node.left) && bundledNamespaceAliases.has(node.left.text)) {
+          magic.remove(node.left.getStart(), node.right.getStart());
+        }
+        forEachChild2(node, visitQualified);
+      };
+      forEachChild2(sourceFile, visitQualified);
+    }
+    const finalValueExports = [...new Set(valueExports.map(exportsMapper))];
+    const valueExportsSet = new Set(finalValueExports);
+    const finalTypeExports = [...new Set(typeExports.map(exportsMapper).filter((t) => !valueExportsSet.has(t)))];
+    return { code: magic.toString(), externalImports, typeExports: finalTypeExports, valueExports: finalValueExports };
+  }
+  /**
+   * 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 allTypeReferences = [];
+    const allFileReferences = [];
+    const allExternalImports = [];
+    const allTypeExports = [];
+    const allValueExports = [];
+    const codeBlocks = [];
+    const allDeclarations = /* @__PURE__ */ new Set();
+    const declarationSources = /* @__PURE__ */ new Map();
+    const renameMap = /* @__PURE__ */ new Map();
+    for (const { path, identifiers } of sortedModules) {
+      for (const name of identifiers.types) {
+        if (!declarationSources.has(name)) {
+          declarationSources.set(name, /* @__PURE__ */ new Set());
+        }
+        declarationSources.get(name).add(path);
+      }
+      for (const name of identifiers.values) {
+        if (!declarationSources.has(name)) {
+          declarationSources.set(name, /* @__PURE__ */ new Set());
+        }
+        declarationSources.get(name).add(path);
+      }
+    }
+    for (const [name, sourcesSet] of declarationSources) {
+      if (sourcesSet.size > 1) {
+        const sources = Array.from(sourcesSet);
+        let suffix = 1;
+        for (const modulePath of sources.slice(1)) {
+          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 } of sortedModules) {
+      allTypeReferences.push(...typeReferences);
+      allFileReferences.push(...fileReferences);
+      const bundledForThisModule = bundledSpecifiers.get(path) || [];
+      const { code: strippedCode, externalImports, typeExports, valueExports } = this.stripImportsExports(code, sourceFile, identifiers, bundledForThisModule, renameMap, path);
+      allExternalImports.push(...externalImports);
+      if (!path.includes(nodeModules)) {
+        allValueExports.push(...valueExports);
+        allTypeExports.push(...typeExports);
+        for (const name of identifiers.types) {
+          allDeclarations.add(name);
+        }
+        for (const name of identifiers.values) {
+          allDeclarations.add(name);
+        }
+      }
+      if (strippedCode.trim().length > 0) {
+        codeBlocks.push(strippedCode.trim());
+      }
+    }
+    const uniqueTypeReferences = [...new Set(allTypeReferences)];
+    const uniqueFileReferences = [...new Set(allFileReferences)];
+    const mergedExternalImports = mergeImports(allExternalImports);
+    const finalValueExports = [...new Set(allValueExports)];
+    const finalValueExportsSet = new Set(finalValueExports);
+    const finalTypeExports = [...new Set(allTypeExports.filter((typeExport) => !finalValueExportsSet.has(typeExport)))];
+    const outputParts = [];
+    if (uniqueFileReferences.length > 0) {
+      outputParts.push(...uniqueFileReferences.map((ref) => `/// <reference path="${ref}" />`), "");
+    }
+    if (uniqueTypeReferences.length > 0) {
+      outputParts.push(...uniqueTypeReferences.map((ref) => `/// <reference types="${ref}" />`), "");
+    }
+    if (mergedExternalImports.length > 0) {
+      outputParts.push(...mergedExternalImports, "");
+    }
+    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 };
+  }
+  /**
+   * Extract exported names from a processed source file
+   * @param processedSourceFile - The processed source file
+   * @returns Array of exported names
+   */
+  getModuleExports(processedSourceFile) {
+    const exports = [];
+    for (const statement of processedSourceFile.statements) {
+      if (isExportDeclaration2(statement) && statement.exportClause && isNamedExports2(statement.exportClause)) {
+        for (const element of statement.exportClause.elements) {
+          exports.push(element.name.text);
+        }
+      }
+    }
+    return exports;
+  }
+  /**
+   * 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);
+    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)) {
+      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}`
+      );
+    }
+    return dtsEntryPoint;
+  }
+};
+async function bundleDeclarations(options) {
+  await mkdir2(options.compilerOptions.outDir, defaultDirOptions);
+  const dtsBundler = new DeclarationBundler(options);
+  const bundleTasks = Object.entries(options.entryPoints).map(async ([entryName, entryPoint]) => {
+    const outPath = Paths.join(options.compilerOptions.outDir, `${entryName}.d.ts`);
+    const content = dtsBundler.bundle(entryPoint);
+    await writeFile2(outPath, content, Encoding.utf8);
+    return { path: Paths.relative(options.currentDirectory, outPath), size: content.length };
+  });
+  const results = await Promise.all(bundleTasks);
+  dtsBundler.clearExternalFiles();
+  return results;
+}
+
+// src/plugins/output.ts
+import { extname } from "node:path";
+var FileMode = { READ_WRITE: 438, READ_WRITE_EXECUTE: 493 };
+async function fileMapper({ path, contents }) {
+  const mode = extname(path) === FileExtension.JS && contents[0] === 35 && contents[1] === 33 ? FileMode.READ_WRITE_EXECUTE : FileMode.READ_WRITE;
+  return Files.write(path, contents, { mode });
+}
+var outputPlugin = () => {
+  return {
+    name: "esbuild:output-plugin",
+    /**
+     * Configures the esbuild build instance to write output files to disk
+     * @param build The esbuild build instance
+     */
+    setup(build) {
+      build.onEnd(async ({ outputFiles }) => void await Promise.all(outputFiles.map(fileMapper)));
+    }
+  };
+};
+
+// src/plugins/external-modules.ts
+var match = (id, patterns) => {
+  return patterns.some((pattern) => pattern instanceof RegExp ? pattern.test(id) : id === pattern || id.startsWith(`${pattern}/`));
+};
+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;
+      build.onResolve({ filter: /.*/ }, ({ path }) => {
+        switch (true) {
+          case match(path, noExternal):
+            return;
+          case match(path, dependencies):
+            return { external };
+          case !Paths.isPath(path):
+            return { path, external };
+          default:
+            return;
+        }
+      });
+    }
+  };
+};
+
+// 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 console exit (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 {
+    /**
+     * Creates an instance and registers it with the process manager.
+     * @param args Arguments to pass to the original constructor.
+     */
+    // 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 _PerformanceLogger_decorators, _init;
+_PerformanceLogger_decorators = [closeOnExit];
+var _PerformanceLogger = class _PerformanceLogger {
+  performanceObserver;
+  constructor() {
+    this.performanceObserver = new PerformanceObserver((list) => {
+      for (const { name, duration, detail: { message, result = [] } } 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 (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 log the result of the method.
+   * @returns A Stage 3 method decorator that measures the performance of the method it decorates.
+   */
+  measure(message, logResult = false) {
+    const _measure = (propertyKey, result, options) => {
+      if (logResult) {
+        options.detail.result = result;
+      }
+      ({ 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((resolve, reject) => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+          _DebounceManager.timers.delete(timeoutId);
+        }
+        if (pendingResolve) {
+          pendingResolve(void 0);
+        }
+        pendingResolve = resolve;
+        timeoutId = setTimeout(() => {
+          if (timeoutId) {
+            _DebounceManager.timers.delete(timeoutId);
+          }
+          try {
+            resolve(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 { sys as sys2, createSourceFile as createSourceFile2, ScriptTarget as ScriptTarget2 } from "typescript";
+var FileManager = class {
+  hasEmittedFiles = false;
+  declarationFiles = /* @__PURE__ */ new Map();
+  cache;
+  /**
+   * 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() {
+    this.hasEmittedFiles = false;
+    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 = await manager.finalize();
+   * if (hasEmitted) { // Continue with build }
+   * ```
+   */
+  async finalize() {
+    if (this.cache && this.hasEmittedFiles) {
+      await this.cache.save(this.declarationFiles);
+    }
+    return this.cache === void 0 || this.hasEmittedFiles;
+  }
+  /**
+   * 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) {
+      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 = {};
+    for (const [name, path] of Object.entries(projectEntryPoints)) {
+      if (dtsEntryPoints.includes(name)) {
+        result[name] = path;
+      }
+    }
+    return result;
+  }
+  /**
+   * Closes the file manager and releases resources.
+   * Clears all stored declaration files.
+   */
+  close() {
+    this.declarationFiles.clear();
+  }
+  /**
+   * 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) {
+    await Files.write(filePath, content);
+    return { path: Paths.relative(projectDirectory, filePath), size: content.length };
+  }
+  /**
+   * Function that intercepts file writes during TypeScript emit.
+   * Declaration files are pre-processed and stored in memory, while .tsbuildinfo is written to disk.
+   * Pre-processing happens immediately so the cache stores ready-to-use declarations.
+   * @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)) {
+      sys2.writeFile(filePath, text);
+    } else {
+      this.declarationFiles.set(filePath, DeclarationProcessor.preProcess(createSourceFile2(filePath, text, ScriptTarget2.Latest, true)));
+    }
+    if (!this.hasEmittedFiles) {
+      this.hasEmittedFiles = true;
+    }
+  };
+  /**
+   * Custom inspection method for better type representation.
+   * @returns The string 'FileManager'
+   * @internal
+   */
+  get [Symbol.toStringTag]() {
+    return "FileManager";
+  }
+};
+
+// src/incremental-build-cache.ts
+import { rmSync } from "node:fs";
+var IncrementalBuildCache = class {
+  buildInfoPath;
+  cacheDirectoryPath;
+  cacheFilePath;
+  /** Pre-loading promise started in constructor for async cache restoration */
+  cacheLoaded;
+  /** Set to true when invalidate() is called to prevent stale cache from being restored */
+  invalidated = false;
+  /**
+   * 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.cacheLoaded = this.loadCache();
+  }
+  /**
+   * 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);
+      return cache.version === dtsCacheVersion ? cache : void 0;
+    } 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 Object.entries(cache.files)) {
+      target.set(fileName, content);
+    }
+  }
+  /**
+   * Saves declaration files to the compressed cache file with version information.
+   * Uses V8 serialization for faster read performance on subsequent builds.
+   * @param source - The declaration files to cache
+   */
+  async save(source) {
+    await Files.writeCompressed(this.cacheFilePath, { version: dtsCacheVersion, files: Object.fromEntries(source) });
+  }
+  /** 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;
+  }
+  /**
+   * Custom inspection tag for type.
+   * @returns The string 'IncrementalBuildCache'
+   */
+  get [Symbol.toStringTag]() {
+    return "IncrementalBuildCache";
+  }
+};
+
+// src/entry-points.ts
+var importConditions = ["import", "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)) {
+      const stem = relativePortion.slice(0, -outExt.length);
+      return `./${sourceDir}/${stem}${srcExt}`;
+    }
+  }
+  return void 0;
+}
+function resolveConditionalExport(exportValue) {
+  if (typeof exportValue === "string") {
+    return exportValue;
+  }
+  for (const condition of importConditions) {
+    const value = exportValue[condition];
+    if (typeof value === "string") {
+      return value;
+    }
+  }
+  return void 0;
+}
+function subpathToEntryName(subpath, packageName) {
+  if (subpath === ".") {
+    return packageName !== void 0 ? unscope(packageName) : "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;
+        }
+      }
+    }
+  }
+  if (Object.keys(entryPoints).length === 0) {
+    const legacyPath = packageJson.module ?? packageJson.main;
+    if (legacyPath !== void 0) {
+      const sourcePath = outputToSourcePath(legacyPath, outDir, sourceDir);
+      if (sourcePath) {
+        entryPoints["index"] = sourcePath;
+      }
+    }
+  }
+  return Object.keys(entryPoints).length > 0 ? entryPoints : void 0;
+}
+
+// src/type-script-project.ts
+import { build as esbuild, formatMessages } from "esbuild";
+import { sys as sys3, createIncrementalProgram, formatDiagnostics, formatDiagnosticsWithColorAndContext, parseJsonConfigFileContent, readConfigFile, findConfigFile } from "typescript";
+var globCharacters = /[*?\\[\]!].*$/;
+var domPredicate = (lib) => lib.toUpperCase() === "DOM";
+var diagnosticsHost = { getNewLine: () => sys3.newLine, getCurrentDirectory: sys3.getCurrentDirectory, getCanonicalFileName: (fileName) => fileName };
+var _triggerRebuild_dec, _processDeclarations_dec, _transpile_dec, _typeCheck_dec, _build_dec, _TypeScriptProject_decorators, _init3;
+_TypeScriptProject_decorators = [closeOnExit], _build_dec = [measure("Build")], _typeCheck_dec = [measure("Type-checking")], _transpile_dec = [measure("Transpile", true)], _processDeclarations_dec = [measure("Process 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 = sys3.getCurrentDirectory(), options = {}) {
+    __runInitializers(_init3, 5, this);
+    __publicField(this, "fileWatcher");
+    __publicField(this, "builderProgram");
+    __publicField(this, "directory");
+    __publicField(this, "configuration");
+    __publicField(this, "fileManager");
+    __publicField(this, "buildConfiguration");
+    __publicField(this, "pendingChanges", []);
+    __publicField(this, "buildDependencies", /* @__PURE__ */ new Set());
+    __publicField(this, "dependencyPaths");
+    this.directory = Paths.absolute(directory);
+    this.configuration = _TypeScriptProject.resolveConfiguration(this.directory, options);
+    const { buildCache, rootNames, projectReferences, configFileParsingDiagnostics, tsbuild: { entryPoints, ...tsbuildOptions }, compilerOptions: { target, outDir } } = this.configuration;
+    if (buildCache !== void 0 && options.clearCache) {
+      buildCache.invalidate();
+    }
+    this.fileManager = new FileManager(buildCache);
+    this.builderProgram = createIncrementalProgram({ rootNames, options: this.configuration.compilerOptions, projectReferences, configFileParsingDiagnostics });
+    const entryPointsPromise = this.getEntryPoints(entryPoints);
+    entryPointsPromise.catch(() => {
+    });
+    this.buildConfiguration = { entryPoints: entryPointsPromise, target: toEsTarget(target), outDir, ...tsbuildOptions };
+  }
+  /**
+   * Cleans the output directory
+   * @returns A promise that resolves when the cleaning is complete.
+   */
+  async clean() {
+    return Files.empty(this.buildConfiguration.outDir);
+  }
+  async build() {
+    Logger.header(`\u{1F680} tsbuild v${"1.2.2"}${this.configuration.compilerOptions.incremental ? " [incremental]" : ""}`);
+    try {
+      const processes = [];
+      const filesWereEmitted = await this.typeCheck();
+      if ((filesWereEmitted || this.configuration.tsbuild.force) && !this.configuration.compilerOptions.noEmit) {
+        if (this.configuration.clean) {
+          await this.clean();
+        }
+        if (this.configuration.compilerOptions.declaration) {
+          processes.push(this.processDeclarations());
+        }
+        if (!this.configuration.compilerOptions.emitDeclarationOnly) {
+          processes.push(this.transpile());
+        }
+      }
+      for (const result of await Promise.allSettled(processes)) {
+        if (result.status === "rejected") {
+          this.handleBuildError(result.reason);
+        }
+      }
+    } catch (error) {
+      this.handleBuildError(error);
+    } finally {
+      if (this.buildConfiguration.watch.enabled) {
+        this.buildDependencies.clear();
+        for (const { isDeclarationFile, fileName } of this.builderProgram.getProgram().getSourceFiles()) {
+          if (!isDeclarationFile) {
+            this.buildDependencies.add(Paths.relative(this.directory, fileName));
+          }
+        }
+        if (this.fileWatcher === void 0 || this.fileWatcher.isClosed()) {
+          setImmediate(() => this.watch());
+        }
+      }
+    }
+  }
+  async typeCheck() {
+    await this.fileManager.initialize();
+    const { diagnostics } = this.builderProgram.emit(void 0, this.fileManager.fileWriter, void 0, true);
+    if (diagnostics.length > 0) {
+      _TypeScriptProject.handleTypeErrors("Type-checking failed", diagnostics, this.directory);
+    }
+    return this.fileManager.finalize();
+  }
+  async transpile() {
+    const plugins = [outputPlugin()];
+    if (this.buildConfiguration.noExternal.length > 0) {
+      plugins.push(externalModulesPlugin({ dependencies: await this.getProjectDependencyPaths(), noExternal: this.buildConfiguration.noExternal }));
+    }
+    if (this.configuration.compilerOptions.emitDecoratorMetadata) {
+      try {
+        const { swcDecoratorMetadataPlugin } = await import("./DSHNVGWV.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 (this.buildConfiguration.plugins?.length) {
+      plugins.push(...this.buildConfiguration.plugins);
+    }
+    const define = {};
+    if (this.buildConfiguration.env !== void 0) {
+      for (const [key, value] of Object.entries(this.buildConfiguration.env)) {
+        processEnvExpansionPattern.lastIndex = 0;
+        define[`import.meta.env.${key}`] = Json.serialize(value.replace(processEnvExpansionPattern, (_, envVar) => process.env[envVar] ?? ""));
+      }
+    }
+    try {
+      const { warnings, errors, metafile: { outputs } } = await esbuild({
+        format,
+        plugins,
+        define,
+        write: false,
+        metafile: true,
+        treeShaking: true,
+        logLevel: "warning",
+        tsconfigRaw: {
+          compilerOptions: {
+            alwaysStrict: this.configuration.compilerOptions.alwaysStrict,
+            experimentalDecorators: this.configuration.compilerOptions.experimentalDecorators,
+            jsx: toJsxRenderingMode(this.configuration.compilerOptions.jsx),
+            jsxFactory: this.configuration.compilerOptions.jsxFactory,
+            jsxFragmentFactory: this.configuration.compilerOptions.jsxFragmentFactory,
+            jsxImportSource: this.configuration.compilerOptions.jsxImportSource,
+            paths: this.configuration.compilerOptions.paths,
+            strict: this.configuration.compilerOptions.strict,
+            target: this.buildConfiguration.target,
+            useDefineForClassFields: this.configuration.compilerOptions.useDefineForClassFields,
+            verbatimModuleSyntax: this.configuration.compilerOptions.verbatimModuleSyntax
+          }
+        },
+        entryPoints: await this.buildConfiguration.entryPoints,
+        bundle: this.buildConfiguration.bundle,
+        packages: this.buildConfiguration.packages,
+        platform: this.buildConfiguration.platform,
+        sourcemap: this.buildConfiguration.sourceMap,
+        target: this.buildConfiguration.target,
+        banner: this.buildConfiguration.banner,
+        footer: this.buildConfiguration.footer,
+        outdir: this.buildConfiguration.outDir,
+        splitting: this.buildConfiguration.splitting,
+        chunkNames: "[hash]",
+        minify: 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]]) {
+        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, { bytes }] of Object.entries(outputs)) {
+        writtenFiles.push({ path: outputPath, size: bytes });
+      }
+      return writtenFiles;
+    } catch (error) {
+      Logger.error("Transpile failed", error);
+      throw error;
+    }
+  }
+  /**
+   * Watches for changes in the project files and rebuilds the project when changes are detected.
+   */
+  watch() {
+    const targets = [];
+    for (const path of this.configuration.include ?? [defaultSourceDirectory]) {
+      targets.push(Paths.absolute(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 (this.configuration.compilerOptions.noEmit || this.buildDependencies.has(Paths.relative(this.directory, path))) {
+        this.pendingChanges.push({ event, path, nextPath });
+        void this.triggerRebuild();
+      }
+    };
+    const pathsToIgnore = [...this.configuration.exclude ?? [], ...this.buildConfiguration.watch.ignore ?? []];
+    this.fileWatcher = new Watchr(targets, { ...this.buildConfiguration.watch, ignore: (path) => pathsToIgnore.some((p) => path.lastIndexOf(p) > -1) }, rebuild);
+    Logger.info(`Watching for changes in: ${targets.join(", ")}`);
+  }
+  /** Closes the project and cleans up resources. */
+  close() {
+    this.fileWatcher?.close();
+    this.fileManager.close();
+    this.buildDependencies.clear();
+    this.pendingChanges.length = 0;
+  }
+  async processDeclarations() {
+    if (!this.buildConfiguration.bundle) {
+      return this.fileManager.writeFiles(this.directory);
+    }
+    return bundleDeclarations({
+      currentDirectory: this.directory,
+      declarationFiles: this.fileManager.getDeclarationFiles(),
+      entryPoints: this.fileManager.resolveEntryPoints(await this.buildConfiguration.entryPoints, this.buildConfiguration.dts.entryPoints),
+      resolve: this.buildConfiguration.dts.resolve,
+      external: this.buildConfiguration.external ?? [],
+      noExternal: 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: this.configuration.compilerOptions.paths,
+        rootDir: this.configuration.compilerOptions.rootDir,
+        outDir: this.configuration.compilerOptions.outDir,
+        moduleResolution: this.configuration.compilerOptions.moduleResolution
+      }
+    });
+  }
+  async triggerRebuild() {
+    if (this.pendingChanges.length === 0) {
+      return;
+    }
+    Logger.clear();
+    Logger.info(`Rebuilding project: ${this.pendingChanges.length} file changes detected.`);
+    const rootNames = [...this.builderProgram.getProgram().getRootFileNames()];
+    for (const { event, path, nextPath } of this.pendingChanges) {
+      if (nextPath !== void 0 && (event === Watchr.FileEvent.rename || event === Watchr.DirectoryEvent.rename)) {
+        this.buildDependencies.delete(Paths.relative(this.directory, path));
+        this.buildDependencies.add(Paths.relative(this.directory, nextPath));
+        const index = rootNames.indexOf(path);
+        if (index !== -1) {
+          rootNames.splice(index, 1, nextPath);
+        }
+      } else {
+        const index = rootNames.indexOf(path);
+        if (event === Watchr.FileEvent.unlink && index !== -1) {
+          rootNames.splice(index, 1);
+        } else if (event === Watchr.FileEvent.add && index === -1) {
+          rootNames.push(path);
+        }
+      }
+    }
+    this.pendingChanges.length = 0;
+    this.builderProgram = createIncrementalProgram({ rootNames, options: this.configuration.compilerOptions, projectReferences: this.configuration.projectReferences, configFileParsingDiagnostics: this.configuration.configFileParsingDiagnostics });
+    await this.build();
+  }
+  /**
+   * Resolves configuration by merging options with tsconfig.json.
+   * @param directory - Project root directory
+   * @param typeScriptOptions - Partial TypeScript options to merge
+   * @returns Resolved configuration and TypeScript parser results
+   */
+  static resolveConfiguration(directory, typeScriptOptions) {
+    const configResult = readConfigFile(findConfigFile(directory, sys3.fileExists) ?? "./tsconfig.json", sys3.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 = sys3.readFile(Paths.join(directory, "package.json"));
+      if (packageJsonContent) {
+        try {
+          const pkgJson = JSON.parse(packageJsonContent);
+          const outDir = typeScriptOptions.compilerOptions?.outDir ?? configResult.config.compilerOptions?.outDir ?? defaultOutDirectory;
+          inferredEntryPoints = inferEntryPoints(pkgJson, outDir);
+        } 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
+      }
+    };
+    const { options, fileNames, errors } = parseJsonConfigFileContent(baseConfig, sys3, 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
+    };
+  }
+  /**
+   * Gets the entry points for the project.
+   * @param entryPoints - The entry points to get.
+   * @returns A promise that resolves to the entry points.
+   */
+  async getEntryPoints(entryPoints) {
+    const expandedEntryPoints = {};
+    for (const [name, entryPoint] of Object.entries(entryPoints)) {
+      const resolvedPath = Paths.absolute(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}`);
+      }
+    }
+    return expandedEntryPoints;
+  }
+  /**
+   * Gets the project dependency paths, cached after first call.
+   * Reads package.json and caches it for reuse.
+   * @returns A promise that resolves to an array of project dependency paths.
+   */
+  getProjectDependencyPaths() {
+    return this.dependencyPaths ??= Files.read(Paths.absolute(this.directory, "package.json")).then((content) => {
+      const { dependencies = {}, peerDependencies = {} } = Json.parse(content);
+      return [.../* @__PURE__ */ new Set([...Object.keys(dependencies), ...Object.keys(peerDependencies)])];
+    });
+  }
+  /**
+   * 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(error) {
+    if (error instanceof ConfigurationError) {
+      Logger.error(error.message);
+      if (!this.buildConfiguration.watch.enabled) {
+        process.exitCode = error.code;
+      }
+      return;
+    }
+    if (error instanceof BuildError) {
+      if (!this.buildConfiguration.watch.enabled) {
+        process.exitCode = error.code;
+      }
+      return;
+    }
+    Logger.error("Build failed", error);
+    if (!this.buildConfiguration.watch.enabled) {
+      process.exitCode = 1;
+    }
+  }
+  /**
+   * Handles type errors in the project.
+   * @param message - The message to display.
+   * @param diagnostics - The diagnostics to handle.
+   * @param projectDirectory - The project directory.
+   */
+  static handleTypeErrors(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}${sys3.newLine}`);
+    } else if (fileCount === 1) {
+      Logger.error(`Found ${errorCount} errors in the same file, starting at: ${relativeFirstFileName}:${firstLine + 1}${sys3.newLine}`);
+    } else {
+      Logger.error(`Found ${errorCount} errors in ${fileCount} files.${sys3.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));
+  }
+};
+_init3 = __decoratorStart(null);
+__decorateElement(_init3, 1, "build", _build_dec, _TypeScriptProject);
+__decorateElement(_init3, 1, "typeCheck", _typeCheck_dec, _TypeScriptProject);
+__decorateElement(_init3, 1, "transpile", _transpile_dec, _TypeScriptProject);
+__decorateElement(_init3, 1, "processDeclarations", _processDeclarations_dec, _TypeScriptProject);
+__decorateElement(_init3, 1, "triggerRebuild", _triggerRebuild_dec, _TypeScriptProject);
+_TypeScriptProject = __decorateElement(_init3, 0, "TypeScriptProject", _TypeScriptProject_decorators, _TypeScriptProject);
+__runInitializers(_init3, 1, _TypeScriptProject);
+var TypeScriptProject = _TypeScriptProject;
+
+export {
+  BuildError,
+  TypeScriptProject
+};