@d1g1tal/tsbuild 1.9.0 → 1.9.2

package/dist/S3D7UW6Z.js

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