jiek 2.2.7 → 2.3.1

package/dist/{cli.js → .internal/.chunks/index.B6RQz1DZ.js}

@@ -1,112 +1,5 @@
-import * as childProcess from 'node:child_process';
-import fs from 'node:fs';
-import path, { isAbsolute, relative, resolve } from 'node:path';
-import process$1 from 'node:process';
-import { TAGS, bump } from '@jiek/utils/bumper';
-import { program } from 'commander';
-import detectIndent from 'detect-indent';
-import { applyEdits, modify } from 'jsonc-parser';
-import { createRequire } from 'node:module';
-import { load } from 'js-yaml';
-import { isWorkspaceDir, getWorkspaceDir } from '@jiek/utils/getWorkspaceDir';
-import { resolveEntrypoints, filterLeafs, DEFAULT_SKIP_VALUES, entrypoints2Exports } from '@jiek/pkger/entrypoints';
 import require$$0 from 'util';
 import require$$0$1 from 'path';
-import 'jiek/cli-only-build';
-
-var require = /* @__PURE__ */ createRequire(import.meta.url);
-
-let root;
-function getRoot() {
-  if (root) return root;
-  const rootOption = process.env.JIEK_ROOT;
-  root = rootOption ? path.isAbsolute(rootOption) ? rootOption : path.resolve(process.cwd(), rootOption) : void 0;
-  return root;
-}
-
-let wd;
-let notWorkspace = false;
-function getWD() {
-  if (wd) return { wd, notWorkspace };
-  const root = getRoot();
-  if (root !== void 0) {
-    const isWorkspace = isWorkspaceDir(root, type);
-    notWorkspace = !isWorkspace;
-    wd = root;
-    return { wd, notWorkspace };
-  }
-  try {
-    wd = getWorkspaceDir(type);
-  } catch (e) {
-    if ("message" in e && e.message === "workspace root not found") {
-      wd = root ?? process.cwd();
-      notWorkspace = true;
-    } else {
-      throw e;
-    }
-  }
-  return { wd, notWorkspace };
-}
-
-let type = "";
-try {
-  require.resolve("@pnpm/filter-workspace-packages");
-  type = "pnpm";
-} catch {
-}
-async function getSelectedProjectsGraph(filter = program.getOptionValue("filter")) {
-  const { wd, notWorkspace } = getWD();
-  let root = getRoot();
-  if (notWorkspace) {
-    return {
-      wd,
-      root,
-      value: {
-        [wd]: JSON.parse(fs.readFileSync(path.resolve(wd, "package.json"), "utf-8"))
-      }
-    };
-  }
-  if (type === "pnpm") {
-    const pnpmWorkspaceFilePath = path.resolve(wd, "pnpm-workspace.yaml");
-    const pnpmWorkspaceFileContent = fs.readFileSync(pnpmWorkspaceFilePath, "utf-8");
-    const pnpmWorkspace = load(pnpmWorkspaceFileContent);
-    if (root === wd && !filter) {
-      throw new Error("root path is workspace root, please provide a filter");
-    }
-    if (root === void 0) {
-      root = process.cwd();
-    }
-    if (root !== wd && !filter) {
-      const packageJSONIsExist = fs.existsSync(path.resolve(root, "package.json"));
-      if (!packageJSONIsExist) {
-        throw new Error("root path is not workspace root, please provide a filter");
-      }
-      const packageJSON = JSON.parse(fs.readFileSync(path.resolve(root, "package.json"), "utf-8"));
-      if (!packageJSON.name) {
-        throw new Error("root path is not workspace root, please provide a filter");
-      }
-      filter = packageJSON.name;
-    }
-    const { filterPackagesFromDir } = await import('@pnpm/filter-workspace-packages');
-    const { selectedProjectsGraph } = await filterPackagesFromDir(wd, [{
-      filter: filter ?? "",
-      followProdDepsOnly: true
-    }], {
-      prefix: root,
-      workspaceDir: wd,
-      patterns: pnpmWorkspace.packages
-    });
-    return {
-      wd,
-      root,
-      value: Object.entries(selectedProjectsGraph).reduce((acc, [key, value]) => {
-        acc[key] = value.package.manifest;
-        return acc;
-      }, {})
-    };
-  }
-  throw new Error(`not supported package manager ${type}`);
-}
 
 var utils$1 = {};
 
@@ -4214,633 +4107,4 @@ function requireMicromatch () {
 
 var micromatchExports = requireMicromatch();
 
-const intersection = (a, b) => new Set([...a].filter((i) => b.has(i)));
-const {
-  JIEK_OUT_DIR,
-  JIEK_CROSS_MODULE_CONVERTOR
-} = process$1.env;
-const OUTDIR = JIEK_OUT_DIR ?? "dist";
-const crossModuleConvertorDefault = JIEK_CROSS_MODULE_CONVERTOR === void 0 ? true : JIEK_CROSS_MODULE_CONVERTOR === "true";
-function getOutDirs({
-  cwd = process$1.cwd(),
-  defaultOutdir = OUTDIR,
-  config,
-  pkgName
-}) {
-  const { build = {} } = config ?? {};
-  const outdir = build?.output?.dir;
-  function resolveOutdir(type) {
-    const dir = (typeof outdir === "object" ? outdir[type] ?? outdir[{
-      js: "dts",
-      dts: "js"
-    }[type]] : outdir) ?? defaultOutdir;
-    return (isAbsolute(dir) ? dir : `./${relative(cwd, resolve(cwd, dir))}`).replace("{{PKG_NAME}}", pkgName);
-  }
-  return {
-    js: resolveOutdir("js"),
-    dts: resolveOutdir("dts")
-  };
-}
-function getExports({
-  entrypoints,
-  pkgName,
-  pkgIsModule,
-  entries,
-  config,
-  dir,
-  defaultOutdir = OUTDIR,
-  // FIXME dts support
-  outdir = getOutDirs({ pkgName, defaultOutdir, config, cwd: dir }).js,
-  noFilter,
-  isPublish
-}) {
-  const {
-    build = {},
-    publish: {
-      withSuffix = false,
-      withSource = true
-    } = {}
-  } = config ?? {};
-  const {
-    crossModuleConvertor = crossModuleConvertorDefault
-  } = build;
-  const [, resolvedEntrypoints] = resolveEntrypoints(entrypoints);
-  if (entries) {
-    Object.entries(resolvedEntrypoints).forEach(([key]) => {
-      if (!entries.some((e) => micromatchExports.isMatch(key, e, { matchBase: true }))) {
-        delete resolvedEntrypoints[key];
-      }
-    });
-  }
-  const filteredResolvedEntrypoints = noFilter ? resolvedEntrypoints : filterLeafs(
-    resolvedEntrypoints,
-    {
-      skipValue: [
-        // ignore values that filename starts with `.jk-noentry`
-        /(^|\/)\.jk-noentry/,
-        ...DEFAULT_SKIP_VALUES
-      ]
-    }
-  );
-  const crossModuleWithConditional = crossModuleConvertor ? {
-    import: (opts) => {
-      if (pkgIsModule) return false;
-      if (opts.src.endsWith(".cts")) return false;
-      if (intersection(
-        new Set(opts.conditionals),
-        /* @__PURE__ */ new Set(["import", "module"])
-      ).size !== 0) return false;
-      return opts.dist.replace(/\.js$/, ".mjs");
-    },
-    require: (opts) => {
-      if (!pkgIsModule) return false;
-      if (opts.src.endsWith(".mts")) return false;
-      if (intersection(
-        new Set(opts.conditionals),
-        /* @__PURE__ */ new Set(["require", "node"])
-      ).size !== 0) return false;
-      return opts.dist.replace(/\.js$/, ".cjs");
-    }
-  } : {};
-  return [
-    filteredResolvedEntrypoints,
-    entrypoints2Exports(filteredResolvedEntrypoints, {
-      outdir,
-      sourceTag: pkgName,
-      withSuffix: isPublish ? withSuffix : void 0,
-      withSource: isPublish ? withSource : void 0,
-      withConditional: {
-        ...crossModuleWithConditional
-      }
-    }),
-    outdir
-  ];
-}
-
-function packageIsExist(name) {
-  try {
-    require.resolve(name);
-    return true;
-  } catch (e) {
-    return false;
-  }
-}
-let tsRegisterName;
-const registers = [
-  process.env.JIEK_TS_REGISTER,
-  "esbuild-register",
-  "@swc-node/register",
-  "ts-node/register"
-].filter(Boolean);
-for (const register of registers) {
-  if (packageIsExist(register)) {
-    tsRegisterName = register;
-    break;
-  }
-}
-
-let configName = "jiek.config";
-function getConfigPath(root, dir) {
-  const isSupportTsLoader = !!tsRegisterName;
-  function configWithExtIsExist(ext) {
-    const filenames = [
-      path.resolve(process.cwd(), `${configName}.${ext}`),
-      path.resolve(process.cwd(), `.${configName}.${ext}`),
-      path.resolve(root, `${configName}.${ext}`),
-      path.resolve(root, `.${configName}.${ext}`)
-    ];
-    if (dir) {
-      filenames.unshift(...[
-        path.resolve(dir, `${configName}.${ext}`),
-        path.resolve(dir, `.${configName}.${ext}`)
-      ]);
-    }
-    for (const filename of filenames) {
-      if (fs.existsSync(filename) && fs.lstatSync(filename).isFile()) {
-        return filename;
-      }
-    }
-    return;
-  }
-  configName = configWithExtIsExist("js") ?? configName;
-  configName = configWithExtIsExist("json") ?? configName;
-  configName = configWithExtIsExist("yaml") ?? configName;
-  if (isSupportTsLoader) {
-    configName = configWithExtIsExist("ts") ?? configName;
-  }
-  return path.resolve(root, configName);
-}
-function loadConfig(dirOrOptions) {
-  let dir;
-  let root;
-  if (typeof dirOrOptions === "object") {
-    dir = dirOrOptions.dir;
-    root = dirOrOptions.root ?? getWD().wd;
-  } else {
-    dir = dirOrOptions;
-    root = getWD().wd;
-  }
-  let configPath = program.getOptionValue("configPath");
-  if (!configPath) {
-    configPath = getConfigPath(root, dir);
-  } else {
-    if (!fs.existsSync(configPath)) {
-      throw new Error(`config file not found: ${configPath}`);
-    }
-    if (!path.isAbsolute(configPath)) {
-      configPath = path.resolve(root, configPath);
-    }
-  }
-  const ext = path.extname(configPath);
-  let module;
-  switch (ext) {
-    case ".js":
-      module = require(configPath);
-      break;
-    case ".json":
-      return require(configPath);
-    case ".yaml":
-      return load(fs.readFileSync(configPath, "utf-8"));
-    case ".ts":
-      if (tsRegisterName) {
-        require(tsRegisterName);
-        module = require(configPath);
-        break;
-      }
-      throw new Error(
-        "ts config file is not supported without ts register, please install esbuild-register or set JIEK_TS_REGISTER env for custom ts register"
-      );
-    case ".config":
-      module = {};
-      break;
-    default:
-      throw new Error(`unsupported config file type: ${ext}`);
-  }
-  if (!module) throw new Error("config file is empty");
-  return module.default ?? module;
-}
-
-const outdirDescription = `
-The output directory of the build, which relative to the target subpackage root directory.
-Support with variables: 'PKG_NAME',
-.e.g. 'dist/{{PKG_NAME}}'.
-`.trim();
-
-const description = `
-Publish package to npm registry, and auto generate exports field and other fields in published package.json.
-If you want to through the options to the \`pnpm publish\` command, you can pass the options after '--'.
-`.trim();
-async function forEachSelectedProjectsGraphEntries(callback) {
-  const { value = {} } = await getSelectedProjectsGraph() ?? {};
-  const selectedProjectsGraphEntries = Object.entries(value);
-  if (selectedProjectsGraphEntries.length === 0) {
-    throw new Error("no packages selected");
-  }
-  for (const [dir, manifest] of selectedProjectsGraphEntries) {
-    callback(dir, manifest);
-  }
-}
-program.command("publish").description(description).aliases(["pub", "p"]).option("-b, --bumper <bumper>", "bump version", "patch").option("-no-b, --no-bumper", "no bump version").option("-o, --outdir <OUTDIR>", outdirDescription, String, "dist").action(async ({ outdir, bumper }) => {
-  let shouldPassThrough = false;
-  const passThroughOptions = process$1.argv.reduce(
-    (acc, value) => {
-      if (shouldPassThrough) {
-        acc.push(value);
-      }
-      if (value === "--") {
-        shouldPassThrough = true;
-      }
-      return acc;
-    },
-    []
-  );
-  await forEachSelectedProjectsGraphEntries((dir) => {
-    const args = ["pnpm", "publish", "--access", "public", "--no-git-checks"];
-    if (bumper && TAGS.includes(bumper)) {
-      args.push("--tag", bumper);
-    }
-    args.push(...passThroughOptions);
-    childProcess.execSync(args.join(" "), {
-      cwd: dir,
-      stdio: "inherit",
-      env: {
-        ...process$1.env,
-        JIEK_PUBLISH_OUTDIR: JSON.stringify(outdir),
-        JIEK_PUBLISH_BUMPER: JSON.stringify(bumper)
-      }
-    });
-  });
-});
-async function prepublish({ bumper } = {}) {
-  const {
-    JIEK_PUBLISH_OUTDIR: outdirEnv,
-    JIEK_PUBLISH_BUMPER: bumperEnv
-  } = process$1.env;
-  const outdir = outdirEnv ? JSON.parse(outdirEnv) : "dist";
-  bumper = bumper ?? (bumperEnv ? JSON.parse(bumperEnv) : false);
-  const generateNewManifest = (dir, manifest) => {
-    const { name, type, exports: entrypoints = {} } = manifest;
-    if (!name) {
-      throw new Error(`package.json in ${dir} must have a name field`);
-    }
-    const pkgIsModule = type === "module";
-    const newManifest = { ...manifest };
-    const [resolvedEntrypoints, exports, resolvedOutdir] = getExports({
-      entrypoints,
-      pkgIsModule,
-      pkgName: name,
-      config: loadConfig(dir),
-      dir,
-      defaultOutdir: outdir,
-      noFilter: true,
-      isPublish: true
-    });
-    newManifest.exports = {
-      ...resolvedEntrypoints,
-      ...exports
-    };
-    return [newManifest, resolvedOutdir];
-  };
-  const generateNewPackageJSONString = ({
-    oldJSONString,
-    oldJSON,
-    manifest,
-    formattingOptions
-  }) => {
-    let newJSONString = oldJSONString;
-    newJSONString = applyEdits(
-      newJSONString,
-      modify(
-        newJSONString,
-        ["publishConfig", "typesVersions"],
-        {
-          "<5.0": {
-            "*": [
-              "*",
-              `./*`,
-              `./*/index.d.ts`,
-              `./*/index.d.mts`,
-              `./*/index.d.cts`
-            ]
-          }
-        },
-        { formattingOptions }
-      )
-    );
-    for (const [key, value] of Object.entries(manifest)) {
-      if (key === "version") continue;
-      if (JSON.stringify(value) === JSON.stringify(oldJSON[key])) continue;
-      if (key !== "exports") {
-        newJSONString = applyEdits(
-          newJSONString,
-          modify(
-            newJSONString,
-            ["publishConfig", key],
-            value,
-            { formattingOptions }
-          )
-        );
-      } else {
-        const exports = value;
-        for (const [k, v] of Object.entries(exports)) {
-          newJSONString = applyEdits(
-            newJSONString,
-            modify(
-              newJSONString,
-              ["publishConfig", "exports", k],
-              v,
-              { formattingOptions }
-            )
-          );
-        }
-        const index = exports?.["."];
-        const indexPublishConfig = {};
-        if (index) {
-          switch (typeof index) {
-            case "string":
-              indexPublishConfig[manifest?.type === "module" ? "module" : "main"] = index;
-              break;
-            case "object": {
-              const indexExports = index;
-              indexPublishConfig.main = indexExports.require ?? indexExports.default;
-              indexPublishConfig.module = indexExports.import ?? indexExports.module ?? indexExports.default;
-              indexPublishConfig.types = indexExports.types;
-              break;
-            }
-          }
-          indexPublishConfig.types = indexPublishConfig[manifest?.type === "module" ? "module" : "main"].replace(/\.([cm]?)js$/, ".d.$1ts");
-          for (const [k, v] of Object.entries(indexPublishConfig)) {
-            if (v === void 0) continue;
-            newJSONString = applyEdits(
-              newJSONString,
-              modify(
-                newJSONString,
-                ["publishConfig", k],
-                v,
-                { formattingOptions }
-              )
-            );
-          }
-        }
-      }
-    }
-    if (oldJSON.devDependencies) {
-      newJSONString = applyEdits(
-        newJSONString,
-        modify(
-          newJSONString,
-          ["devDependencies"],
-          void 0,
-          { formattingOptions }
-        )
-      );
-    }
-    if (oldJSON.peerDependencies) {
-      const peerDependenciesMeta = Object.keys(oldJSON.peerDependencies).reduce(
-        (acc, key) => {
-          acc[key] = { optional: true };
-          return acc;
-        },
-        {}
-      );
-      newJSONString = applyEdits(
-        newJSONString,
-        modify(
-          newJSONString,
-          ["peerDependenciesMeta"],
-          peerDependenciesMeta,
-          { formattingOptions }
-        )
-      );
-    }
-    if (oldJSON.files) {
-      newJSONString = applyEdits(
-        newJSONString,
-        modify(
-          newJSONString,
-          ["files"],
-          void 0,
-          { formattingOptions }
-        )
-      );
-    }
-    return newJSONString;
-  };
-  await forEachSelectedProjectsGraphEntries((dir, originalManifest) => {
-    const [manifest, resolvedOutdir] = generateNewManifest(dir, originalManifest);
-    const resolveByDir = (...paths) => path.resolve(dir, ...paths);
-    const oldJSONString = fs.readFileSync(resolveByDir("package.json"), "utf-8");
-    const oldJSON = JSON.parse(oldJSONString);
-    if (typeof oldJSON.version !== "string") {
-      throw new TypeError(`${dir}/package.json must have a version field with a string value`);
-    }
-    const { indent = "    " } = detectIndent(oldJSONString);
-    const formattingOptions = {
-      tabSize: indent.length,
-      insertSpaces: true
-    };
-    const newVersion = bumper ? bump(oldJSON.version, bumper === true ? "patch" : bumper) : oldJSON.version;
-    const modifyVersionPackageJSON = applyEdits(
-      oldJSONString,
-      modify(oldJSONString, ["version"], newVersion, { formattingOptions })
-    );
-    const newJSONString = generateNewPackageJSONString({
-      oldJSONString: modifyVersionPackageJSON,
-      oldJSON: {
-        ...oldJSON,
-        version: newVersion
-      },
-      manifest,
-      formattingOptions
-    });
-    const withPublishConfigDirectoryOldJSONString = applyEdits(
-      modifyVersionPackageJSON,
-      modify(modifyVersionPackageJSON, ["publishConfig", "directory"], resolvedOutdir, { formattingOptions })
-    );
-    if (!fs.existsSync(resolveByDir(resolvedOutdir))) {
-      fs.mkdirSync(resolveByDir(resolvedOutdir));
-    }
-    const jiekTempDir = resolveByDir("node_modules/.jiek/.tmp");
-    if (!fs.existsSync(resolveByDir(jiekTempDir))) {
-      fs.mkdirSync(resolveByDir(jiekTempDir), { recursive: true });
-    }
-    fs.writeFileSync(resolveByDir(resolvedOutdir, "package.json"), newJSONString);
-    fs.writeFileSync(resolveByDir(jiekTempDir, "package.json"), modifyVersionPackageJSON);
-    fs.writeFileSync(resolveByDir("package.json"), withPublishConfigDirectoryOldJSONString);
-    const allBuildFiles = fs.readdirSync(resolveByDir(resolvedOutdir), { recursive: true }).filter((file) => typeof file === "string").filter((file) => file !== "package.json");
-    const resolvedExports = manifest.exports;
-    Object.keys(resolvedExports).forEach((key) => {
-      if (key === ".") return;
-      if (/\.[cm]?js$/.test(key)) return;
-      const resourceFileSuffixes = [
-        ".d.ts",
-        ".d.mts",
-        ".d.cts",
-        ".css",
-        ".scss",
-        ".sass",
-        ".less",
-        ".styl",
-        ".stylus",
-        ".json",
-        ".json5"
-      ];
-      if (resourceFileSuffixes.find((suffix) => key.endsWith(suffix))) return;
-      const value = resolvedExports[key];
-      const filepath = resolveByDir(resolvedOutdir, key);
-      fs.mkdirSync(filepath, { recursive: true });
-      const pkgJSONPath = resolveByDir(resolvedOutdir, key, "package.json");
-      const relativePath = Array.from({ length: key.split("/").length - 1 }, () => "..").join("/");
-      const { type } = manifest;
-      const pkgJSON = { type };
-      if ("default" in value) {
-        pkgJSON[type === "module" ? "module" : "main"] = [
-          relativePath,
-          value.default?.replace(/^\.\//, "")
-        ].join("/");
-      }
-      if ("import" in value) {
-        pkgJSON.module = [
-          relativePath,
-          value.import?.replace(/^\.\//, "")
-        ].join("/");
-      }
-      if ("require" in value) {
-        pkgJSON.main = [
-          relativePath,
-          value.require?.replace(/^\.\//, "")
-        ].join("/");
-      }
-      fs.writeFileSync(pkgJSONPath, JSON.stringify(pkgJSON));
-    });
-    fs.mkdirSync(resolveByDir(resolvedOutdir, resolvedOutdir));
-    for (const file of allBuildFiles) {
-      const filepath = resolveByDir(resolvedOutdir, file);
-      const newFilepath = resolveByDir(resolvedOutdir, resolvedOutdir, file);
-      const stat = fs.statSync(filepath);
-      if (stat.isDirectory()) {
-        fs.mkdirSync(newFilepath, { recursive: true });
-        continue;
-      }
-      if (stat.isFile()) {
-        fs.cpSync(filepath, newFilepath);
-        fs.rmSync(filepath);
-      }
-    }
-    if (oldJSON.files) {
-      if (Array.isArray(oldJSON.files)) {
-        if (oldJSON.files.every((file) => typeof file !== "string")) {
-          throw new TypeError(`${dir}/package.json files field must be an array of string`);
-        }
-      } else {
-        throw new TypeError(`${dir}/package.json files field must be an array`);
-      }
-    }
-    const resolvedOutdirAbs = resolveByDir(resolvedOutdir);
-    const files = (oldJSON.files ?? fs.readdirSync(resolveByDir("."))).filter(
-      (file) => ![
-        "node_modules",
-        "package.json",
-        "pnpm-lock.yaml"
-      ].includes(file) && resolveByDir(file) !== resolvedOutdirAbs
-    );
-    for (const file of files) {
-      const path2 = resolveByDir(file);
-      try {
-        const stat = fs.statSync(path2);
-        if (stat.isDirectory()) {
-          fs.cpSync(path2, resolveByDir(resolvedOutdir, file), { recursive: true });
-          continue;
-        }
-        if (stat.isFile()) {
-          fs.cpSync(path2, resolveByDir(resolvedOutdir, file));
-          continue;
-        }
-      } catch (e) {
-        console.warn(String(e));
-        continue;
-      }
-      throw new Error(`file type of ${path2} is not supported`);
-    }
-  });
-}
-async function postpublish() {
-  await forEachSelectedProjectsGraphEntries((dir) => {
-    const jiekTempDir = path.resolve(dir, "node_modules/.jiek/.tmp");
-    const packageJSONPath = path.resolve(dir, "package.json");
-    const { name, version } = JSON.parse(fs.readFileSync(packageJSONPath, "utf-8"));
-    const jiekTempPackageJSONPath = path.resolve(jiekTempDir, "package.json");
-    if (fs.existsSync(jiekTempPackageJSONPath)) {
-      fs.copyFileSync(jiekTempPackageJSONPath, packageJSONPath);
-      fs.rmSync(jiekTempPackageJSONPath);
-      console.log(`${dir}/package.json has been restored`);
-      console.log(
-        `if you want to check the compatibility of the package, you can visit: https://arethetypeswrong.github.io/?p=${name}%40${version}`
-      );
-    } else {
-      throw new Error(
-        `jiek temp \`${dir}/package.json\` not found, please confirm the jiek pre-publish command has been executed`
-      );
-    }
-  });
-}
-program.action(async () => {
-  const {
-    npm_lifecycle_event: NPM_LIFECYCLE_EVENT
-  } = process$1.env;
-  switch (NPM_LIFECYCLE_EVENT) {
-    case "prepublish":
-      await prepublish();
-      break;
-    case "postpublish":
-      await postpublish();
-      break;
-    default:
-      program.help();
-  }
-});
-const prepublishDescription = `
-Prepare package.json for publish, you can add \`jk\` to the \`prepublish\` script in package.json, the command will automatically run \`jk prepublish\`.
-.e.g
-{
-  "scripts": {
-    "prepublish": "jk"
-  }
-}
-`.trim();
-program.command("prepublish").description(prepublishDescription).option("-b, --bumper <bumper>", "bump version").option("-no-b, --no-bumper", "no bump version").action(prepublish);
-const postpublishDescription = `
-Restore package.json after publish, you can add \`jk\` to the \`postpublish\` script in package.json, the command will automatically run \`jk postpublish\`.
-.e.g
-{
-  "scripts": {
-    "postpublish": "jk"
-  }
-}
-`.trim();
-program.command("postpublish").description(postpublishDescription).action(postpublish);
-
-const { argv } = process$1;
-const env = {};
-let isPassThrough = false;
-const newArgv = argv.filter((arg) => {
-  if (isPassThrough) {
-    return true;
-  }
-  if (arg === "--") {
-    isPassThrough = true;
-    return false;
-  }
-  const m = /^--env\.(\w+)=(.*)$/.exec(arg);
-  if (m) {
-    env[m[1]] = m[2];
-    return false;
-  }
-  return true;
-});
-for (const [key, value] of Object.entries(env)) {
-  process$1.env[key] = value;
-}
-var parseArgv = () => program.parse(newArgv);
-
-parseArgv();
+export { micromatchExports as m };