@d1g1tal/tsbuild 1.8.2 → 1.8.4

package/CHANGELOG.md

@@ -1,3 +1,47 @@
+## [1.8.4](https://github.com/D1g1talEntr0py/tsbuild/compare/v1.8.3...v1.8.4) (2026-04-12)
+
+### Performance Improvements
+
+* **build:** delegate file writing to esbuild (84a64e212a9dc7f309bb2dcbe74ffa990c06065b)
+- Enables esbuild write option for direct-to-disk transpilation output
+- Moves relative module specifier rewriting logic to FileManager
+- Simplifies output plugin to only manage shebang executable permissions via chmod
+- Adapts IIFE plugin to process metafile outputs instead of in-memory files
+- Updates tests and mock helpers to align with file writing capabilities
+
+* **dts:** optimize declaration bundler module resolution and graph traversal (59606c0ccfe54ac74068fe6ab8f6d26d7edd97b6)
+- Optimizes module pattern matching by using Sets and RegEx arrays instead of iteration
+- Refactors bundled specifiers state to use ReadonlySet for O(1) lookups
+- Simplifies deduplication of non-mergeable imports using Sets
+- Yields the event loop before cpu-intensive declaration bundling to prevent I/O blocking
+
+
+### Miscellaneous Chores
+
+* **perf:** add performance baseline documentation and benchmark script (3e897aaa7a35022b8d9ec1d4222448973eb57a2b)
+- Adds documentation detailing performance baselines and architectures
+- Introduces performance measurements log
+- Adds quick reference for performance monitoring
+- Introduces new benchmark script for running automated metrics collection
+- Registers bench script in package.json
+
+## [1.8.3](https://github.com/D1g1talEntr0py/tsbuild/compare/v1.8.2...v1.8.3) (2026-04-11)
+
+### Performance Improvements
+
+* **core:** optimize build performance and decrease startup time (5cc35a8e0c6acc45dff38f6186e9f5b8f59ee8bf)
+- use sets instead of arrays for faster lookups
+- replace string concatenation with array joins
+- replace object.keys with for-in loops
+- cache regex patterns and avoid repeated compilations
+- dynamically import esbuild and watchr to reduce startup time
+- replace map/reduce chains with single loops for better performance
+
+
+### Miscellaneous Chores
+
+* **deps:** update dependency @types/node to ^25.6.0 (a99b720acf5c2d3ed4116605e66fbd0f0174259f)
+
 ## [1.8.2](https://github.com/D1g1talEntr0py/tsbuild/compare/v1.8.1...v1.8.2) (2026-04-09)
 
 ### Bug Fixes

package/dist/{ALZQNZZK.js → 23A5VAYC.js}

@@ -139,9 +139,6 @@ var Files = class _Files {
   }
 };
 
-// src/type-script-project.ts
-import { Watchr } from "@d1g1tal/watchr";
-
 // src/text-formatter.ts
 import { isatty } from "node:tty";
 var { env = {}, platform = "" } = process;
@@ -151,13 +148,13 @@ var isColorSupported = !("NO_COLOR" in env) && ("FORCE_COLOR" in env || platform
 var replaceClose = (index, string, close, replace, head = string.substring(0, index) + replace, tail = string.substring(index + close.length), next = tail.indexOf(close)) => {
   return head + (next < 0 ? tail : replaceClose(next, tail, close, replace));
 };
-var clearBleed = (index, string, open, close, replace) => {
-  return index < 0 ? `${open}${string}${close}` : `${open}${replaceClose(index, string, close, replace)}${close}`;
+var clearBleed = (index, string, open2, close, replace) => {
+  return index < 0 ? `${open2}${string}${close}` : `${open2}${replaceClose(index, string, close, replace)}${close}`;
 };
-var filterEmpty = (open, close, replace = open, at = open.length + 1) => {
-  return (text) => text.length ? clearBleed(text.indexOf(close, at), text, open, close, replace) : "";
+var filterEmpty = (open2, close, replace = open2, at = open2.length + 1) => {
+  return (text) => text.length ? clearBleed(text.indexOf(close, at), text, open2, close, replace) : "";
 };
-var generateTextFormatter = (open, close, replace) => filterEmpty(`\x1B[${open}m`, `\x1B[${close}m`, 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);
@@ -204,6 +201,8 @@ var TextFormat = class {
 };
 
 // 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;
@@ -231,7 +230,7 @@ var prettyBytes = (bytes) => {
   if (bytes === 0) {
     return { value: "0", unit: "B" };
   }
-  const exp = ~~(Math.log(bytes) / Math.log(1024));
+  const exp = ~~(Math.log(bytes) / LOG_1024);
   return { value: (bytes / Math.pow(1024, exp)).toFixed(2), unit: dataUnits[exp] };
 };
 var Logger = class _Logger {
@@ -255,7 +254,7 @@ var Logger = class _Logger {
    * @param message The message to display in the header.
    */
   static header(message) {
-    const innerWidth = message.replace(new RegExp(`${String.fromCharCode(27)}\\[[0-9;]*m`, "g"), "").length + 2;
+    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`));
   }
   /**
@@ -283,8 +282,17 @@ var Logger = class _Logger {
     if (visible.length === 0) {
       return;
     }
-    const maxNameLength = visible.reduce((max, { name }) => Math.max(max, name.length), 0);
-    const maxDurationLength = visible.reduce((max, { duration }) => Math.max(max, duration.length), 0);
+    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";
@@ -353,10 +361,24 @@ var Logger = class _Logger {
    * @internal
    */
   static files(files) {
-    const maxPathLength = files.reduce((max, { path }) => Math.max(max, path.length), 0);
-    const formatted = files.map(({ path, size }) => ({ path, ...prettyBytes(size) }));
-    const maxValueLength = formatted.reduce((max, { value }) => Math.max(max, value.length), 0);
-    const maxUnitLength = formatted.reduce((max, { unit }) => Math.max(max, unit.length), 0);
+    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);
@@ -536,17 +558,13 @@ var DeclarationProcessor = class _DeclarationProcessor {
     function createNamespaceImport(fileId) {
       let importName = inlineImports.get(fileId);
       if (importName === void 0) {
-        let sanitized = "";
+        const chars = [];
         for (let i = 0; i < fileId.length; i++) {
           const char = fileId[i];
           const code2 = char.charCodeAt(0);
-          if (code2 >= 97 && code2 <= 122 || code2 >= 65 && code2 <= 90 || code2 >= 48 && code2 <= 57 || code2 === 95 || code2 === 36) {
-            sanitized += char;
-          } else {
-            sanitized += "_";
-          }
+          chars.push(code2 >= 97 && code2 <= 122 || code2 >= 65 && code2 <= 90 || code2 >= 48 && code2 <= 57 || code2 === 95 || code2 === 36 ? char : "_");
         }
-        importName = generateUniqueName(sanitized);
+        importName = generateUniqueName(chars.join(""));
         inlineImports.set(fileId, importName);
       }
       return importName;
@@ -799,36 +817,40 @@ import {
   forEachChild as forEachChild2
 } from "typescript";
 var nodeModules = "/node_modules/";
+var emptySet = /* @__PURE__ */ new Set();
 var importPattern = /^import\s*(?:type\s*)?\{\s*([^}]+)\s*\}\s*from\s*['"]([^'"]+)['"]\s*;?\s*$/;
 var typePrefixPattern = /^type:/;
 function mergeImports(imports) {
   const moduleImports = /* @__PURE__ */ new Map();
-  const nonMergeableImports = [];
+  const nonMergeableImports = /* @__PURE__ */ new Set();
   for (const importStatement of imports) {
     const match = importPattern.exec(importStatement);
     if (match) {
       const [, namesString, moduleSpecifier] = match;
       const isType = importStatement.includes("import type");
       const key = `${isType ? "type:" : ""}${moduleSpecifier}`;
-      if (!moduleImports.has(key)) {
-        moduleImports.set(key, { names: /* @__PURE__ */ new Set(), isType });
+      let entry = moduleImports.get(key);
+      if (entry === void 0) {
+        entry = { names: /* @__PURE__ */ new Set(), isType };
+        moduleImports.set(key, entry);
       }
-      const entry = moduleImports.get(key);
       for (const name of namesString.split(",")) {
         entry.names.add(name.trim());
       }
     } else {
-      nonMergeableImports.push(importStatement);
+      nonMergeableImports.add(importStatement);
     }
   }
   const result = [];
   for (const [key, { names, isType }] of moduleImports) {
     result.push(`${isType ? "import type" : "import"} { ${[...names].sort().join(", ")} } from "${key.replace(typePrefixPattern, "")}";`);
   }
-  result.push(...[...new Set(nonMergeableImports)]);
+  for (const imp of nonMergeableImports) {
+    result.push(imp);
+  }
   return result;
 }
-var DeclarationBundler = class {
+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 */
@@ -841,6 +863,10 @@ var DeclarationBundler = class {
   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) => {
@@ -890,6 +916,8 @@ var DeclarationBundler = class {
       }
     }
     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.
@@ -942,23 +970,42 @@ var DeclarationBundler = class {
     return imports;
   }
   /**
-   * Check if a module specifier matches a pattern list
-   * @param moduleSpecifier - The module specifier to check
-   * @param patterns - Array of patterns to match against
-   * @returns True if the module matches any pattern
+   * 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
    */
-  matchesPattern(moduleSpecifier, patterns) {
-    return patterns.some((pattern) => {
-      return typeof pattern === "string" ? moduleSpecifier === pattern || moduleSpecifier.startsWith(`${pattern}/`) : pattern.test(moduleSpecifier);
-    });
-  }
-  /**
-   * Check if a module specifier matches explicit external patterns
-   * @param moduleSpecifier - The module specifier to check
-   * @returns True if the module should be treated as external
-   */
-  isExternal(moduleSpecifier) {
-    return this.matchesPattern(moduleSpecifier, this.options.external);
+  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
@@ -1006,18 +1053,18 @@ var DeclarationBundler = class {
       const sourceFile = createSourceFile(path, code, ScriptTarget.Latest, true);
       const identifiers = this.collectIdentifiers(sourceFile.statements, sourceFile);
       const module = { path, code, imports: /* @__PURE__ */ new Set(), typeReferences: new Set(typeReferences), fileReferences: new Set(fileReferences), sourceFile, identifiers };
-      const bundledSpecs = [];
+      const bundledSpecs = /* @__PURE__ */ new Set();
       for (const specifier of this.extractImports(sourceFile)) {
-        if (this.isExternal(specifier)) {
+        if (this.matchExternal(specifier)) {
           continue;
         }
         const resolvedPath = this.resolveModule(specifier, path);
-        if (resolvedPath?.includes(nodeModules) && !this.matchesPattern(specifier, this.options.noExternal)) {
+        if (resolvedPath?.includes(nodeModules) && !this.matchNoExternal(specifier)) {
           continue;
         }
         if (resolvedPath && (this.declarationFiles.has(resolvedPath) || this.externalDeclarationFiles.has(resolvedPath))) {
           module.imports.add(resolvedPath);
-          bundledSpecs.push(specifier);
+          bundledSpecs.add(specifier);
           visit(resolvedPath);
         }
       }
@@ -1128,7 +1175,7 @@ var DeclarationBundler = class {
    * @param code - Declaration file content
    * @param sourceFile - Parsed source file AST (required to avoid re-parsing)
    * @param identifiers - Pre-computed type and value identifiers (to avoid re-computation)
-   * @param bundledImportPaths - Array of resolved file paths that were bundled (to exclude from external imports)
+   * @param 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)
@@ -1151,7 +1198,7 @@ var DeclarationBundler = class {
     for (const statement of sourceFile.statements) {
       if (isImportDeclaration2(statement)) {
         const moduleSpecifier = statement.moduleSpecifier.text;
-        if (this.isExternal(moduleSpecifier) || !bundledImportPaths.includes(moduleSpecifier)) {
+        if (this.matchExternal(moduleSpecifier) || !bundledImportPaths.has(moduleSpecifier)) {
           externalImports.push(code.substring(statement.pos, statement.end).trim());
         } else if (statement.importClause?.namedBindings && isNamespaceImport(statement.importClause.namedBindings)) {
           bundledNamespaceAliases.add(statement.importClause.namedBindings.name.text);
@@ -1206,8 +1253,9 @@ var DeclarationBundler = class {
       };
       forEachChild2(sourceFile, visitQualified);
     }
-    const finalValueExports = [...new Set(valueExports.map(exportsMapper))];
-    const finalTypeExports = [...new Set(typeExports.map(exportsMapper).filter((t) => !new Set(finalValueExports).has(t)))];
+    const finalValueExportsSet = new Set(valueExports.map(exportsMapper));
+    const finalValueExports = [...finalValueExportsSet];
+    const finalTypeExports = [...new Set(typeExports.map(exportsMapper).filter((t) => !finalValueExportsSet.has(t)))];
     return { code: magic.toString(), externalImports, typeExports: finalTypeExports, valueExports: finalValueExports };
   }
   /**
@@ -1243,7 +1291,9 @@ var DeclarationBundler = class {
     for (const [name, sourcesSet] of declarationSources) {
       if (sourcesSet.size > 1) {
         let suffix = 1;
-        for (const modulePath of Array.from(sourcesSet).slice(1)) {
+        const modulePaths = sourcesSet.values();
+        modulePaths.next();
+        for (const modulePath of modulePaths) {
           let candidate = `${name}$${suffix}`;
           while (declarationSources.has(candidate)) {
             candidate = `${name}$${++suffix}`;
@@ -1256,7 +1306,7 @@ var DeclarationBundler = class {
     for (const { path, typeReferences, fileReferences, sourceFile, code, identifiers } of sortedModules) {
       allTypeReferences.push(...typeReferences);
       allFileReferences.push(...fileReferences);
-      const bundledForThisModule = bundledSpecifiers.get(path) || [];
+      const bundledForThisModule = bundledSpecifiers.get(path) ?? emptySet;
       const { code: strippedCode, externalImports, typeExports, valueExports } = this.stripImportsExports(code, sourceFile, identifiers, bundledForThisModule, renameMap, path);
       allExternalImports.push(...externalImports);
       if (!path.includes(nodeModules)) {
@@ -1282,8 +1332,8 @@ var DeclarationBundler = class {
       }
     }
     const uniqueTypeReferences = [...typeReferencesSet];
-    const finalValueExports = [...new Set(allValueExports)];
-    const finalValueExportsSet = new Set(finalValueExports);
+    const finalValueExportsSet = new Set(allValueExports);
+    const finalValueExports = [...finalValueExportsSet];
     const finalTypeExports = [...new Set(allTypeExports.filter((typeExport) => !finalValueExportsSet.has(typeExport)))];
     const outputParts = [];
     if (uniqueFileReferences.length > 0) {
@@ -1353,11 +1403,12 @@ async function bundleDeclarations(options) {
     await mkdir2(options.compilerOptions.outDir, defaultDirOptions);
   }
   const dtsBundler = new DeclarationBundler(options);
+  await new Promise((resolve3) => void setImmediate(resolve3));
   const bundleTasks = [];
   for (const [entryName, entryPoint] of Object.entries(options.entryPoints)) {
     const content = dtsBundler.bundle(entryPoint);
     if (content.length > 0) {
-      const outPath = Paths.join(options.compilerOptions.outDir, `${entryName}.d.ts`);
+      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 })));
     }
   }
@@ -1367,38 +1418,42 @@ async function bundleDeclarations(options) {
 }
 
 // src/plugins/output.ts
+import { chmod, open } from "node:fs/promises";
 import { extname } from "node:path";
-var textEncoder = new TextEncoder();
-var textDecoder = new TextDecoder();
-var localFileIdentifier = /\.[a-z]+$/i;
-var relativeSpecifierPattern = /(from\s*['"])(\.\.?\/[^'"]*?)(['"])/g;
-var FileMode = { READ_WRITE: 438, READ_WRITE_EXECUTE: 493 };
-function rewriteRelativeSpecifiers(code) {
-  return code.replace(relativeSpecifierPattern, (_, before, path, after) => localFileIdentifier.test(path) ? before + path + after : `${before}${path}.js${after}`);
-}
-async function fileMapper({ path, contents }) {
-  if (extname(path) !== FileExtension.JS) {
-    return Files.write(path, contents, { mode: FileMode.READ_WRITE });
-  }
-  let rewritten = false;
-  const result = textDecoder.decode(contents).replace(relativeSpecifierPattern, (_, before, specPath, after) => {
-    if (localFileIdentifier.test(specPath)) {
-      return before + specPath + after;
+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);
     }
-    rewritten = true;
-    return `${before}${specPath}.js${after}`;
-  });
-  return Files.write(path, rewritten ? textEncoder.encode(result) : contents, { mode: contents[0] === 35 && contents[1] === 33 ? FileMode.READ_WRITE_EXECUTE : FileMode.READ_WRITE });
+  } finally {
+    await handle.close();
+  }
 }
 var outputPlugin = () => {
   return {
     name: "esbuild:output-plugin",
     /**
-     * Configures the esbuild build instance to write output files to disk
+     * Checks JS entry points for shebangs and sets executable permissions
      * @param build The esbuild build instance
      */
     setup(build) {
-      build.onEnd(async ({ outputFiles }) => void await Promise.all(outputFiles.map(fileMapper)));
+      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);
+        }
+      });
     }
   };
 };
@@ -1519,10 +1574,9 @@ async function resolvePlugins(plugins, projectDir) {
 }
 
 // src/plugins/iife.ts
-import { basename as basename2, dirname as dirname2, join, relative, resolve as resolve2 } from "node:path";
-import { mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
-import { build as esbuild } from "esbuild";
-var textDecoder2 = new TextDecoder();
+import { mkdir as mkdir3, readFile as readFile2, writeFile as writeFile3 } from "node:fs/promises";
+import { basename as basename2, dirname as dirname2, join, resolve as resolve2 } from "node:path";
+var textDecoder = new TextDecoder();
 var jsExtension = ".js";
 function iifePlugin(options) {
   const globalName = options?.globalName;
@@ -1542,11 +1596,11 @@ function iifePlugin(options) {
         }
         const sourcemap = build.initialOptions.sourcemap;
         const entryPointNames = extractEntryNames(build.initialOptions.entryPoints);
-        build.onEnd(async ({ outputFiles }) => {
-          if (!outputFiles?.length || entryPointNames.length === 0) {
+        build.onEnd(async ({ metafile }) => {
+          if (!metafile || entryPointNames.length === 0) {
             return;
           }
-          const written = await buildIife(outputFiles, entryPointNames, outdir, globalName, sourcemap);
+          const written = await buildIife(metafile.outputs, entryPointNames, outdir, globalName, sourcemap);
           files.push(...written);
         });
       }
@@ -1570,15 +1624,15 @@ function extractEntryNames(entryPoints) {
   }
   return Object.keys(entryPoints);
 }
-var exportRe = /export\s*\{([^}]*)\};?/g;
-var asRe = /^(\w+)\s+as\s+(\w+)$/;
+var exportRegex = /export\s*\{([^}]*)\};?/g;
+var exportAliasRegex = /^(\w+)\s+as\s+(\w+)$/;
 function wrapAsIife(text, globalName) {
-  let last = null;
-  let match;
-  exportRe.lastIndex = 0;
-  while ((match = exportRe.exec(text)) !== null) {
-    last = match;
+  const exportIndex = text.lastIndexOf("export");
+  if (exportIndex === -1) {
+    return text;
   }
+  exportRegex.lastIndex = exportIndex;
+  const last = exportRegex.exec(text);
   if (!last) {
     return text;
   }
@@ -1588,7 +1642,7 @@ function wrapAsIife(text, globalName) {
     if (!trimmed) {
       continue;
     }
-    const m = asRe.exec(trimmed);
+    const m = exportAliasRegex.exec(trimmed);
     props.push(m ? `${m[2]}: ${m[1]}` : trimmed);
   }
   if (props.length === 0) {
@@ -1602,11 +1656,12 @@ ${body}
 	${assignment}
 })();${after}`;
 }
-async function buildIife(outputFiles, entryPointNames, outdir, globalName, sourcemap) {
+async function buildIife(outputs, entryPointNames, outdir, globalName, sourcemap) {
+  const { build: esbuild } = await import("esbuild");
   const fileContents = /* @__PURE__ */ new Map();
-  for (const file of outputFiles) {
-    if (file.path.endsWith(jsExtension)) {
-      fileContents.set(file.path, textDecoder2.decode(file.contents));
+  for (const outputPath of Object.keys(outputs)) {
+    if (outputPath.endsWith(jsExtension)) {
+      fileContents.set(outputPath, await readFile2(outputPath, "utf8"));
     }
   }
   const validEntries = [];
@@ -1638,15 +1693,16 @@ async function buildIife(outputFiles, entryPointNames, outdir, globalName, sourc
   ));
   const written = [];
   const writes = [];
+  const cwd = process.cwd();
   for (const { outputFiles: iifeFiles } of results) {
-    for (const file of iifeFiles) {
-      if (file.path.endsWith(jsExtension)) {
-        const text = wrapAsIife(textDecoder2.decode(file.contents), globalName);
-        writes.push(writeFile3(file.path, text));
-        written.push({ path: relative(process.cwd(), file.path), size: Buffer.byteLength(text) });
+    for (const { path, contents } of iifeFiles) {
+      if (path.endsWith(jsExtension)) {
+        const text = wrapAsIife(textDecoder.decode(contents), globalName);
+        writes.push(writeFile3(path, text));
+        written.push({ path: Paths.relative(cwd, path), size: Buffer.byteLength(text) });
       } else {
-        writes.push(writeFile3(file.path, file.contents));
-        written.push({ path: relative(process.cwd(), file.path), size: file.contents.byteLength });
+        writes.push(writeFile3(path, contents));
+        written.push({ path: Paths.relative(cwd, path), size: contents.byteLength });
       }
     }
   }
@@ -1921,6 +1977,11 @@ function debounce(wait) {
 
 // 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();
@@ -1979,14 +2040,17 @@ var FileManager = class {
    */
   finalize() {
     this.processEmittedFiles();
-    const buildInfoWrite = this.pendingBuildInfo ? Files.write(this.pendingBuildInfo.path, this.pendingBuildInfo.text) : void 0;
+    const tasks = [];
+    if (this.pendingBuildInfo) {
+      tasks.push(Files.write(this.pendingBuildInfo.path, this.pendingBuildInfo.text));
+    }
     this.pendingBuildInfo = void 0;
     if (this.cache && this.hasEmittedFiles) {
-      this.pendingSave = Promise.all([buildInfoWrite, this.cache.save(this.declarationFiles)]).then(() => {
-      });
-    } else if (buildInfoWrite) {
-      this.pendingSave = buildInfoWrite;
+      tasks.push(this.cache.save(this.declarationFiles));
     }
+    this.pendingSave = Promise.all(tasks).then(() => {
+    }, () => {
+    });
     this.pendingSave?.catch(() => {
     });
     return this.cache === void 0 || this.hasEmittedFiles;
@@ -2018,7 +2082,7 @@ var FileManager = class {
         writeTasks.push(this.writeFile(projectDirectory, filePath, code));
       }
     }
-    return (await Promise.all(writeTasks)).filter((result) => result !== void 0);
+    return Promise.all(writeTasks);
   }
   /**
    * Resolves entry points for declaration bundling.
@@ -2033,8 +2097,9 @@ var FileManager = class {
       return defaultEntryPoint in projectEntryPoints ? { [defaultEntryPoint]: projectEntryPoints[defaultEntryPoint] } : projectEntryPoints;
     }
     const result = {};
+    const allowedEntryPoints = new Set(dtsEntryPoints);
     for (const [name, path] of Object.entries(projectEntryPoints)) {
-      if (dtsEntryPoints.includes(name)) {
+      if (allowedEntryPoints.has(name)) {
         result[name] = path;
       }
     }
@@ -2298,7 +2363,12 @@ function inferEntryPoints(packageJson, outDir, sourceDir = "src") {
       }
     }
   }
-  if (Object.keys(entryPoints).length === 0) {
+  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);
@@ -2307,11 +2377,13 @@ function inferEntryPoints(packageJson, outDir, sourceDir = "src") {
       }
     }
   }
-  return Object.keys(entryPoints).length > 0 ? entryPoints : void 0;
+  for (const _ in entryPoints) {
+    return entryPoints;
+  }
+  return void 0;
 }
 
 // src/type-script-project.ts
-import { build as esbuild2, formatMessages } from "esbuild";
 import { performance as performance2 } from "node:perf_hooks";
 import { sys as sys2, createIncrementalProgram, formatDiagnostics, formatDiagnosticsWithColorAndContext, parseJsonConfigFileContent, readConfigFile, findConfigFile } from "typescript";
 var globCharacters = /[*?\\[\]!].*$/;
@@ -2355,7 +2427,7 @@ var _TypeScriptProject = class _TypeScriptProject {
     return Files.empty(this.buildConfiguration.outDir);
   }
   async build() {
-    Logger.header(`${tsLogo} tsbuild v${"1.8.2"}${this.configuration.compilerOptions.incremental && this.configuration.buildCache?.isValid() ? " [incremental]" : ""}`);
+    Logger.header(`${tsLogo} tsbuild v${"1.8.4"}${this.configuration.compilerOptions.incremental && this.configuration.buildCache?.isValid() ? " [incremental]" : ""}`);
     try {
       const processes = [];
       const filesWereEmitted = await this.typeCheck();
@@ -2386,7 +2458,7 @@ var _TypeScriptProject = class _TypeScriptProject {
           }
         }
         if (this.fileWatcher === void 0 || this.fileWatcher.isClosed()) {
-          setImmediate(() => this.watch());
+          setImmediate(() => void this.watch());
         }
       }
     }
@@ -2425,6 +2497,7 @@ var _TypeScriptProject = class _TypeScriptProject {
     return emitted || !this.configuration.compilerOptions.declaration;
   }
   async transpile() {
+    const { build: esbuild, formatMessages } = await import("esbuild");
     const plugins = [outputPlugin()];
     if (this.buildConfiguration.noExternal.length > 0) {
       plugins.push(externalModulesPlugin({ dependencies: await this.getProjectDependencyPaths(), noExternal: this.buildConfiguration.noExternal }));
@@ -2453,11 +2526,11 @@ var _TypeScriptProject = class _TypeScriptProject {
       }
     }
     try {
-      const { warnings, errors, metafile: { outputs } } = await esbuild2({
+      const { warnings, errors, metafile: { outputs } } = await esbuild({
         format,
         plugins,
         define,
-        write: false,
+        write: true,
         metafile: true,
         treeShaking: true,
         logLevel: "warning",
@@ -2517,7 +2590,8 @@ var _TypeScriptProject = class _TypeScriptProject {
   /**
    * Watches for changes in the project files and rebuilds the project when changes are detected.
    */
-  watch() {
+  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, "")));
@@ -2571,7 +2645,7 @@ var _TypeScriptProject = class _TypeScriptProject {
     Logger.info(`Rebuilding project: ${this.pendingChanges.length} file changes detected.`);
     const rootNames = [...this.builderProgram.getProgram().getRootFileNames()];
     for (const { event, path, nextPath } of this.pendingChanges) {
-      if (nextPath !== void 0 && (event === Watchr.FileEvent.rename || event === Watchr.DirectoryEvent.rename)) {
+      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);
@@ -2580,9 +2654,9 @@ var _TypeScriptProject = class _TypeScriptProject {
         }
       } else {
         const index = rootNames.indexOf(path);
-        if (event === Watchr.FileEvent.unlink && index !== -1) {
+        if (event === "unlink" && index !== -1) {
           rootNames.splice(index, 1);
-        } else if (event === Watchr.FileEvent.add && index === -1) {
+        } else if (event === "add" && index === -1) {
           rootNames.push(path);
         }
       }

package/dist/tsbuild.js

@@ -2,7 +2,7 @@
 import {
   BuildError,
   TypeScriptProject
-} from "./ALZQNZZK.js";
+} from "./23A5VAYC.js";
 import "./JKGYA2AW.js";
 
 // src/tsbuild.ts
@@ -30,7 +30,7 @@ if (help) {
   process.exit(0);
 }
 if (version) {
-  console.log("1.8.2");
+  console.log("1.8.4");
   process.exit(0);
 }
 var typeScriptOptions = {

package/dist/type-script-project.js

@@ -1,6 +1,6 @@
 import {
   TypeScriptProject
-} from "./ALZQNZZK.js";
+} from "./23A5VAYC.js";
 import "./JKGYA2AW.js";
 export {
   TypeScriptProject

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@d1g1tal/tsbuild",
   "author": "D1g1talEntr0py",
-  "version": "1.8.2",
+  "version": "1.8.4",
   "license": "MIT",
   "description": "A fast, ESM-only TypeScript build tool combining the TypeScript API for type checking and declaration generation, esbuild for bundling, and SWC for decorator metadata.",
   "homepage": "https://github.com/D1g1talEntr0py/tsbuild#readme",
@@ -50,7 +50,7 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "@types/node": "^25.5.2",
+    "@types/node": "^25.6.0",
     "@typescript-eslint/eslint-plugin": "^8.58.1",
     "@typescript-eslint/parser": "^8.58.1",
     "@vitest/coverage-v8": "^4.1.4",
@@ -81,6 +81,7 @@
   "scripts": {
     "build": "tsx ./src/tsbuild.ts",
     "build:watch": "tsx ./src/tsbuild.ts --watch",
+    "bench": "tsx ./scripts/benchmark.ts",
     "type-check": "tsx ./src/tsbuild.ts --noEmit",
     "lint": "eslint ./src",
     "test": "vitest run",