@b9g/libuild 0.1.3 → 0.1.5

package/src/chunk-YRPHTAV4.js

@@ -1,713 +0,0 @@
-import {
-  umdPlugin
-} from "./chunk-EVLPGECD.js";
-
-// src/libuild.ts
-import * as FS from "fs/promises";
-import * as Path from "path";
-import { spawn } from "child_process";
-import * as ESBuild from "esbuild";
-import * as TS from "typescript";
-function isValidEntrypoint(filename) {
-  if (!filename.endsWith(".ts") && !filename.endsWith(".js"))
-    return false;
-  if (filename.endsWith(".d.ts"))
-    return false;
-  if (filename.startsWith("_"))
-    return false;
-  if (filename.startsWith("."))
-    return false;
-  return true;
-}
-async function findEntryPoints(srcDir) {
-  const files = await FS.readdir(srcDir);
-  return files.filter(isValidEntrypoint).map((file) => Path.basename(file, Path.extname(file))).sort();
-}
-async function detectMainEntry(pkg, entries) {
-  if (pkg.exports && pkg.exports["."]) {
-    const dotExport = pkg.exports["."];
-    let importPath;
-    if (typeof dotExport === "string") {
-      importPath = dotExport;
-    } else if (typeof dotExport === "object" && dotExport.import) {
-      importPath = dotExport.import;
-    }
-    if (importPath) {
-      const match = importPath.match(/\.\/src\/([^.]+)/);
-      if (match && entries.includes(match[1])) {
-        return match[1];
-      }
-    }
-  }
-  if (pkg.main && typeof pkg.main === "string") {
-    const mainBase = Path.basename(pkg.main, Path.extname(pkg.main));
-    if (entries.includes(mainBase)) {
-      return mainBase;
-    }
-  }
-  if (entries.includes("index")) {
-    return "index";
-  }
-  if (entries.length === 1) {
-    return entries[0];
-  }
-  const pkgNameParts = pkg.name.split("/");
-  const pkgName = pkgNameParts[pkgNameParts.length - 1];
-  if (!pkgName) {
-    throw new Error(`Invalid package name: ${pkg.name}`);
-  }
-  if (entries.includes(pkgName)) {
-    return pkgName;
-  }
-  return entries[0];
-}
-function checkIfExportIsStale(exportKey, exportValue, entries) {
-  if (exportKey === "./package.json" || typeof exportValue === "string" && (exportValue === "./package.json" || exportValue.endsWith("/package.json"))) {
-    return false;
-  }
-  let entryName;
-  let hasInvalidPath = false;
-  if (typeof exportValue === "string") {
-    if (exportValue.match(/\.\/src\/.*\/.*\.(ts|js)$/)) {
-      hasInvalidPath = true;
-    } else {
-      const match = exportValue.match(/\.\/src\/([^/]+)\.(ts|js)$/);
-      if (match) {
-        const filename = match[1] + "." + match[2];
-        if (!isValidEntrypoint(filename)) {
-          hasInvalidPath = true;
-        } else {
-          entryName = match[1];
-        }
-      }
-    }
-  } else if (typeof exportValue === "object" && exportValue !== null) {
-    const importPath = exportValue.import || exportValue.require;
-    if (typeof importPath === "string") {
-      if (importPath.match(/\.\/src\/.*\/.*\.(ts|js|cjs)$/)) {
-        hasInvalidPath = true;
-      } else {
-        const match = importPath.match(/\.\/src\/([^/]+)\.(ts|js|cjs)$/);
-        if (match) {
-          const filename = match[1] + "." + match[2].replace("cjs", "js");
-          if (!isValidEntrypoint(filename)) {
-            hasInvalidPath = true;
-          } else {
-            entryName = match[1];
-          }
-        }
-      }
-    }
-  }
-  if (!entryName && !hasInvalidPath && exportKey.startsWith("./") && exportKey !== ".") {
-    const keyName = exportKey.slice(2).replace(/\.js$/, "");
-    if (keyName && !keyName.includes("/")) {
-      entryName = keyName;
-    }
-  }
-  if (hasInvalidPath) {
-    return false;
-  }
-  return entryName ? !entries.includes(entryName) : false;
-}
-function generateExports(entries, mainEntry, options, existingExports = {}) {
-  const exports = {};
-  const staleExports = [];
-  function createExportEntry(entry) {
-    const exportEntry = {
-      types: `./src/${entry}.d.ts`,
-      import: `./src/${entry}.js`
-    };
-    if (options.formats.cjs) {
-      exportEntry.require = `./src/${entry}.cjs`;
-    }
-    return exportEntry;
-  }
-  function expandExistingExport(existing, entryFromPath) {
-    var _a;
-    if (typeof existing === "string") {
-      if (existing === "./package.json" || existing.endsWith("/package.json")) {
-        return existing;
-      }
-      const match = existing.match(/\.\/src\/([^/]+\.(?:ts|js))$/);
-      if (match) {
-        const filename = match[1];
-        if (!isValidEntrypoint(filename)) {
-          throw new Error(`Export path '${existing}' references '${filename}' which is not a valid entrypoint. Valid entrypoints cannot start with '_' or '.' and must be .ts/.js files in src/.`);
-        }
-        const entry = Path.basename(filename, Path.extname(filename));
-        return options.formats.cjs ? {
-          types: `./src/${entry}.d.ts`,
-          import: existing,
-          require: `./src/${entry}.cjs`
-        } : {
-          types: `./src/${entry}.d.ts`,
-          import: existing
-        };
-      }
-      if (entryFromPath) {
-        return options.formats.cjs ? {
-          types: `./src/${entryFromPath}.d.ts`,
-          import: existing,
-          require: `./src/${entryFromPath}.cjs`
-        } : {
-          types: `./src/${entryFromPath}.d.ts`,
-          import: existing
-        };
-      }
-      throw new Error(`Export path '${existing}' must point to a valid entrypoint in src/ (e.g., './src/utils.js'). Nested directories and internal files (starting with '_' or '.') are not allowed.`);
-    } else if (typeof existing === "object" && existing !== null) {
-      if (options.formats.cjs && !existing.require && existing.import) {
-        const match = (_a = existing.import) == null ? void 0 : _a.match(/\.\/src\/([^/]+\.(?:ts|js))$/);
-        if (match) {
-          const filename = match[1];
-          if (!isValidEntrypoint(filename)) {
-            throw new Error(`Export import path '${existing.import}' references '${filename}' which is not a valid entrypoint. Valid entrypoints cannot start with '_' or '.' and must be .ts/.js files in src/.`);
-          }
-          const entry = Path.basename(filename, Path.extname(filename));
-          return {
-            ...existing,
-            types: existing.types || `./src/${entry}.d.ts`,
-            require: `./src/${entry}.cjs`
-          };
-        }
-        if (entryFromPath) {
-          return {
-            ...existing,
-            types: existing.types || `./src/${entryFromPath}.d.ts`,
-            require: `./src/${entryFromPath}.cjs`
-          };
-        }
-        throw new Error(`Export import path '${existing.import}' must point to a valid entrypoint in src/ (e.g., './src/utils.js'). Nested directories and internal files are not allowed.`);
-      }
-      return {
-        types: existing.types || `./src/${entryFromPath}.d.ts`,
-        ...existing
-      };
-    }
-    return existing;
-  }
-  for (const [key, value] of Object.entries(existingExports)) {
-    const isStale = checkIfExportIsStale(key, value, entries);
-    if (isStale) {
-      staleExports.push(key);
-    } else {
-      exports[key] = expandExistingExport(value);
-    }
-  }
-  if (!exports["."]) {
-    exports["."] = createExportEntry(mainEntry);
-  } else {
-    exports["."] = expandExistingExport(exports["."], mainEntry);
-  }
-  for (const entry of entries) {
-    if (entry === "umd")
-      continue;
-    const key = `./${entry}`;
-    if (!exports[key]) {
-      exports[key] = createExportEntry(entry);
-    } else {
-      exports[key] = expandExistingExport(exports[key], entry);
-    }
-    if (!exports[`${key}.js`]) {
-      exports[`${key}.js`] = exports[key];
-    }
-    if (entry === "jsx-runtime") {
-      if (!exports["./jsx-dev-runtime"]) {
-        exports["./jsx-dev-runtime"] = exports[key];
-      }
-      if (!exports["./jsx-dev-runtime.js"]) {
-        exports["./jsx-dev-runtime.js"] = exports[key];
-      }
-    }
-  }
-  if (options.formats.umd && !exports["./umd"]) {
-    exports["./umd"] = {
-      require: "./src/umd.js"
-    };
-    if (!exports["./umd.js"]) {
-      exports["./umd.js"] = exports["./umd"];
-    }
-  }
-  if (!exports["./package.json"]) {
-    exports["./package.json"] = "./package.json";
-  }
-  return { exports, staleExports };
-}
-function transformSrcToDist(value) {
-  if (typeof value === "string") {
-    if (value.startsWith("src/") || value === "src") {
-      return "./" + value;
-    }
-    return value;
-  } else if (Array.isArray(value)) {
-    return value.map(transformSrcToDist);
-  } else if (typeof value === "object" && value !== null) {
-    const transformed = {};
-    for (const [key, val] of Object.entries(value)) {
-      transformed[key] = transformSrcToDist(val);
-    }
-    return transformed;
-  }
-  return value;
-}
-function fixExportsForDist(obj) {
-  if (typeof obj === "string") {
-    if (obj.includes("/dist/") && obj.includes("/src/")) {
-      const match = obj.match(/.*\/src\/(.*)$/);
-      if (match) {
-        return `./src/${match[1]}`;
-      }
-    }
-    if (obj.startsWith("./dist/src/")) {
-      return obj.replace("./dist/src/", "./src/");
-    }
-    if (obj.includes("/dist/") && obj.endsWith("/package.json")) {
-      return "./package.json";
-    }
-    return obj;
-  } else if (Array.isArray(obj)) {
-    return obj.map(fixExportsForDist);
-  } else if (typeof obj === "object" && obj !== null) {
-    const fixed = {};
-    for (const [key, val] of Object.entries(obj)) {
-      if (key === "files" && Array.isArray(val)) {
-        fixed[key] = val.filter((file) => file !== "dist/" && file !== "dist").concat(val.includes("dist/") || val.includes("dist") ? ["src/"] : []);
-      } else {
-        fixed[key] = fixExportsForDist(val);
-      }
-    }
-    return fixed;
-  }
-  return obj;
-}
-function cleanPackageJSON(pkg, mainEntry, options) {
-  const cleaned = {
-    name: pkg.name,
-    version: pkg.version
-  };
-  const fieldsToKeep = [
-    "description",
-    "keywords",
-    "author",
-    "contributors",
-    "maintainers",
-    "license",
-    "repository",
-    "bugs",
-    "homepage",
-    "funding",
-    "bin",
-    "scripts",
-    "dependencies",
-    "peerDependencies",
-    "optionalDependencies",
-    "bundledDependencies",
-    "engines",
-    "cpu",
-    "os",
-    "type",
-    "types",
-    "files",
-    "sideEffects",
-    "browserslist"
-  ];
-  const pathFields = ["files", "types", "scripts"];
-  for (const field of fieldsToKeep) {
-    if (pkg[field] !== void 0) {
-      if (field === "scripts") {
-        const npmLifecycleScripts = ["postinstall", "preinstall", "install", "preuninstall", "postuninstall", "shrinkwrap"];
-        const filteredScripts = {};
-        for (const [scriptName, scriptValue] of Object.entries(pkg[field] || {})) {
-          if (npmLifecycleScripts.includes(scriptName)) {
-            filteredScripts[scriptName] = scriptValue;
-          }
-        }
-        if (Object.keys(filteredScripts).length > 0) {
-          cleaned[field] = transformSrcToDist(filteredScripts);
-        }
-      } else if (field === "bin") {
-        cleaned[field] = transformSrcToDist(pkg[field]);
-      } else if (pathFields.includes(field)) {
-        cleaned[field] = transformSrcToDist(pkg[field]);
-      } else {
-        cleaned[field] = pkg[field];
-      }
-    }
-  }
-  if (!cleaned.type) {
-    cleaned.type = "module";
-  }
-  if (options.formats.cjs) {
-    cleaned.main = `src/${mainEntry}.cjs`;
-  }
-  cleaned.module = `src/${mainEntry}.js`;
-  cleaned.types = `src/${mainEntry}.d.ts`;
-  return cleaned;
-}
-async function fileExists(filePath) {
-  try {
-    await FS.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function build2(cwd, save = false) {
-  console.log("Building with libuild...");
-  const srcDir = Path.join(cwd, "src");
-  const distDir = Path.join(cwd, "dist");
-  const distSrcDir = Path.join(distDir, "src");
-  if (!await fileExists(srcDir)) {
-    throw new Error("No src/ directory found");
-  }
-  const pkgPath = Path.join(cwd, "package.json");
-  const pkg = JSON.parse(await FS.readFile(pkgPath, "utf-8"));
-  if (!pkg.private) {
-    console.warn("\u26A0\uFE0F  WARNING: Root package.json is not private - this could lead to accidental publishing of development package.json");
-    console.warn("   Consider setting 'private: true' in your root package.json");
-  }
-  const gitignorePath = Path.join(cwd, ".gitignore");
-  if (await fileExists(gitignorePath)) {
-    const gitignoreContent = await FS.readFile(gitignorePath, "utf-8");
-    const isDistIgnored = gitignoreContent.includes("dist/") || gitignoreContent.includes("/dist") || gitignoreContent.includes("dist\n") || gitignoreContent.includes("dist\r\n");
-    if (!isDistIgnored) {
-      console.warn("\u26A0\uFE0F  WARNING: dist/ directory is not in .gitignore - built files should not be committed");
-      console.warn("   Add 'dist/' to your .gitignore file");
-    }
-  }
-  const entries = await findEntryPoints(srcDir);
-  if (entries.length === 0) {
-    throw new Error("No entry points found in src/");
-  }
-  const options = {
-    formats: {
-      esm: true,
-      // Always build ESM
-      cjs: !!pkg.main,
-      // Generate CJS only if main field exists
-      umd: entries.includes("umd")
-    }
-  };
-  const mainEntry = await detectMainEntry(pkg, entries);
-  console.log("  Found entries:", entries.join(", "));
-  console.log("  Main entry:", mainEntry);
-  if (options.formats.cjs) {
-    console.log("  Formats: ESM, CJS" + (options.formats.umd ? ", UMD" : ""));
-  } else {
-    console.log("  Formats: ESM" + (options.formats.umd ? ", UMD" : "") + " (no main field - CJS disabled)");
-  }
-  if (await fileExists(distDir)) {
-    await FS.rm(distDir, { recursive: true });
-  }
-  await FS.mkdir(distDir, { recursive: true });
-  const entryPoints = [];
-  const umdEntries = [];
-  for (const entry of entries) {
-    const entryPath = Path.join(srcDir, `${entry}.ts`);
-    const jsEntryPath = Path.join(srcDir, `${entry}.js`);
-    const actualPath = await fileExists(entryPath) ? entryPath : jsEntryPath;
-    if (!await fileExists(actualPath)) {
-      throw new Error(`Entry point file not found: ${actualPath}. Expected ${entry}.ts or ${entry}.js in src/ directory.`);
-    }
-    if (entry === "umd") {
-      umdEntries.push(actualPath);
-    } else {
-      entryPoints.push(actualPath);
-    }
-  }
-  if (entryPoints.length > 0) {
-    console.log(`  Building ${entryPoints.length} entries (ESM)...`);
-    await ESBuild.build({
-      entryPoints,
-      outdir: distSrcDir,
-      format: "esm",
-      entryNames: "[name]",
-      outExtension: { ".js": ".js" },
-      bundle: true,
-      splitting: true,
-      // Enable shared chunk extraction
-      minify: false,
-      sourcemap: true,
-      external: Object.keys(pkg.dependencies || {}),
-      platform: "node",
-      target: "node16"
-    });
-    if (options.formats.cjs) {
-      console.log(`  Building ${entryPoints.length} entries (CJS)...`);
-      await ESBuild.build({
-        entryPoints,
-        outdir: distSrcDir,
-        format: "cjs",
-        entryNames: "[name]",
-        outExtension: { ".js": ".cjs" },
-        bundle: true,
-        minify: false,
-        sourcemap: true,
-        external: Object.keys(pkg.dependencies || {}),
-        platform: "node",
-        target: "node16"
-        // Note: CJS doesn't support splitting, but building together still helps with consistency
-      });
-    }
-  }
-  for (const umdPath of umdEntries) {
-    const entry = Path.basename(umdPath, Path.extname(umdPath));
-    console.log(`  Building ${entry} (UMD)...`);
-    const globalName = pkg.name.includes("/") ? pkg.name.split("/").pop().replace(/-/g, "").charAt(0).toUpperCase() + pkg.name.split("/").pop().replace(/-/g, "").slice(1) : pkg.name.replace(/-/g, "").charAt(0).toUpperCase() + pkg.name.replace(/-/g, "").slice(1);
-    await ESBuild.build({
-      entryPoints: [umdPath],
-      outdir: distSrcDir,
-      format: "cjs",
-      entryNames: "[name]",
-      bundle: true,
-      minify: false,
-      sourcemap: true,
-      external: Object.keys(pkg.dependencies || {}),
-      platform: "node",
-      target: "node16",
-      plugins: [umdPlugin({ globalName })]
-    });
-  }
-  console.log("  Generating TypeScript declarations...");
-  const allTsFiles = [...entryPoints, ...umdEntries].filter((file) => file.endsWith(".ts"));
-  if (allTsFiles.length > 0) {
-    const compilerOptions = {
-      declaration: true,
-      emitDeclarationOnly: true,
-      outDir: distSrcDir,
-      rootDir: srcDir,
-      skipLibCheck: true,
-      esModuleInterop: true,
-      target: TS.ScriptTarget.ES2020,
-      module: TS.ModuleKind.ESNext
-    };
-    const program = TS.createProgram(allTsFiles, compilerOptions);
-    const emitResult = program.emit();
-    if (emitResult.diagnostics.length > 0) {
-      const diagnostics = TS.formatDiagnosticsWithColorAndContext(emitResult.diagnostics, {
-        getCanonicalFileName: (path) => path,
-        getCurrentDirectory: () => cwd,
-        getNewLine: () => "\n"
-      });
-      throw new Error(`TypeScript declaration generation failed:
-${diagnostics}`);
-    }
-  }
-  for (const entry of entries) {
-    if (entry === "umd")
-      continue;
-    const jsPath = Path.join(distSrcDir, `${entry}.js`);
-    const dtsPath = Path.join(distSrcDir, `${entry}.d.ts`);
-    if (await fileExists(jsPath) && await fileExists(dtsPath)) {
-      const content = await FS.readFile(jsPath, "utf-8");
-      if (content.startsWith("#!")) {
-        const lines = content.split("\n");
-        const shebang = lines[0];
-        const rest = lines.slice(1).join("\n");
-        await FS.writeFile(jsPath, `${shebang}
-/// <reference types="./${entry}.d.ts" />
-${rest}`);
-      } else {
-        await FS.writeFile(jsPath, `/// <reference types="./${entry}.d.ts" />
-${content}`);
-      }
-    }
-  }
-  const autoDiscoveredFiles = [];
-  console.log("  Generating package.json...");
-  const cleanedPkg = cleanPackageJSON(pkg, mainEntry, options);
-  const exportsResult = generateExports(entries, mainEntry, options, pkg.exports);
-  cleanedPkg.exports = fixExportsForDist(exportsResult.exports);
-  if (exportsResult.staleExports.length > 0) {
-    console.warn(`\u26A0\uFE0F  WARNING: Found ${exportsResult.staleExports.length} stale export(s) pointing to missing src/ files:`);
-    for (const staleExport of exportsResult.staleExports) {
-      console.warn(`   - ${staleExport}`);
-    }
-    if (save) {
-      console.log("   Removing stale exports from root package.json (--save mode)");
-    } else {
-      console.warn("   Use --save to remove these from root package.json");
-    }
-  }
-  if (cleanedPkg.files && Array.isArray(cleanedPkg.files)) {
-    for (const autoFile of autoDiscoveredFiles) {
-      if (!cleanedPkg.files.includes(autoFile)) {
-        cleanedPkg.files.push(autoFile);
-      }
-    }
-  }
-  const fixedDistPkg = fixExportsForDist(cleanedPkg);
-  await FS.writeFile(
-    Path.join(distDir, "package.json"),
-    JSON.stringify(fixedDistPkg, null, 2) + "\n"
-  );
-  const defaultFilesToCopy = ["README.md", "LICENSE", "CHANGELOG.md"];
-  for (const file of defaultFilesToCopy) {
-    const srcPath = Path.join(cwd, file);
-    if (await fileExists(srcPath)) {
-      console.log(`  Copying ${file}...`);
-      await FS.copyFile(srcPath, Path.join(distDir, file));
-    }
-  }
-  const commonFiles = ["README.md", "LICENSE", "CHANGELOG.md", "COPYING", "AUTHORS"];
-  if (pkg.files && Array.isArray(pkg.files)) {
-    for (const commonFile of commonFiles) {
-      const commonPath = Path.join(cwd, commonFile);
-      if (await fileExists(commonPath) && !pkg.files.includes(commonFile)) {
-        console.log(`  Auto-discovered ${commonFile}, adding to files field...`);
-        pkg.files.push(commonFile);
-        autoDiscoveredFiles.push(commonFile);
-      }
-    }
-  }
-  if (pkg.files && Array.isArray(pkg.files)) {
-    console.log("  Copying files from package.json files field...");
-    for (const pattern of pkg.files) {
-      if (typeof pattern === "string" && (pattern.includes("src") || pattern.includes("dist"))) {
-        continue;
-      }
-      if (typeof pattern === "string") {
-        const srcPath = Path.join(cwd, pattern);
-        const destPath = Path.join(distDir, pattern);
-        if (await fileExists(srcPath)) {
-          const stat2 = await FS.stat(srcPath);
-          if (stat2.isDirectory()) {
-            console.log(`  Copying directory ${pattern}/...`);
-            await FS.mkdir(Path.dirname(destPath), { recursive: true });
-            await FS.cp(srcPath, destPath, { recursive: true });
-          } else {
-            console.log(`  Copying ${pattern}...`);
-            await FS.mkdir(Path.dirname(destPath), { recursive: true });
-            await FS.copyFile(srcPath, destPath);
-          }
-        } else if (pattern.includes("*")) {
-          const baseDir = pattern.split("*")[0].replace(/\/$/, "");
-          if (baseDir && await fileExists(Path.join(cwd, baseDir))) {
-            console.log(`  Copying pattern ${pattern}...`);
-            const baseSrcPath = Path.join(cwd, baseDir);
-            const baseDestPath = Path.join(distDir, baseDir);
-            await FS.mkdir(Path.dirname(baseDestPath), { recursive: true });
-            await FS.cp(baseSrcPath, baseDestPath, { recursive: true });
-          } else {
-            throw new Error(`Pattern base directory not found for "${pattern}". Expected directory: ${Path.join(cwd, baseDir)}`);
-          }
-        } else {
-          throw new Error(`File specified in files field not found: ${srcPath}. Remove "${pattern}" from package.json files field or create the file.`);
-        }
-      } else {
-        throw new Error(`Invalid files field entry: ${JSON.stringify(pattern)}. Files field entries must be strings.`);
-      }
-    }
-  }
-  if (save) {
-    console.log("  Updating root package.json...");
-    const rootPkg2 = { ...pkg };
-    rootPkg2.private = true;
-    if (options.formats.cjs) {
-      rootPkg2.main = `./dist/src/${mainEntry}.cjs`;
-    }
-    rootPkg2.module = `./dist/src/${mainEntry}.js`;
-    rootPkg2.types = `./dist/src/${mainEntry}.d.ts`;
-    if (rootPkg2.typings && typeof rootPkg2.typings === "string") {
-      rootPkg2.typings = rootPkg2.typings.startsWith("./dist/") ? rootPkg2.typings : "./" + Path.join("dist", rootPkg2.typings);
-    }
-    const rootExports = {};
-    for (const [key, value] of Object.entries(cleanedPkg.exports)) {
-      if (typeof value === "string") {
-        rootExports[key] = value.startsWith("./dist/") ? value : `./dist${value.startsWith(".") ? value.slice(1) : value}`;
-      } else if (typeof value === "object" && value !== null) {
-        rootExports[key] = {};
-        for (const [subKey, subValue] of Object.entries(value)) {
-          if (typeof subValue === "string") {
-            rootExports[key][subKey] = subValue.startsWith("./dist/") ? subValue : `./dist${subValue.startsWith(".") ? subValue.slice(1) : subValue}`;
-          }
-        }
-      }
-    }
-    rootPkg2.exports = rootExports;
-    if (rootPkg2.bin) {
-      if (typeof rootPkg2.bin === "string") {
-        if (!rootPkg2.bin.startsWith("./dist/")) {
-          rootPkg2.bin = "./" + Path.join("dist", rootPkg2.bin);
-        }
-      } else {
-        for (const [name, binPath] of Object.entries(rootPkg2.bin)) {
-          if (typeof binPath === "string" && !binPath.startsWith("./dist/")) {
-            rootPkg2.bin[name] = "./" + Path.join("dist", binPath);
-          }
-        }
-      }
-    }
-    if (pkg.files !== void 0) {
-      if (!rootPkg2.files) {
-        rootPkg2.files = [];
-      } else if (!Array.isArray(rootPkg2.files)) {
-        rootPkg2.files = [rootPkg2.files];
-      }
-      for (const autoFile of autoDiscoveredFiles) {
-        if (!rootPkg2.files.includes(autoFile)) {
-          rootPkg2.files.push(autoFile);
-        }
-      }
-      if (!rootPkg2.files.includes("dist/") && !rootPkg2.files.includes("dist")) {
-        rootPkg2.files.push("dist/");
-      }
-    }
-    await FS.writeFile(pkgPath, JSON.stringify(rootPkg2, null, 2) + "\n");
-  } else {
-    console.log("  Skipping root package.json update (use --save to enable)");
-  }
-  console.log("\nBuild complete!");
-  console.log(`
-  Output: ${distDir}`);
-  console.log(`
-  Entries: ${entries.length}`);
-  if (options.formats.cjs) {
-    console.log(`
-  Formats: ESM, CJS${options.formats.umd ? ", UMD" : ""}`);
-  } else {
-    console.log(`
-  Formats: ESM${options.formats.umd ? ", UMD" : ""}`);
-  }
-  let rootPkg = pkg;
-  if (save) {
-    rootPkg = JSON.parse(await FS.readFile(pkgPath, "utf-8"));
-  }
-  return { distPkg: fixedDistPkg, rootPkg };
-}
-async function publish(cwd, save = true) {
-  await build2(cwd, save);
-  console.log("\nPublishing to npm...");
-  const distDir = Path.join(cwd, "dist");
-  const distPkgPath = Path.join(distDir, "package.json");
-  if (!await fileExists(distPkgPath)) {
-    throw new Error("No dist/package.json found. Run 'libuild build' first.");
-  }
-  const distPkg = JSON.parse(await FS.readFile(distPkgPath, "utf-8"));
-  const publishArgs = ["publish"];
-  if (distPkg.name.startsWith("@")) {
-    publishArgs.push("--access", "public");
-  }
-  const proc = spawn("npm", publishArgs, {
-    cwd: distDir,
-    stdio: "inherit"
-  });
-  const exitCode = await new Promise((resolve) => {
-    proc.on("close", resolve);
-  });
-  if (exitCode === 0) {
-    const distPkg2 = JSON.parse(await FS.readFile(distPkgPath, "utf-8"));
-    console.log(`
-Published ${distPkg2.name}@${distPkg2.version}!`);
-  } else {
-    throw new Error("npm publish failed");
-  }
-}
-
-export {
-  transformSrcToDist,
-  build2 as build,
-  publish
-};
-//# sourceMappingURL=chunk-YRPHTAV4.js.map