@yaonyan/jsr2npm 0.1.8 → 0.1.10

package/bin/jsr2npm.cjs

@@ -0,0 +1,596 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// __yao__jsr2npm_latest/node_modules/@yao/jsr2npm/config.js
+var import_promises = require("node:fs/promises");
+var import_node_path = require("node:path");
+var import_node_process = __toESM(require("node:process"), 1);
+async function loadConfig(configPath) {
+  try {
+    const absolutePath = (0, import_node_path.resolve)(import_node_process.default.cwd(), configPath);
+    const content = await (0, import_promises.readFile)(absolutePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+// __yao__jsr2npm_latest/node_modules/@yao/jsr2npm/converter.js
+var import_dax_sh = __toESM(require("dax-sh"), 1);
+var import_promises4 = require("node:fs/promises");
+var import_node_path4 = require("node:path");
+var import_node_fs = require("node:fs");
+var import_node_process2 = __toESM(require("node:process"), 1);
+
+// __yao__jsr2npm_latest/node_modules/@yao/jsr2npm/bundler.js
+var import_promises2 = require("node:fs/promises");
+var import_node_path2 = require("node:path");
+var import_esbuild = require("esbuild");
+async function bundleWithEsbuild(packageDir, inputFile, outputFile, externalPackages = [], useBrowserPlatform = false) {
+  const entryPath = (0, import_node_path2.join)(process.cwd(), packageDir, inputFile);
+  const baseName = outputFile.replace(/\.mjs$/, "");
+  const esmOutputPath = (0, import_node_path2.join)(process.cwd(), packageDir, "dist", `${baseName}.mjs`);
+  const cjsOutputPath = (0, import_node_path2.join)(process.cwd(), packageDir, "dist", `${baseName}.cjs`);
+  const outputDir = esmOutputPath.split("/").slice(0, -1).join("/");
+  await (0, import_promises2.mkdir)(outputDir, {
+    recursive: true
+  });
+  const externalList = externalPackages.length > 0 ? externalPackages.join(", ") : "none";
+  console.log(`  \u{1F4E6} External packages: ${externalList}`);
+  const platform = useBrowserPlatform ? "neutral" : "node";
+  const esmBanner = useBrowserPlatform ? {} : {
+    js: `#!/usr/bin/env node
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);`
+  };
+  const cjsBanner = useBrowserPlatform ? {} : {
+    js: `#!/usr/bin/env node`
+  };
+  console.log(`  \u{1F527} Platform: ${platform}${useBrowserPlatform ? " (browser)" : ""}`);
+  await (0, import_esbuild.build)({
+    entryPoints: [
+      entryPath
+    ],
+    bundle: true,
+    platform,
+    format: "esm",
+    outfile: esmOutputPath,
+    external: externalPackages,
+    packages: "bundle",
+    banner: esmBanner,
+    write: true
+  });
+  await (0, import_esbuild.build)({
+    entryPoints: [
+      entryPath
+    ],
+    bundle: true,
+    platform,
+    format: "cjs",
+    outfile: cjsOutputPath,
+    external: externalPackages,
+    packages: "bundle",
+    banner: cjsBanner,
+    write: true
+  });
+  console.log(`  \u2705 Built ESM: ${baseName}.mjs`);
+  console.log(`  \u2705 Built CJS: ${baseName}.cjs`);
+}
+async function copyTypeDeclarations(packageDir) {
+  console.log("\n\u{1F4DD} Copying TypeScript declarations...");
+  const sourceDir = (0, import_node_path2.join)(packageDir, "_dist");
+  const targetDir = (0, import_node_path2.join)(packageDir, "dist", "types");
+  try {
+    await (0, import_promises2.stat)(sourceDir);
+    await (0, import_promises2.mkdir)(targetDir, {
+      recursive: true
+    });
+    const entries = await (0, import_promises2.readdir)(sourceDir, {
+      withFileTypes: true
+    });
+    for (const entry of entries) {
+      const source = (0, import_node_path2.join)(sourceDir, entry.name);
+      const target = (0, import_node_path2.join)(targetDir, entry.name);
+      if (entry.isFile()) {
+        await (0, import_promises2.copyFile)(source, target);
+      } else if (entry.isDirectory()) {
+        await copyDirectory(source, target);
+      }
+      console.log(`  \u2705 Copied ${entry.name}`);
+    }
+    console.log("\u2705 TypeScript declarations copied");
+  } catch {
+    console.warn("\u26A0\uFE0F No TypeScript declarations found");
+  }
+}
+async function copyDirectory(source, target) {
+  await (0, import_promises2.mkdir)(target, {
+    recursive: true
+  });
+  const entries = await (0, import_promises2.readdir)(source, {
+    withFileTypes: true
+  });
+  for (const entry of entries) {
+    const sourcePath = (0, import_node_path2.join)(source, entry.name);
+    const targetPath = (0, import_node_path2.join)(target, entry.name);
+    if (entry.isFile()) {
+      await (0, import_promises2.copyFile)(sourcePath, targetPath);
+    } else if (entry.isDirectory()) {
+      await copyDirectory(sourcePath, targetPath);
+    }
+  }
+}
+
+// __yao__jsr2npm_latest/node_modules/@yao/jsr2npm/package-generator.js
+var import_promises3 = require("node:fs/promises");
+var import_node_path3 = require("node:path");
+async function generatePackageJson(packageDir, bin, overrides, allDependencies) {
+  console.log("\n\u{1F4CB} Generating package.json...");
+  const jsrPkg = await readPackageJson(`${packageDir}/package.json`);
+  const denoJson = await readDenoJson(packageDir);
+  const dependencies = allDependencies || getNpmDependencies(jsrPkg.dependencies);
+  const newPkg = buildPackageJson(jsrPkg, denoJson, dependencies, bin, overrides);
+  await (0, import_promises3.writeFile)((0, import_node_path3.join)(packageDir, "dist", "package.json"), JSON.stringify(newPkg, null, 2));
+  console.log(`\u2705 Generated package.json with ${Object.keys(dependencies).length} dependencies`);
+}
+async function readPackageJson(path) {
+  try {
+    const content = await (0, import_promises3.readFile)(path, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return {
+      name: "converted-package",
+      version: "1.0.0",
+      license: "MIT"
+    };
+  }
+}
+async function readDenoJson(packageDir) {
+  for (const file of [
+    "deno.json",
+    "deno.jsonc"
+  ]) {
+    try {
+      const content = await (0, import_promises3.readFile)((0, import_node_path3.join)(packageDir, file), "utf-8");
+      console.log(`\u2705 Found ${file}`);
+      return JSON.parse(content);
+    } catch {
+      continue;
+    }
+  }
+  return {};
+}
+function getNpmDependencies(deps) {
+  if (!deps || typeof deps !== "object") return {};
+  const npmDeps = {};
+  for (const [name, version] of Object.entries(deps)) {
+    if (!name.startsWith("@jsr/")) {
+      npmDeps[name] = String(version);
+      console.log(`  \u{1F4CC} ${name}: ${version}`);
+    }
+  }
+  return npmDeps;
+}
+function buildPackageJson(jsrPkg, denoJson, dependencies, bin, overrides) {
+  const pkg = {
+    ...jsrPkg,
+    dependencies
+  };
+  delete pkg.type;
+  mergeMetadata(pkg, denoJson);
+  addBugsUrl(pkg);
+  delete pkg._jsr_revision;
+  delete pkg.devDependencies;
+  buildExports(pkg, denoJson, bin);
+  const originalName = String(jsrPkg.name || "package");
+  pkg.name = `@jsr2npm/${originalName.split("/").pop()}`;
+  applyOverrides(pkg, overrides);
+  return pkg;
+}
+function mergeMetadata(pkg, denoJson) {
+  const fields = [
+    "description",
+    "author",
+    "license",
+    "repository",
+    "keywords"
+  ];
+  for (const field of fields) {
+    if (denoJson[field] && !pkg[field]) {
+      pkg[field] = denoJson[field];
+      const extra = field === "keywords" ? ` (${denoJson[field].length} items)` : "";
+      console.log(`  \u{1F4DD} Using ${field} from deno.json${extra}`);
+    }
+  }
+}
+function addBugsUrl(pkg) {
+  if (!pkg.repository || pkg.bugs) return;
+  const repoUrl = typeof pkg.repository === "string" ? pkg.repository : pkg.repository?.url;
+  if (!repoUrl) return;
+  const cleanUrl = repoUrl.replace(/^git\+/, "").replace(/\.git$/, "");
+  pkg.bugs = {
+    url: `${cleanUrl}/issues`
+  };
+  console.log(`  \u{1F41B} Added bugs URL`);
+}
+function buildExports(pkg, denoJson, bin) {
+  if (bin && Object.keys(bin).length > 0) {
+    buildBinExports(pkg, bin);
+  } else if (denoJson.exports) {
+    buildLibraryExports(pkg, denoJson);
+  } else {
+    pkg.exports = {
+      "./types/*": "./types/*"
+    };
+    console.log(`  \u26A0\uFE0F  No exports found, only exposing types`);
+  }
+}
+function buildBinExports(pkg, bin) {
+  const binCommands = {};
+  const exports2 = {};
+  for (const cmdName of Object.keys(bin)) {
+    binCommands[cmdName] = `./bin/${cmdName}.mjs`;
+    exports2[`./bin/${cmdName}`] = {
+      import: `./bin/${cmdName}.mjs`,
+      require: `./bin/${cmdName}.cjs`
+    };
+  }
+  pkg.bin = binCommands;
+  const firstCmd = Object.keys(bin)[0];
+  exports2["."] = {
+    import: `./bin/${firstCmd}.mjs`,
+    require: `./bin/${firstCmd}.cjs`
+  };
+  pkg.exports = exports2;
+  pkg.main = `./bin/${firstCmd}.cjs`;
+  pkg.module = `./bin/${firstCmd}.mjs`;
+  console.log(`  \u{1F527} Added bin commands: ${Object.keys(binCommands).join(", ")}`);
+}
+function buildLibraryExports(pkg, denoJson) {
+  const exports2 = {};
+  const denoExports = denoJson.exports;
+  for (const [key, value] of Object.entries(denoExports)) {
+    const tsPath = typeof value === "string" ? value : null;
+    if (!tsPath) continue;
+    const baseName = key === "." ? "index" : key.replace(/^\.\//, "");
+    const dtsFile = tsPath.replace(/\.ts$/, ".d.ts").replace(/^\.\//, "");
+    exports2[key] = {
+      types: `./types/${dtsFile}`,
+      import: `./${baseName}.mjs`,
+      require: `./${baseName}.cjs`
+    };
+  }
+  exports2["./types/*"] = "./types/*";
+  pkg.exports = exports2;
+  const mainExport = exports2["."];
+  if (mainExport) {
+    pkg.main = mainExport.require;
+    pkg.module = mainExport.import;
+  }
+  console.log(`  \u{1F4E6} Built exports for ${Object.keys(denoExports).length} entry points (ESM + CJS)`);
+}
+function applyOverrides(pkg, overrides) {
+  if (!overrides) return;
+  const fields = [
+    "name",
+    "version",
+    "description",
+    "license",
+    "author",
+    "repository",
+    "homepage"
+  ];
+  for (const field of fields) {
+    const value = overrides[field];
+    if (value) {
+      pkg[field] = value;
+      console.log(`  \u270F\uFE0F  Overriding ${field}`);
+    }
+  }
+  if (overrides.keywords) {
+    pkg.keywords = overrides.keywords;
+    console.log(`  \u270F\uFE0F  Overriding keywords (${overrides.keywords.length} items)`);
+  }
+  if (overrides.scripts) {
+    const existingScripts = pkg.scripts || {};
+    pkg.scripts = {
+      ...existingScripts,
+      ...overrides.scripts
+    };
+    console.log(`  \u270F\uFE0F  Merging scripts`);
+  }
+}
+async function copyExtraFiles(sourceDir, targetDir) {
+  console.log("\n\u{1F4C4} Copying extra files...");
+  const files = [
+    "README.md",
+    "README",
+    "LICENSE",
+    "LICENSE.md"
+  ];
+  for (const file of files) {
+    try {
+      await (0, import_promises3.stat)((0, import_node_path3.join)(sourceDir, file));
+      await (0, import_promises3.copyFile)((0, import_node_path3.join)(sourceDir, file), (0, import_node_path3.join)(targetDir, file));
+      console.log(`  \u2705 Copied ${file}`);
+    } catch {
+    }
+  }
+}
+
+// __yao__jsr2npm_latest/node_modules/@yao/jsr2npm/converter.js
+async function convertPackage(packageName, version, bin, overrides, browser) {
+  console.log(`
+\u{1F4E6} Package: ${packageName}`);
+  console.log(`\u{1F3F7}\uFE0F  Version: ${version}`);
+  if (bin) {
+    console.log(`\u{1F527} CLI Commands: ${Object.keys(bin).join(", ")}`);
+  }
+  if (browser) {
+    console.log(`\u{1F310} Browser mode: enabled`);
+  }
+  const workspaceDir = createWorkspace(packageName, version);
+  const originalCwd = import_node_process2.default.cwd();
+  try {
+    import_node_process2.default.chdir(workspaceDir);
+    await installJSRPackage(packageName, version);
+    const packageDir = (0, import_node_path4.join)("node_modules", packageName);
+    await (0, import_promises4.mkdir)((0, import_node_path4.join)(packageDir, "dist"), {
+      recursive: true
+    });
+    const { externals, allDependencies } = await getExternalPackages(packageDir, overrides);
+    await bundlePackage(packageDir, bin, externals, browser);
+    await copyTypeDeclarations(packageDir);
+    await copyExtraFiles(packageDir, `${packageDir}/dist`);
+    await generatePackageJson(packageDir, bin, overrides, allDependencies);
+    await moveDistToRoot(packageDir);
+    console.log("\n\u2705 Conversion completed!");
+    console.log(`\u{1F4C2} Output: ${workspaceDir}/dist`);
+  } finally {
+    import_node_process2.default.chdir(originalCwd);
+  }
+}
+function createWorkspace(packageName, version) {
+  const folderName = packageName.replace(/[@\/]/g, "__") + `_${version}`;
+  (0, import_node_fs.mkdirSync)(folderName, {
+    recursive: true
+  });
+  console.log(`\u{1F4C1} Created folder: ${folderName}`);
+  return folderName;
+}
+async function getExternalPackages(packageDir, overrides) {
+  try {
+    const content = await (0, import_promises4.readFile)((0, import_node_path4.join)(packageDir, "package.json"), "utf-8");
+    const pkgJson = JSON.parse(content);
+    const userDependencies = overrides?.dependencies || {};
+    if (!pkgJson.dependencies && Object.keys(userDependencies).length === 0) {
+      return {
+        externals: [],
+        allDependencies: {}
+      };
+    }
+    const topLevelDeps = {};
+    if (pkgJson.dependencies) {
+      for (const [name, version] of Object.entries(pkgJson.dependencies)) {
+        if (!name.startsWith("@jsr/")) {
+          topLevelDeps[name] = String(version);
+        }
+      }
+    }
+    for (const [name, version] of Object.entries(userDependencies)) {
+      topLevelDeps[name] = version;
+    }
+    const jsrPackages = pkgJson.dependencies ? Object.keys(pkgJson.dependencies).filter((name) => name.startsWith("@jsr/")) : [];
+    const conflictingPackages = await findConflictingPackages(packageDir, jsrPackages, topLevelDeps);
+    const externals = Object.keys(topLevelDeps).filter((name) => !conflictingPackages.has(name));
+    const externalList = externals.join(", ") || "none";
+    console.log(`
+\u{1F4E6} External dependencies (${externals.length}): ${externalList}`);
+    if (Object.keys(userDependencies).length > 0) {
+      const userDepsList = Object.keys(userDependencies).join(", ");
+      console.log(`\u{1F4DD} User-configured dependencies: ${userDepsList}`);
+    }
+    if (conflictingPackages.size > 0) {
+      const conflictList = Array.from(conflictingPackages).join(", ");
+      console.log(`\u26A0\uFE0F  Version conflicts, will bundle: ${conflictList}`);
+    }
+    return {
+      externals,
+      allDependencies: topLevelDeps
+    };
+  } catch {
+    return {
+      externals: [],
+      allDependencies: {}
+    };
+  }
+}
+async function findConflictingPackages(packageDir, jsrPackages, topLevelDeps) {
+  const conflicts = /* @__PURE__ */ new Set();
+  const parts = packageDir.split(/[\/\\]/);
+  const nodeModulesIndex = parts.indexOf("node_modules");
+  const rootNodeModules = parts.slice(0, nodeModulesIndex + 1).join("/");
+  for (const jsrPkg of jsrPackages) {
+    try {
+      const jsrPkgPath = (0, import_node_path4.join)(rootNodeModules, jsrPkg, "package.json");
+      const jsrContent = await (0, import_promises4.readFile)(jsrPkgPath, "utf-8");
+      const jsrPkgJson = JSON.parse(jsrContent);
+      if (!jsrPkgJson.dependencies) continue;
+      for (const [depName, depVersion] of Object.entries(jsrPkgJson.dependencies)) {
+        if (depName.startsWith("@jsr/")) continue;
+        if (topLevelDeps[depName]) {
+          if (topLevelDeps[depName] !== depVersion) {
+            conflicts.add(depName);
+            console.log(`  \u26A0\uFE0F  Version conflict for ${depName}:`);
+            console.log(`      Top-level: ${topLevelDeps[depName]}`);
+            console.log(`      ${jsrPkg}: ${depVersion}`);
+          }
+        } else {
+          topLevelDeps[depName] = String(depVersion);
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  return conflicts;
+}
+async function bundlePackage(packageDir, bin, externalPackages, browser) {
+  if (bin) {
+    await bundleBinCommands(packageDir, bin, externalPackages, browser);
+  } else {
+    await bundleLibraryExports(packageDir, externalPackages, browser);
+  }
+}
+async function bundleBinCommands(packageDir, bin, externalPackages, browser) {
+  console.log("\n\u{1F528} Bundling CLI tools...");
+  for (const [cmdName, inputFile] of Object.entries(bin)) {
+    await verifyEntrypoint(packageDir, inputFile);
+    const outputFile = `bin/${cmdName}.mjs`;
+    await bundleWithEsbuild(packageDir, inputFile, outputFile, externalPackages, browser || false);
+    const outputPath = (0, import_node_path4.join)(packageDir, "dist", outputFile);
+    await (0, import_promises4.chmod)(outputPath, 493);
+    console.log(`  \u2705 Created ${cmdName}: ${outputFile}`);
+  }
+}
+async function bundleLibraryExports(packageDir, externalPackages, browser) {
+  const exports2 = await readDenoJsonExports(packageDir);
+  if (!exports2) return;
+  console.log("\n\u{1F528} Bundling library exports...");
+  for (const [exportKey, inputFile] of Object.entries(exports2)) {
+    await verifyEntrypoint(packageDir, inputFile);
+    const outputFile = exportKey === "." ? "index.mjs" : `${exportKey.replace(/^\.\//, "")}.mjs`;
+    await bundleWithEsbuild(packageDir, inputFile, outputFile, externalPackages, browser || false);
+    console.log(`  \u2705 Bundled ${exportKey}: ${outputFile}`);
+  }
+}
+async function installJSRPackage(packageName, version) {
+  await (0, import_promises4.writeFile)("package.json", "{}");
+  const packageSpec = version === "latest" ? packageName : `${packageName}@${version}`;
+  console.log(`\u{1F504} Installing: ${packageSpec}`);
+  await import_dax_sh.default`npx jsr add ${packageSpec}`.cwd(import_node_process2.default.cwd());
+}
+async function verifyEntrypoint(packageDir, entrypoint) {
+  try {
+    await (0, import_promises4.stat)((0, import_node_path4.join)(packageDir, entrypoint));
+    console.log(`\u2705 Found ${entrypoint}`);
+  } catch {
+    throw new Error(`\u274C ${entrypoint} not found in ${packageDir}`);
+  }
+}
+async function readDenoJsonExports(packageDir) {
+  for (const file of [
+    "deno.json",
+    "deno.jsonc"
+  ]) {
+    try {
+      const content = await (0, import_promises4.readFile)((0, import_node_path4.join)(packageDir, file), "utf-8");
+      const denoJson = JSON.parse(content);
+      if (!denoJson.exports) continue;
+      const exports2 = {};
+      for (const [key, value] of Object.entries(denoJson.exports)) {
+        const path = typeof value === "string" ? value : null;
+        if (path?.endsWith(".ts")) {
+          exports2[key] = path;
+        }
+      }
+      return Object.keys(exports2).length > 0 ? exports2 : null;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+async function moveDistToRoot(packageDir) {
+  const sourceDist = (0, import_node_path4.join)(packageDir, "dist");
+  const targetDist = (0, import_node_path4.join)(import_node_process2.default.cwd(), "dist");
+  try {
+    await (0, import_promises4.rm)(targetDist, {
+      recursive: true
+    });
+  } catch {
+  }
+  await (0, import_promises4.rename)(sourceDist, targetDist);
+  await copyExtraFiles(packageDir, targetDist);
+}
+
+// __yao__jsr2npm_latest/node_modules/@yao/jsr2npm/cli.ts
+var import_meta = {};
+async function main() {
+  console.log("\u{1F680} JSR to NPM Package Converter\n");
+  const configFile = process.argv[2] || "jsr2npm.config.json";
+  const config = await loadConfig(configFile);
+  if (!config?.packages?.length) {
+    console.error("\u274C No packages found in jsr2npm.config.json");
+    console.log("\n\u{1F4A1} Create a jsr2npm.config.json file with your packages:");
+    console.log(`
+{
+  "packages": [
+    {
+      "name": "@scope/package",
+      "version": "1.0.0",
+      "bin": {
+        "your-command": "src/bin.ts"
+      },
+      "packageJson": {
+        "name": "@myorg/custom-name",
+        "description": "Package description"
+      }
+    }
+  ]
+}
+    `);
+    process.exit(1);
+  }
+  console.log(`\u{1F4CB} Found ${config.packages.length} package(s) in config
+`);
+  for (const pkg of config.packages) {
+    console.log(`
+${"=".repeat(60)}`);
+    console.log(`Converting: ${pkg.name}@${pkg.version}`);
+    console.log("=".repeat(60));
+    try {
+      await convertPackage(
+        pkg.name,
+        pkg.version,
+        pkg.bin,
+        pkg.packageJson,
+        pkg.browser
+      );
+    } catch (error) {
+      console.error(
+        `
+\u274C Failed to convert ${pkg.name}:`,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  console.log(`
+${"=".repeat(60)}`);
+  console.log("\u2705 All packages processed!");
+  console.log("=".repeat(60));
+}
+if (import_meta.main) {
+  main().catch(console.error);
+}

package/bin/jsr2npm.mjs

@@ -21,6 +21,7 @@ import $ from "dax-sh";
 import { chmod, mkdir as mkdir2, readFile as readFile3, rename, rm, stat as stat3, writeFile as writeFile2 } from "node:fs/promises";
 import { join as join3 } from "node:path";
 import { mkdirSync } from "node:fs";
+import process3 from "node:process";
 
 // __yao__jsr2npm_latest/node_modules/@yao/jsr2npm/bundler.js
 import { copyFile, mkdir, readdir, stat } from "node:fs/promises";
@@ -28,19 +29,24 @@ import { join } from "node:path";
 import { build } from "esbuild";
 async function bundleWithEsbuild(packageDir, inputFile, outputFile, externalPackages = [], useBrowserPlatform = false) {
   const entryPath = join(process.cwd(), packageDir, inputFile);
-  const outputPath = join(process.cwd(), packageDir, "dist", outputFile);
-  const outputDir = outputPath.split("/").slice(0, -1).join("/");
+  const baseName = outputFile.replace(/\.mjs$/, "");
+  const esmOutputPath = join(process.cwd(), packageDir, "dist", `${baseName}.mjs`);
+  const cjsOutputPath = join(process.cwd(), packageDir, "dist", `${baseName}.cjs`);
+  const outputDir = esmOutputPath.split("/").slice(0, -1).join("/");
   await mkdir(outputDir, {
     recursive: true
   });
   const externalList = externalPackages.length > 0 ? externalPackages.join(", ") : "none";
   console.log(`  \u{1F4E6} External packages: ${externalList}`);
   const platform = useBrowserPlatform ? "neutral" : "node";
-  const banner = useBrowserPlatform ? {} : {
+  const esmBanner = useBrowserPlatform ? {} : {
     js: `#!/usr/bin/env node
 import { createRequire } from 'node:module';
 const require = createRequire(import.meta.url);`
   };
+  const cjsBanner = useBrowserPlatform ? {} : {
+    js: `#!/usr/bin/env node`
+  };
   console.log(`  \u{1F527} Platform: ${platform}${useBrowserPlatform ? " (browser)" : ""}`);
   await build({
     entryPoints: [
@@ -49,12 +55,27 @@ const require = createRequire(import.meta.url);`
     bundle: true,
     platform,
     format: "esm",
-    outfile: outputPath,
+    outfile: esmOutputPath,
+    external: externalPackages,
+    packages: "bundle",
+    banner: esmBanner,
+    write: true
+  });
+  await build({
+    entryPoints: [
+      entryPath
+    ],
+    bundle: true,
+    platform,
+    format: "cjs",
+    outfile: cjsOutputPath,
     external: externalPackages,
     packages: "bundle",
-    banner,
+    banner: cjsBanner,
     write: true
   });
+  console.log(`  \u2705 Built ESM: ${baseName}.mjs`);
+  console.log(`  \u2705 Built CJS: ${baseName}.cjs`);
 }
 async function copyTypeDeclarations(packageDir) {
   console.log("\n\u{1F4DD} Copying TypeScript declarations...");
@@ -154,9 +175,9 @@ function getNpmDependencies(deps) {
 function buildPackageJson(jsrPkg, denoJson, dependencies, bin, overrides) {
   const pkg = {
     ...jsrPkg,
-    type: "module",
     dependencies
   };
+  delete pkg.type;
   mergeMetadata(pkg, denoJson);
   addBugsUrl(pkg);
   delete pkg._jsr_revision;
@@ -210,13 +231,20 @@ function buildBinExports(pkg, bin) {
   const exports = {};
   for (const cmdName of Object.keys(bin)) {
     binCommands[cmdName] = `./bin/${cmdName}.mjs`;
-    exports[`./bin/${cmdName}`] = `./bin/${cmdName}.mjs`;
+    exports[`./bin/${cmdName}`] = {
+      import: `./bin/${cmdName}.mjs`,
+      require: `./bin/${cmdName}.cjs`
+    };
   }
   pkg.bin = binCommands;
   const firstCmd = Object.keys(bin)[0];
-  exports["."] = `./bin/${firstCmd}.mjs`;
+  exports["."] = {
+    import: `./bin/${firstCmd}.mjs`,
+    require: `./bin/${firstCmd}.cjs`
+  };
   pkg.exports = exports;
-  pkg.main = `./bin/${firstCmd}.mjs`;
+  pkg.main = `./bin/${firstCmd}.cjs`;
+  pkg.module = `./bin/${firstCmd}.mjs`;
   console.log(`  \u{1F527} Added bin commands: ${Object.keys(binCommands).join(", ")}`);
 }
 function buildLibraryExports(pkg, denoJson) {
@@ -225,20 +253,22 @@ function buildLibraryExports(pkg, denoJson) {
   for (const [key, value] of Object.entries(denoExports)) {
     const tsPath = typeof value === "string" ? value : null;
     if (!tsPath) continue;
-    const mjsFile = key === "." ? "index.mjs" : `${key.replace(/^\.\//, "")}.mjs`;
+    const baseName = key === "." ? "index" : key.replace(/^\.\//, "");
     const dtsFile = tsPath.replace(/\.ts$/, ".d.ts").replace(/^\.\//, "");
     exports[key] = {
       types: `./types/${dtsFile}`,
-      import: `./${mjsFile}`
+      import: `./${baseName}.mjs`,
+      require: `./${baseName}.cjs`
     };
   }
   exports["./types/*"] = "./types/*";
   pkg.exports = exports;
   const mainExport = exports["."];
-  if (mainExport && typeof mainExport === "object" && "import" in mainExport) {
-    pkg.main = mainExport.import;
+  if (mainExport) {
+    pkg.main = mainExport.require;
+    pkg.module = mainExport.import;
   }
-  console.log(`  \u{1F4E6} Built exports for ${Object.keys(denoExports).length} entry points`);
+  console.log(`  \u{1F4E6} Built exports for ${Object.keys(denoExports).length} entry points (ESM + CJS)`);
 }
 function applyOverrides(pkg, overrides) {
   if (!overrides) return;
@@ -301,15 +331,15 @@ async function convertPackage(packageName, version, bin, overrides, browser) {
     console.log(`\u{1F310} Browser mode: enabled`);
   }
   const workspaceDir = createWorkspace(packageName, version);
-  const originalCwd = process.cwd();
+  const originalCwd = process3.cwd();
   try {
-    process.chdir(workspaceDir);
+    process3.chdir(workspaceDir);
     await installJSRPackage(packageName, version);
     const packageDir = join3("node_modules", packageName);
     await mkdir2(join3(packageDir, "dist"), {
       recursive: true
     });
-    const { externals, allDependencies } = await getExternalPackages(packageDir);
+    const { externals, allDependencies } = await getExternalPackages(packageDir, overrides);
     await bundlePackage(packageDir, bin, externals, browser);
     await copyTypeDeclarations(packageDir);
     await copyExtraFiles(packageDir, `${packageDir}/dist`);
@@ -318,7 +348,7 @@ async function convertPackage(packageName, version, bin, overrides, browser) {
     console.log("\n\u2705 Conversion completed!");
     console.log(`\u{1F4C2} Output: ${workspaceDir}/dist`);
   } finally {
-    process.chdir(originalCwd);
+    process3.chdir(originalCwd);
   }
 }
 function createWorkspace(packageName, version) {
@@ -329,26 +359,38 @@ function createWorkspace(packageName, version) {
   console.log(`\u{1F4C1} Created folder: ${folderName}`);
   return folderName;
 }
-async function getExternalPackages(packageDir) {
+async function getExternalPackages(packageDir, overrides) {
   try {
     const content = await readFile3(join3(packageDir, "package.json"), "utf-8");
     const pkgJson = JSON.parse(content);
-    if (!pkgJson.dependencies) return {
-      externals: [],
-      allDependencies: {}
-    };
+    const userDependencies = overrides?.dependencies || {};
+    if (!pkgJson.dependencies && Object.keys(userDependencies).length === 0) {
+      return {
+        externals: [],
+        allDependencies: {}
+      };
+    }
     const topLevelDeps = {};
-    for (const [name, version] of Object.entries(pkgJson.dependencies)) {
-      if (!name.startsWith("@jsr/")) {
-        topLevelDeps[name] = String(version);
+    if (pkgJson.dependencies) {
+      for (const [name, version] of Object.entries(pkgJson.dependencies)) {
+        if (!name.startsWith("@jsr/")) {
+          topLevelDeps[name] = String(version);
+        }
       }
     }
-    const jsrPackages = Object.keys(pkgJson.dependencies).filter((name) => name.startsWith("@jsr/"));
+    for (const [name, version] of Object.entries(userDependencies)) {
+      topLevelDeps[name] = version;
+    }
+    const jsrPackages = pkgJson.dependencies ? Object.keys(pkgJson.dependencies).filter((name) => name.startsWith("@jsr/")) : [];
     const conflictingPackages = await findConflictingPackages(packageDir, jsrPackages, topLevelDeps);
     const externals = Object.keys(topLevelDeps).filter((name) => !conflictingPackages.has(name));
     const externalList = externals.join(", ") || "none";
     console.log(`
 \u{1F4E6} External dependencies (${externals.length}): ${externalList}`);
+    if (Object.keys(userDependencies).length > 0) {
+      const userDepsList = Object.keys(userDependencies).join(", ");
+      console.log(`\u{1F4DD} User-configured dependencies: ${userDepsList}`);
+    }
     if (conflictingPackages.size > 0) {
       const conflictList = Array.from(conflictingPackages).join(", ");
       console.log(`\u26A0\uFE0F  Version conflicts, will bundle: ${conflictList}`);
@@ -427,7 +469,7 @@ async function installJSRPackage(packageName, version) {
   await writeFile2("package.json", "{}");
   const packageSpec = version === "latest" ? packageName : `${packageName}@${version}`;
   console.log(`\u{1F504} Installing: ${packageSpec}`);
-  await $`npx jsr add ${packageSpec}`.cwd(process.cwd());
+  await $`npx jsr add ${packageSpec}`.cwd(process3.cwd());
 }
 async function verifyEntrypoint(packageDir, entrypoint) {
   try {
@@ -462,7 +504,7 @@ async function readDenoJsonExports(packageDir) {
 }
 async function moveDistToRoot(packageDir) {
   const sourceDist = join3(packageDir, "dist");
-  const targetDist = join3(process.cwd(), "dist");
+  const targetDist = join3(process3.cwd(), "dist");
   try {
     await rm(targetDist, {
       recursive: true

package/package.json

@@ -1,15 +1,20 @@
 {
   "name": "@yaonyan/jsr2npm",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "homepage": "https://jsr.io/@yao/jsr2npm",
-  "type": "module",
   "dependencies": {
     "dax-sh": "^0.43.2",
     "esbuild": "^0.25.10"
   },
   "exports": {
-    "./bin/jsr2npm": "./bin/jsr2npm.mjs",
-    ".": "./bin/jsr2npm.mjs"
+    "./bin/jsr2npm": {
+      "import": "./bin/jsr2npm.mjs",
+      "require": "./bin/jsr2npm.cjs"
+    },
+    ".": {
+      "import": "./bin/jsr2npm.mjs",
+      "require": "./bin/jsr2npm.cjs"
+    }
   },
   "license": "MIT",
   "repository": {
@@ -22,5 +27,6 @@
   "bin": {
     "jsr2npm": "./bin/jsr2npm.mjs"
   },
-  "main": "./bin/jsr2npm.mjs"
+  "main": "./bin/jsr2npm.cjs",
+  "module": "./bin/jsr2npm.mjs"
 }