@done-coding/cli-template 0.6.1-alpha.0 → 0.6.2-alpha.0

package/es/cli.mjs

@@ -1,11 +1,9 @@
 #!/usr/bin/env node
-import { c as r } from "./index-9892305e.js";
+import { c as r } from "./index-694fa5e1.js";
 import "node:path";
 import "node:fs";
-import "chalk";
 import "lodash.template";
 import "lodash.assign";
-import "prompts";
 import "@done-coding/cli-utils";
 import "yargs";
 import "yargs/helpers";

package/es/index-694fa5e1.js

@@ -0,0 +1,340 @@
+#!/usr/bin/env node
+import $ from "node:path";
+import l from "node:fs";
+import D from "lodash.template";
+import T from "lodash.assign";
+import { log as n, xPrompts as N } from "@done-coding/cli-utils";
+import A from "yargs";
+import { hideBin as U } from "yargs/helpers";
+var v = /* @__PURE__ */ ((e) => (e.OVERWRITE = "overwrite", e.APPEND = "append", e.REPLACE = "replace", e.RETURN = "return", e))(v || {});
+const g = {
+  rollback: !1,
+  dealMarkdown: !1,
+  mode: v.OVERWRITE,
+  batch: !1
+}, P = (e) => {
+  const { rollback: r, dealMarkdown: i, mode: s, batch: u, ...c } = e;
+  return {
+    rollback: r ?? g.rollback,
+    dealMarkdown: i ?? g.dealMarkdown,
+    mode: s ?? g.mode,
+    batch: u ?? g.batch,
+    ...c
+  };
+}, E = {
+  version: "0.6.2-alpha.0",
+  name: "@done-coding/cli-template",
+  description: "预编译命令行工具",
+  cliConfig: {
+    namespaceDir: ".done-coding",
+    moduleName: "template"
+  }
+}, W = (e) => {
+  const { namespaceDir: r, moduleName: i } = E.cliConfig, s = [r, `${i}.json`];
+  e && s.unshift(e);
+  const u = $.resolve(...s);
+  if (l.existsSync(u))
+    return u;
+}, C = ({
+  filePath: e,
+  dataInit: r,
+  limitJson: i,
+  filePathKey: s,
+  dataInitKey: u,
+  dealMarkdown: c = !1
+}) => {
+  if (e) {
+    if (i && !e.endsWith(".json"))
+      return n.error(`${s}必须是json文件，请检查文件后缀名`), process.exit(1);
+    const a = l.readFileSync($.resolve(e), "utf-8");
+    let p = a;
+    return c && e.endsWith(".md") && (p = a.replace(
+      /^\s*```[a-zA-Z0-9]+\s*[\r\n]+([\s\S]+?)```\s*$/,
+      "$1"
+    )), i ? JSON.parse(p) : p;
+  } else
+    return r ? (n.info(`${s} 为空，将使用${u}作为数据`), i ? JSON.parse(r) : r) : (n.error(`${s}与${u}不能同时为空`), process.exit(1));
+}, R = (e, r) => {
+  if (!r)
+    return n.error(`${e}模式下output不能为空`), process.exit(1);
+}, S = (e, r) => {
+  if (r && e === r)
+    return n.error("output与input不能相同"), process.exit(1);
+}, J = (e, r) => {
+  if (!r)
+    return n.error(`${e}模式下input不能为空`), process.exit(1);
+}, x = async (e, {
+  rollbackDelFileAgree: r = !1
+} = {}) => {
+  const {
+    env: i,
+    input: s,
+    inputData: u,
+    output: c,
+    mode: a,
+    rollback: p,
+    dealMarkdown: y,
+    envData: h
+  } = e;
+  if (p)
+    switch (a) {
+      case v.REPLACE:
+      case v.RETURN: {
+        n.error(`${a}模式不支持回滚`);
+        return;
+      }
+    }
+  n.stage(`开始处理模板
+mode: ${a}
+rollback: ${p}
+`);
+  const w = C({
+    filePath: s,
+    dataInit: u,
+    limitJson: !1,
+    filePathKey: "input",
+    dataInitKey: "inputData",
+    dealMarkdown: y
+  }), o = D(w), d = typeof h == "function" ? h() : h, m = o(d);
+  switch (a) {
+    case v.OVERWRITE: {
+      R(a, c), S(c, s);
+      const t = $.resolve(c);
+      if (l.mkdirSync($.dirname(t), { recursive: !0 }), l.existsSync(t)) {
+        if (p)
+          if (r || (await N({
+            type: "confirm",
+            name: "remove",
+            message: `${a}模式下回滚将删除${t}，是否继续？`
+          })).remove) {
+            l.rmSync(t, { force: !0 }), n.success(`${a}模式下${t}已删除`);
+            return;
+          } else {
+            n.warn(`${a}模式下${t}回滚取消`);
+            return;
+          }
+        n.info(`output:${t} 已存在，将覆盖`);
+      } else {
+        if (p) {
+          n.warn(`${a}模式下${t}不存在，无需回滚`);
+          return;
+        }
+        n.stage(`output:${t} 不存在，将创建`);
+      }
+      l.writeFileSync(t, m, "utf-8"), n.success(`模板处理完成，输出到 ${t}`);
+      break;
+    }
+    case v.APPEND: {
+      R(a, c), S(c, s);
+      const t = $.resolve(c);
+      if (l.mkdirSync($.dirname(t), { recursive: !0 }), l.existsSync(t)) {
+        const f = l.readFileSync(t, "utf-8");
+        if (p) {
+          l.writeFileSync(
+            t,
+            f.replace(m, ""),
+            "utf-8"
+          ), n.success(`${a}模式下${t}回滚完成`);
+          return;
+        }
+        const b = f + m;
+        l.writeFileSync(t, b, "utf-8"), n.success(`模板处理完成，追加到 ${t}`);
+      } else {
+        if (p) {
+          n.warn(`${a}模式下${t}不存在，无需回滚`);
+          return;
+        }
+        n.stage(`output:${t} 不存在，将创建`), l.writeFileSync(t, m, "utf-8"), n.success(`模板处理完成，输出到 ${t}`);
+      }
+      break;
+    }
+    case v.REPLACE: {
+      if (c && n.warn(`output ${c} 将被忽略`), J(a, s), i && i === s)
+        return n.error("env 与 input 不能相同"), process.exit(1);
+      const t = $.resolve(s);
+      let f = t;
+      const b = s.replace(`${process.cwd()}/`, ""), k = D(b)(d);
+      k !== b && (n.success(`检测输入文件名也需要替换
+            ./${b} => ./${k} `), l.rmSync(t), f = $.resolve(`./${k}`)), l.mkdirSync($.dirname(f), { recursive: !0 }), l.writeFileSync(f, m, "utf-8"), n.success(`模板处理完成，输出到 ${f}`);
+      break;
+    }
+    case v.RETURN:
+      return n.success("模板处理完成，返回结果(函数调用才会拿到返回值)"), m;
+    default:
+      return n.error(`mode ${a} 不支持`), process.exit(1);
+  }
+  return m;
+}, M = async ({
+  rootDir: e = process.cwd(),
+  itemDefaultRollback: r = !1,
+  extraEnvData: i = {}
+} = {}, s) => {
+  let u;
+  if (s)
+    u = s;
+  else {
+    const o = W(e);
+    if (!o)
+      return n.error(`配置文件${o}不存在`), process.exit(1);
+    const d = l.readFileSync(o, "utf-8");
+    u = JSON.parse(d);
+  }
+  const {
+    list: c,
+    globalEnvData: a = {},
+    collectEnvDataForm: p = []
+  } = u, y = {};
+  for (const o of p) {
+    let d, m, t;
+    typeof o == "string" ? (d = o, m = o, t = void 0) : (d = o.key, m = o.label, t = o.initial), y[d] = (await N({
+      type: "text",
+      name: d,
+      message: `请输入${m}`,
+      initial: t,
+      format: (f) => f.trim(),
+      validate: (f) => f.length > 0 || `${m}不能为空`
+    }))[d];
+  }
+  const h = c.map((o) => {
+    const { rollback: d = r } = o, {
+      envData: m,
+      env: t,
+      input: f,
+      output: b,
+      ...k
+    } = P(o);
+    return t && n.warn(`批量处理中 env:${t} 将被忽略，只读envData`), {
+      ...k,
+      env: t,
+      input: e && f ? $.resolve(e, f) : f,
+      output: e && b ? $.resolve(e, b) : b,
+      envData: T(
+        {},
+        i,
+        a,
+        y,
+        m
+      ),
+      rollback: d
+    };
+  }), w = [];
+  for (const o of h) {
+    const d = await x(o, {
+      rollbackDelFileAgree: !0
+    });
+    w.push(d);
+  }
+  return w;
+}, I = async (e) => {
+  const {
+    envData: r,
+    env: i,
+    input: s,
+    inputData: u,
+    output: c,
+    mode: a,
+    rollback: p,
+    dealMarkdown: y,
+    batch: h
+  } = P(e);
+  if (h)
+    return n.stage("开始批量处理"), M({
+      // 回滚默认值 基于全局
+      itemDefaultRollback: p
+    });
+  n.stage("开始单个处理");
+  const w = C({
+    filePath: i,
+    dataInit: r,
+    limitJson: !0,
+    filePathKey: "env",
+    dataInitKey: "envData",
+    dealMarkdown: y
+  });
+  return x({
+    input: s,
+    inputData: u,
+    output: c,
+    mode: a,
+    rollback: p,
+    dealMarkdown: y,
+    envData: w
+  });
+}, j = () => ({
+  env: {
+    alias: "e",
+    describe: "环境数据文件JSON文件相对路径(优先级高于envData)",
+    type: "string"
+  },
+  envData: {
+    alias: "E",
+    describe: "环境变量数据(JSON字符串)",
+    type: "string"
+  },
+  input: {
+    alias: "i",
+    describe: "模板文件相对路径(优先级高于inputTemplate)",
+    type: "string"
+  },
+  inputData: {
+    alias: "I",
+    describe: "模板数据",
+    type: "string"
+  },
+  mode: {
+    alias: "m",
+    describe: "输出模式",
+    type: "string",
+    choices: [
+      v.OVERWRITE,
+      v.APPEND,
+      v.REPLACE,
+      v.RETURN
+    ],
+    default: g.mode
+  },
+  output: {
+    alias: "o",
+    describe: "输出文件路径",
+    type: "string"
+  },
+  rollback: {
+    alias: "r",
+    describe: "是否回滚",
+    type: "boolean",
+    default: g.rollback
+  },
+  dealMarkdown: {
+    alias: "d",
+    describe: "(检测是markdown)是否处理(单个)代码块包裹",
+    type: "boolean",
+    default: g.dealMarkdown
+  },
+  batch: {
+    alias: "b",
+    describe: "是否批量处理",
+    type: "boolean",
+    default: g.batch
+  }
+}), F = E.cliConfig.moduleName, L = (e, r) => {
+  e ? n.error(e) : n.error(r.message), process.exit(1);
+}, V = E.description, H = `Usage: $0 ${F} [options]`, _ = "Usage: $0 [options]", O = (e, r) => {
+  const i = j();
+  return e.strict().usage(r).help("help").version(E.version).alias("v", "version").alias("h", "help").options(i).fail(L).argv;
+}, q = (e) => O(e, H), Y = {
+  command: F,
+  describe: V,
+  builder: q,
+  handler: I
+}, ee = async () => {
+  const e = A(U(process.argv)), r = await O(e, _);
+  return I(r);
+};
+export {
+  v as O,
+  Y as a,
+  M as b,
+  ee as c,
+  W as g,
+  I as h
+};

package/es/index.mjs

@@ -1,18 +1,16 @@
 #!/usr/bin/env node
-import { O as d, b as h, a as u, g as b, h as f } from "./index-9892305e.js";
-export * from "@done-coding/cli-utils";
+import { O as s, b as d, a as h, g as u, h as b } from "./index-694fa5e1.js";
 import "node:path";
 import "node:fs";
-import "chalk";
 import "lodash.template";
 import "lodash.assign";
-import "prompts";
+import "@done-coding/cli-utils";
 import "yargs";
 import "yargs/helpers";
 export {
-  d as OutputModeEnum,
-  h as batchHandler,
-  u as command,
-  b as getConfigPath,
-  f as handler
+  s as OutputModeEnum,
+  d as batchHandler,
+  h as command,
+  u as getConfigPath,
+  b as handler
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@done-coding/cli-template",
-  "version": "0.6.1-alpha.0",
+  "version": "0.6.2-alpha.0",
   "description": "预编译命令行工具",
   "private": false,
   "module": "es/index.mjs",
@@ -41,13 +41,12 @@
   "license": "MIT",
   "sideEffects": false,
   "devDependencies": {
-    "@done-coding/cli-inject": "^0.4.6-alpha.0",
+    "@done-coding/cli-inject": "^0.4.7-alpha.0",
     "@types/lodash.assign": "^4.2.9",
     "@types/lodash.get": "^4.4.9",
     "@types/lodash.set": "^4.3.9",
     "@types/lodash.template": "^4.5.3",
     "@types/node": "^18.0.0",
-    "@types/prompts": "^2.4.6",
     "@types/yargs": "^17.0.28",
     "rimraf": "^6.0.1",
     "typescript": "^5.2.2",
@@ -58,14 +57,12 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
-    "@done-coding/cli-utils": "^0.2.1-alpha.0",
-    "chalk": "^5.3.0",
+    "@done-coding/cli-utils": "^0.2.2-alpha.0",
     "lodash.assign": "^4.2.0",
     "lodash.get": "^4.4.2",
     "lodash.set": "^4.3.2",
     "lodash.template": "^4.5.0",
-    "prompts": "^2.4.2",
     "yargs": "^17.7.2"
   },
-  "gitHead": "21eb698f64179882cfec979bd8f19920b047dacb"
+  "gitHead": "2e59e86ee192e023138e7475f4abbb5e7c42b29e"
 }

package/types/index.d.ts

@@ -2,4 +2,3 @@ export { handler, batchHandler } from "./handler";
 export { command } from "./main";
 export * from './utils/types';
 export * from './utils/config';
-export * from "@done-coding/cli-utils";

package/types/injectInfo.json.d.ts

@@ -1,5 +1,5 @@
 declare const _default: {
-  "version": "0.6.1-alpha.0",
+  "version": "0.6.2-alpha.0",
   "name": "@done-coding/cli-template",
   "description": "预编译命令行工具",
   "cliConfig": {

package/es/index-9892305e.js

@@ -1,358 +0,0 @@
-#!/usr/bin/env node
-import v from "node:path";
-import c from "node:fs";
-import o from "chalk";
-import E from "lodash.template";
-import A from "lodash.assign";
-import N from "prompts";
-import { onPromptFormStateForSigint as P } from "@done-coding/cli-utils";
-import U from "yargs";
-import { hideBin as W } from "yargs/helpers";
-var g = /* @__PURE__ */ ((e) => (e.OVERWRITE = "overwrite", e.APPEND = "append", e.REPLACE = "replace", e.RETURN = "return", e))(g || {});
-const $ = {
-  rollback: !1,
-  dealMarkdown: !1,
-  mode: g.OVERWRITE,
-  batch: !1
-}, C = (e) => {
-  const { rollback: n, dealMarkdown: a, mode: s, batch: u, ...i } = e;
-  return {
-    rollback: n ?? $.rollback,
-    dealMarkdown: a ?? $.dealMarkdown,
-    mode: s ?? $.mode,
-    batch: u ?? $.batch,
-    ...i
-  };
-}, S = {
-  version: "0.6.1-alpha.0",
-  name: "@done-coding/cli-template",
-  description: "预编译命令行工具",
-  cliConfig: {
-    namespaceDir: ".done-coding",
-    moduleName: "template"
-  }
-}, J = (e) => {
-  const { namespaceDir: n, moduleName: a } = S.cliConfig, s = [n, `${a}.json`];
-  e && s.unshift(e);
-  const u = v.resolve(...s);
-  if (c.existsSync(u))
-    return u;
-}, I = ({
-  filePath: e,
-  dataInit: n,
-  limitJson: a,
-  filePathKey: s,
-  dataInitKey: u,
-  dealMarkdown: i = !1
-}) => {
-  if (e) {
-    if (a && !e.endsWith(".json"))
-      return console.log(
-        o.red(`${s}必须是json文件，请检查文件后缀名`)
-      ), process.exit(1);
-    const l = c.readFileSync(v.resolve(e), "utf-8");
-    let p = l;
-    return i && e.endsWith(".md") && (p = l.replace(
-      /^\s*```[a-zA-Z0-9]+\s*[\r\n]+([\s\S]+?)```\s*$/,
-      "$1"
-    )), a ? JSON.parse(p) : p;
-  } else
-    return n ? (console.log(
-      o.green(`${s} 为空，将使用${u}作为数据`)
-    ), a ? JSON.parse(n) : n) : (console.log(o.red(`${s}与${u}不能同时为空`)), process.exit(1));
-}, D = (e, n) => {
-  if (!n)
-    return console.log(o.red(`${e}模式下output不能为空`)), process.exit(1);
-}, R = (e, n) => {
-  if (n && e === n)
-    return console.log(o.red("output与input不能相同")), process.exit(1);
-}, M = (e, n) => {
-  if (!n)
-    return console.log(o.red(`${e}模式下input不能为空`)), process.exit(1);
-}, x = async (e, {
-  rollbackDelFileAgree: n = !1
-} = {}) => {
-  const {
-    env: a,
-    input: s,
-    inputData: u,
-    output: i,
-    mode: l,
-    rollback: p,
-    dealMarkdown: y,
-    envData: h
-  } = e;
-  if (p)
-    switch (l) {
-      case g.REPLACE:
-      case g.RETURN: {
-        console.log(o.red(`${l}模式不支持回滚`));
-        return;
-      }
-    }
-  console.log(
-    o.blue(`开始处理模板
-mode: ${l}
-rollback: ${p}
-`)
-  );
-  const k = I({
-    filePath: s,
-    dataInit: u,
-    limitJson: !1,
-    filePathKey: "input",
-    dataInitKey: "inputData",
-    dealMarkdown: y
-  }), r = E(k), m = typeof h == "function" ? h() : h, f = r(m);
-  switch (l) {
-    case g.OVERWRITE: {
-      D(l, i), R(i, s);
-      const t = v.resolve(i);
-      if (c.mkdirSync(v.dirname(t), { recursive: !0 }), c.existsSync(t)) {
-        if (p)
-          if (n || (await N({
-            type: "confirm",
-            name: "remove",
-            message: `${l}模式下回滚将删除${t}，是否继续？`,
-            onState: P
-          })).remove) {
-            c.rmSync(t, { force: !0 }), console.log(o.green(`${l}模式下${t}已删除`));
-            return;
-          } else {
-            console.log(o.yellow(`${l}模式下${t}回滚取消`));
-            return;
-          }
-        console.log(o.blue(`output:${t} 已存在，将覆盖`));
-      } else {
-        if (p) {
-          console.log(
-            o.yellow(`${l}模式下${t}不存在，无需回滚`)
-          );
-          return;
-        }
-        console.log(o.blue(`output:${t} 不存在，将创建`));
-      }
-      c.writeFileSync(t, f, "utf-8"), console.log(o.green(`模板处理完成，输出到 ${t}`));
-      break;
-    }
-    case g.APPEND: {
-      D(l, i), R(i, s);
-      const t = v.resolve(i);
-      if (c.mkdirSync(v.dirname(t), { recursive: !0 }), c.existsSync(t)) {
-        const d = c.readFileSync(t, "utf-8");
-        if (p) {
-          c.writeFileSync(
-            t,
-            d.replace(f, ""),
-            "utf-8"
-          ), console.log(o.green(`${l}模式下${t}回滚完成`));
-          return;
-        }
-        const b = d + f;
-        c.writeFileSync(t, b, "utf-8"), console.log(o.green(`模板处理完成，追加到 ${t}`));
-      } else {
-        if (p) {
-          console.log(
-            o.yellow(`${l}模式下${t}不存在，无需回滚`)
-          );
-          return;
-        }
-        console.log(o.blue(`output:${t} 不存在，将创建`)), c.writeFileSync(t, f, "utf-8"), console.log(o.green(`模板处理完成，输出到 ${t}`));
-      }
-      break;
-    }
-    case g.REPLACE: {
-      if (i && console.log(o.yellow(`output ${i} 将被忽略`)), M(l, s), a && a === s)
-        return console.log(o.red("env 与 input 不能相同")), process.exit(1);
-      const t = v.resolve(s);
-      let d = t;
-      const b = s.replace(`${process.cwd()}/`, ""), w = E(b)(m);
-      w !== b && (console.log(
-        o.green(`检测输入文件名也需要替换
-            ./${b} => ./${w} `)
-      ), c.rmSync(t), d = v.resolve(`./${w}`)), c.mkdirSync(v.dirname(d), { recursive: !0 }), c.writeFileSync(d, f, "utf-8"), console.log(o.green(`模板处理完成，输出到 ${d}`));
-      break;
-    }
-    case g.RETURN:
-      return console.log(
-        o.green("模板处理完成，返回结果(函数调用才会拿到返回值)")
-      ), f;
-    default:
-      return console.log(o.red(`mode ${l} 不支持`)), process.exit(1);
-  }
-  return f;
-}, j = async ({
-  rootDir: e = process.cwd(),
-  itemDefaultRollback: n = !1,
-  extraEnvData: a = {}
-} = {}, s) => {
-  let u;
-  if (s)
-    u = s;
-  else {
-    const r = J(e);
-    if (!r)
-      return console.log(o.red(`配置文件${r}不存在`)), process.exit(1);
-    const m = c.readFileSync(r, "utf-8");
-    u = JSON.parse(m);
-  }
-  const {
-    list: i,
-    globalEnvData: l = {},
-    collectEnvDataForm: p = []
-  } = u, y = {};
-  for (const r of p) {
-    let m, f, t;
-    typeof r == "string" ? (m = r, f = r, t = void 0) : (m = r.key, f = r.label, t = r.initial), y[m] = (await N({
-      type: "text",
-      name: m,
-      message: `请输入${f}`,
-      initial: t,
-      format: (d) => d.trim(),
-      validate: (d) => d.length > 0 || `${f}不能为空`,
-      onState: P
-    }))[m];
-  }
-  const h = i.map((r) => {
-    const { rollback: m = n } = r, {
-      envData: f,
-      env: t,
-      input: d,
-      output: b,
-      ...w
-    } = C(r);
-    return t && console.log(o.yellow(`批量处理中 env:${t} 将被忽略，只读envData`)), {
-      ...w,
-      env: t,
-      input: e && d ? v.resolve(e, d) : d,
-      output: e && b ? v.resolve(e, b) : b,
-      envData: A(
-        {},
-        a,
-        l,
-        y,
-        f
-      ),
-      rollback: m
-    };
-  }), k = [];
-  for (const r of h) {
-    const m = await x(r, {
-      rollbackDelFileAgree: !0
-    });
-    k.push(m);
-  }
-  return k;
-}, F = async (e) => {
-  const {
-    envData: n,
-    env: a,
-    input: s,
-    inputData: u,
-    output: i,
-    mode: l,
-    rollback: p,
-    dealMarkdown: y,
-    batch: h
-  } = C(e);
-  if (h)
-    return console.log(o.blue("开始批量处理")), j({
-      // 回滚默认值 基于全局
-      itemDefaultRollback: p
-    });
-  console.log(o.blue("开始单个处理"));
-  const k = I({
-    filePath: a,
-    dataInit: n,
-    limitJson: !0,
-    filePathKey: "env",
-    dataInitKey: "envData",
-    dealMarkdown: y
-  });
-  return x({
-    input: s,
-    inputData: u,
-    output: i,
-    mode: l,
-    rollback: p,
-    dealMarkdown: y,
-    envData: k
-  });
-}, L = () => ({
-  env: {
-    alias: "e",
-    describe: "环境数据文件JSON文件相对路径(优先级高于envData)",
-    type: "string"
-  },
-  envData: {
-    alias: "E",
-    describe: "环境变量数据(JSON字符串)",
-    type: "string"
-  },
-  input: {
-    alias: "i",
-    describe: "模板文件相对路径(优先级高于inputTemplate)",
-    type: "string"
-  },
-  inputData: {
-    alias: "I",
-    describe: "模板数据",
-    type: "string"
-  },
-  mode: {
-    alias: "m",
-    describe: "输出模式",
-    type: "string",
-    choices: [
-      g.OVERWRITE,
-      g.APPEND,
-      g.REPLACE,
-      g.RETURN
-    ],
-    default: $.mode
-  },
-  output: {
-    alias: "o",
-    describe: "输出文件路径",
-    type: "string"
-  },
-  rollback: {
-    alias: "r",
-    describe: "是否回滚",
-    type: "boolean",
-    default: $.rollback
-  },
-  dealMarkdown: {
-    alias: "d",
-    describe: "(检测是markdown)是否处理(单个)代码块包裹",
-    type: "boolean",
-    default: $.dealMarkdown
-  },
-  batch: {
-    alias: "b",
-    describe: "是否批量处理",
-    type: "boolean",
-    default: $.batch
-  }
-}), O = S.cliConfig.moduleName, V = (e, n) => {
-  console.log(e ? o.red(e) : o.red(n.message)), process.exit(1);
-}, H = S.description, _ = `Usage: $0 ${O} [options]`, q = "Usage: $0 [options]", T = (e, n) => {
-  const a = L();
-  return e.strict().usage(n).help("help").version(S.version).alias("v", "version").alias("h", "help").options(a).fail(V).argv;
-}, z = (e) => T(e, _), oe = {
-  command: O,
-  describe: H,
-  builder: z,
-  handler: F
-}, ne = async () => {
-  const e = U(W(process.argv)), n = await T(e, q);
-  return F(n);
-};
-export {
-  g as O,
-  oe as a,
-  j as b,
-  ne as c,
-  J as g,
-  F as h
-};