@bemoje/cli 1.0.2 → 1.0.4

package/cjs/lib/CommanderHelpAdapter.cjs

@@ -0,0 +1,120 @@
+"use strict";
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var CommanderHelpAdapter_exports = {};
+__export(CommanderHelpAdapter_exports, {
+  CommanderHelpAdapter: () => CommanderHelpAdapter
+});
+module.exports = __toCommonJS(CommanderHelpAdapter_exports);
+var import_Help = require("./Help");
+var import_lazyProp = __toESM(require("./internal/lazyProp"), 1);
+var import_renderHelp = require("./renderHelp");
+const _CommanderHelpAdapter = class _CommanderHelpAdapter {
+  constructor(cmd) {
+    this.cmd = cmd;
+  }
+  renderHelp(help = new import_Help.Help()) {
+    return (0, import_renderHelp.renderHelp)(this, help);
+  }
+  get name() {
+    return this.cmd.name();
+  }
+  get aliases() {
+    return this.cmd.aliases();
+  }
+  get summary() {
+    const cmdSummary = this.cmd.summary();
+    return cmdSummary && cmdSummary.trim() !== "" ? cmdSummary : this.cmd.description().includes("\n") ? this.cmd.description().split("\n")[0] : void 0;
+  }
+  get description() {
+    return this.cmd.description();
+  }
+  get hidden() {
+    return Reflect.get(this.cmd, "_hidden");
+  }
+  get usage() {
+    return this.cmd.usage();
+  }
+  get group() {
+    return this.cmd.helpGroup();
+  }
+  get commands() {
+    return this.cmd.commands.map((c) => new _CommanderHelpAdapter(c));
+  }
+  get options() {
+    return this.cmd.options.map((opt) => ({
+      ...opt,
+      short: opt.short ?? opt.attributeName()[0],
+      long: opt.long ?? opt.attributeName()
+    }));
+  }
+  get arguments() {
+    return this.cmd.registeredArguments.map((arg) => ({
+      ...arg,
+      name: arg.name()
+    }));
+  }
+  get parent() {
+    return this.cmd.parent ? new _CommanderHelpAdapter(this.cmd.parent) : null;
+  }
+  get helpConfiguration() {
+    return { ...this.cmd.configureHelp() };
+  }
+};
+__decorateClass([
+  import_lazyProp.default
+], _CommanderHelpAdapter.prototype, "summary", 1);
+__decorateClass([
+  import_lazyProp.default
+], _CommanderHelpAdapter.prototype, "commands", 1);
+__decorateClass([
+  import_lazyProp.default
+], _CommanderHelpAdapter.prototype, "options", 1);
+__decorateClass([
+  import_lazyProp.default
+], _CommanderHelpAdapter.prototype, "arguments", 1);
+__decorateClass([
+  import_lazyProp.default
+], _CommanderHelpAdapter.prototype, "parent", 1);
+__decorateClass([
+  import_lazyProp.default
+], _CommanderHelpAdapter.prototype, "helpConfiguration", 1);
+let CommanderHelpAdapter = _CommanderHelpAdapter;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CommanderHelpAdapter
+});
+//# sourceMappingURL=CommanderHelpAdapter.cjs.map

package/cjs/lib/Help.cjs

@@ -0,0 +1,490 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Help_exports = {};
+__export(Help_exports, {
+  Help: () => Help
+});
+module.exports = __toCommonJS(Help_exports);
+class Help {
+  /** output helpWidth, long lines are wrapped to fit */
+  helpWidth = process.stdout.isTTY ? process.stdout.columns : 80;
+  minWidthToWrap = 40;
+  sortSubcommands;
+  sortOptions;
+  showGlobalOptions;
+  /**
+   * Get an array of the visible subcommands. Includes a placeholder for the implicit help command, if there is one.
+   */
+  visibleCommands(cmd) {
+    const visibleCommands = cmd.commands.filter((cmd2) => !cmd2.hidden);
+    if (this.sortSubcommands) {
+      visibleCommands.sort((a, b) => {
+        return a.name.localeCompare(b.name);
+      });
+    }
+    return visibleCommands;
+  }
+  /**
+   * Compare options for sort.
+   */
+  compareOptions(a, b) {
+    const getSortKey = (option) => {
+      return option.short ? option.short.replace(/^-/, "") : option.long.replace(/^--/, "");
+    };
+    return getSortKey(a).localeCompare(getSortKey(b));
+  }
+  /**
+   * Get an array of the visible options. Includes a placeholder for the implicit help option, if there is one.
+   */
+  visibleOptions(cmd) {
+    const visibleOptions = cmd.options.filter((option) => !option.hidden);
+    if (this.sortOptions) {
+      visibleOptions.sort(this.compareOptions);
+    }
+    return visibleOptions;
+  }
+  /**
+   * Get an array of the visible global options. (Not including help.)
+   */
+  visibleGlobalOptions(cmd) {
+    if (!this.showGlobalOptions) return [];
+    const globalOptions = [];
+    for (let ancestorCmd = cmd.parent; ancestorCmd; ancestorCmd = ancestorCmd.parent) {
+      const visibleOptions = ancestorCmd.options.filter((option) => !option.hidden);
+      globalOptions.push(...visibleOptions);
+    }
+    if (this.sortOptions) {
+      globalOptions.sort(this.compareOptions);
+    }
+    return globalOptions;
+  }
+  /**
+   * Get an array of the arguments if any have a description.
+   */
+  visibleArguments(cmd) {
+    if (cmd.arguments.find((argument) => argument.description)) {
+      return [...cmd.arguments];
+    }
+    return [];
+  }
+  /**
+   * Get the command term to show in the list of subcommands.
+   */
+  subcommandTerm(cmd) {
+    const args = cmd.arguments.map((arg) => humanReadableArgName(arg)).join(" ");
+    return cmd.name + (cmd.aliases[0] ? "|" + cmd.aliases[0] : "") + (cmd.options.length ? " [options]" : "") + // simplistic check for non-help option
+    (args ? " " + args : "");
+  }
+  /**
+   * Get the option term to show in the list of options.
+   */
+  optionTerm(option) {
+    return option.flags;
+  }
+  /**
+   * Get the argument term to show in the list of arguments.
+   */
+  argumentTerm(argument) {
+    return argument.name;
+  }
+  /**
+   * Get the longest command term length.
+   */
+  longestSubcommandTermLength(cmd, helper) {
+    return helper.visibleCommands(cmd).reduce((max, command) => {
+      return Math.max(max, this.displayWidth(helper.styleSubcommandTerm(helper.subcommandTerm(command))));
+    }, 0);
+  }
+  /**
+   * Get the longest option term length.
+   */
+  longestOptionTermLength(cmd, helper) {
+    return helper.visibleOptions(cmd).reduce((max, option) => {
+      return Math.max(max, this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option))));
+    }, 0);
+  }
+  /**
+   * Get the longest global option term length.
+   */
+  longestGlobalOptionTermLength(cmd, helper) {
+    return helper.visibleGlobalOptions(cmd).reduce((max, option) => {
+      return Math.max(max, this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option))));
+    }, 0);
+  }
+  /**
+   * Get the longest argument term length.
+   */
+  longestArgumentTermLength(cmd, helper) {
+    return helper.visibleArguments(cmd).reduce((max, argument) => {
+      return Math.max(max, this.displayWidth(helper.styleArgumentTerm(helper.argumentTerm(argument))));
+    }, 0);
+  }
+  /**
+   * Get the command usage to be displayed at the top of the built-in help.
+   */
+  commandUsage(cmd) {
+    let cmdName = cmd.name;
+    if (cmd.aliases[0]) {
+      cmdName = cmdName + "|" + cmd.aliases[0];
+    }
+    let ancestorCmdNames = "";
+    for (let ancestorCmd = cmd.parent; ancestorCmd; ancestorCmd = ancestorCmd.parent) {
+      ancestorCmdNames = ancestorCmd.name + " " + ancestorCmdNames;
+    }
+    return ancestorCmdNames + cmdName + " " + cmd.usage;
+  }
+  /**
+   * Get the description for the command.
+   */
+  commandDescription(cmd) {
+    return cmd.description;
+  }
+  /**
+   * Get the subcommand summary to show in the list of subcommands.
+   * (Fallback to description for backwards compatibility.)
+   */
+  subcommandDescription(cmd) {
+    return cmd.summary || cmd.description;
+  }
+  /**
+   * Get the option description to show in the list of options.
+   */
+  optionDescription(option) {
+    const extraInfo = [];
+    if (option.choices) {
+      extraInfo.push(
+        // use stringify to match the display of the default value
+        `choices: ${option.choices.map((choice) => String(choice)).join(", ")}`
+      );
+    }
+    if (option.defaultValue !== void 0) {
+      const boolean = !option.required && !option.optional && !option.negate;
+      const showDefault = option.required || option.optional || boolean && typeof option.defaultValue === "boolean";
+      if (showDefault) {
+        extraInfo.push(`default: ${option.defaultValueDescription || String(option.defaultValue)}`);
+      }
+    }
+    if (option.env !== void 0) {
+      extraInfo.push(`env: ${option.env}`);
+    }
+    if (extraInfo.length > 0) {
+      const extraDescription = `(${extraInfo.join(", ")})`;
+      if (option.description) {
+        return `${option.description} ${extraDescription}`;
+      }
+      return extraDescription;
+    }
+    return option.description;
+  }
+  /**
+   * Get the argument description to show in the list of arguments.
+   */
+  argumentDescription(argument) {
+    const extraInfo = [];
+    if (argument.choices) {
+      extraInfo.push(
+        // use stringify to match the display of the default value
+        `choices: ${argument.choices.map((choice) => String(choice)).join(", ")}`
+      );
+    }
+    if (argument.defaultValue !== void 0) {
+      extraInfo.push(`default: ${argument.defaultValueDescription || String(argument.defaultValue)}`);
+    }
+    if (extraInfo.length > 0) {
+      const extraDescription = `(${extraInfo.join(", ")})`;
+      if (argument.description) {
+        return `${argument.description} ${extraDescription}`;
+      }
+      return extraDescription;
+    }
+    return argument.description;
+  }
+  /**
+   * Format a list of items, given a heading and an array of formatted items.
+   */
+  formatItemList(heading, items, helper) {
+    if (items.length === 0) return [];
+    return [helper.styleTitle(heading), ...items, ""];
+  }
+  /**
+   * Group items by their help group heading.
+   */
+  groupItems(unsortedItems, visibleItems, getGroup) {
+    const result = /* @__PURE__ */ new Map();
+    unsortedItems.forEach((item) => {
+      const group = getGroup(item);
+      if (!result.has(group)) result.set(group, []);
+    });
+    visibleItems.forEach((item) => {
+      const group = getGroup(item);
+      if (!result.has(group)) {
+        result.set(group, []);
+      }
+      result.get(group).push(item);
+    });
+    return result;
+  }
+  /**
+   * Generate the built-in help text.
+   */
+  formatHelp(cmd, helper) {
+    const termWidth = helper.padWidth(cmd, helper);
+    const helpWidth = helper.helpWidth;
+    function callFormatItem(term, description) {
+      return helper.formatItem(term, termWidth, description, helper);
+    }
+    let output = [`${helper.styleTitle("Usage:")} ${helper.styleUsage(helper.commandUsage(cmd))}`, ""];
+    const commandDescription = helper.commandDescription(cmd);
+    if (commandDescription.length > 0) {
+      output = output.concat([helper.boxWrap(helper.styleCommandDescription(commandDescription), helpWidth), ""]);
+    }
+    const argumentList = helper.visibleArguments(cmd).map((argument) => {
+      return callFormatItem(
+        helper.styleArgumentTerm(helper.argumentTerm(argument)),
+        helper.styleArgumentDescription(helper.argumentDescription(argument))
+      );
+    });
+    output = output.concat(this.formatItemList("Arguments:", argumentList, helper));
+    const optionGroups = this.groupItems(
+      cmd.options,
+      helper.visibleOptions(cmd),
+      (option) => option.group ?? "Options:"
+    );
+    optionGroups.forEach((options, group) => {
+      const optionList = options.map((option) => {
+        return callFormatItem(
+          helper.styleOptionTerm(helper.optionTerm(option)),
+          helper.styleOptionDescription(helper.optionDescription(option))
+        );
+      });
+      output = output.concat(this.formatItemList(group, optionList, helper));
+    });
+    if (helper.showGlobalOptions) {
+      const globalOptionList = helper.visibleGlobalOptions(cmd).map((option) => {
+        return callFormatItem(
+          helper.styleOptionTerm(helper.optionTerm(option)),
+          helper.styleOptionDescription(helper.optionDescription(option))
+        );
+      });
+      output = output.concat(this.formatItemList("Global Options:", globalOptionList, helper));
+    }
+    const commandGroups = this.groupItems(
+      cmd.commands,
+      helper.visibleCommands(cmd),
+      (sub) => sub.group || "Commands:"
+    );
+    commandGroups.forEach((commands, group) => {
+      const commandList = commands.map((sub) => {
+        return callFormatItem(
+          helper.styleSubcommandTerm(helper.subcommandTerm(sub)),
+          helper.styleSubcommandDescription(helper.subcommandDescription(sub))
+        );
+      });
+      output = output.concat(this.formatItemList(group, commandList, helper));
+    });
+    return output.join("\n");
+  }
+  /**
+   * Return display width of string, ignoring ANSI escape sequences. Used in padding and wrapping calculations.
+   */
+  displayWidth(str) {
+    return stripColor(str).length;
+  }
+  /**
+   * Style the title for displaying in the help. Called with 'Usage:', 'Options:', etc.
+   */
+  styleTitle(str) {
+    return str;
+  }
+  /**
+   * Style the usage line for displaying in the help. Applies specific styling to different parts like options, commands, and arguments.
+   */
+  styleUsage(str) {
+    return str.split(" ").map((word) => {
+      if (word === "[options]") return this.styleOptionText(word);
+      if (word === "[command]") return this.styleSubcommandText(word);
+      if (word[0] === "[" || word[0] === "<") return this.styleArgumentText(word);
+      return this.styleCommandText(word);
+    }).join(" ");
+  }
+  /**
+   * Style command descriptions for display in help output.
+   */
+  styleCommandDescription(str) {
+    return this.styleDescriptionText(str);
+  }
+  /**
+   * Style option descriptions for display in help output.
+   */
+  styleOptionDescription(str) {
+    return this.styleDescriptionText(str);
+  }
+  /**
+   * Style subcommand descriptions for display in help output.
+   */
+  styleSubcommandDescription(str) {
+    return this.styleDescriptionText(str);
+  }
+  /**
+   * Style argument descriptions for display in help output.
+   */
+  styleArgumentDescription(str) {
+    return this.styleDescriptionText(str);
+  }
+  /**
+   * Base style used by descriptions. Override in subclass to apply custom formatting.
+   */
+  styleDescriptionText(str) {
+    return str;
+  }
+  /**
+   * Style option terms (flags) for display in help output.
+   */
+  styleOptionTerm(str) {
+    return this.styleOptionText(str);
+  }
+  /**
+   * Style subcommand terms for display in help output. Applies specific styling to different parts like options and arguments.
+   */
+  styleSubcommandTerm(str) {
+    return str.split(" ").map((word) => {
+      if (word === "[options]") return this.styleOptionText(word);
+      if (word[0] === "[" || word[0] === "<") return this.styleArgumentText(word);
+      return this.styleSubcommandText(word);
+    }).join(" ");
+  }
+  /**
+   * Style argument terms for display in help output.
+   */
+  styleArgumentTerm(str) {
+    return this.styleArgumentText(str);
+  }
+  /**
+   * Base style used in terms and usage for options. Override in subclass to apply custom formatting.
+   */
+  styleOptionText(str) {
+    return str;
+  }
+  /**
+   * Base style used in terms and usage for arguments. Override in subclass to apply custom formatting.
+   */
+  styleArgumentText(str) {
+    return str;
+  }
+  /**
+   * Base style used in terms and usage for subcommands. Override in subclass to apply custom formatting.
+   */
+  styleSubcommandText(str) {
+    return str;
+  }
+  /**
+   * Base style used in terms and usage for commands. Override in subclass to apply custom formatting.
+   */
+  styleCommandText(str) {
+    return str;
+  }
+  /**
+   * Calculate the pad width from the maximum term length.
+   */
+  padWidth(cmd, helper) {
+    return Math.max(
+      helper.longestOptionTermLength(cmd, helper),
+      helper.longestGlobalOptionTermLength(cmd, helper),
+      helper.longestSubcommandTermLength(cmd, helper),
+      helper.longestArgumentTermLength(cmd, helper)
+    );
+  }
+  /**
+   * Detect manually wrapped and indented strings by checking for line break followed by whitespace.
+   */
+  preformatted(str) {
+    return /\n[^\S\r\n]/.test(str);
+  }
+  /**
+   * Format the "item", which consists of a term and description. Pad the term and wrap the description, indenting the following lines.
+   *
+   * So "TTT", 5, "DDD DDDD DD DDD" might be formatted for this.helpWidth=17 like so:
+   *   TTT  DDD DDDD
+   *        DD DDD
+   */
+  formatItem(term, termWidth, description, helper) {
+    const itemIndent = 2;
+    const itemIndentStr = " ".repeat(itemIndent);
+    if (!description) return itemIndentStr + term;
+    const paddedTerm = term.padEnd(termWidth + term.length - helper.displayWidth(term));
+    const spacerWidth = 2;
+    const helpWidth = this.helpWidth;
+    const remainingWidth = helpWidth - termWidth - spacerWidth - itemIndent;
+    let formattedDescription;
+    if (remainingWidth < this.minWidthToWrap || helper.preformatted(description)) {
+      formattedDescription = description;
+    } else {
+      const wrappedDescription = helper.boxWrap(description, remainingWidth);
+      formattedDescription = wrappedDescription.replace(/\n/g, "\n" + " ".repeat(termWidth + spacerWidth));
+    }
+    return itemIndentStr + paddedTerm + " ".repeat(spacerWidth) + formattedDescription.replace(/\n/g, `
+${itemIndentStr}`);
+  }
+  /**
+   * Wrap a string at whitespace, preserving existing line breaks.
+   * Wrapping is skipped if the width is less than `minWidthToWrap`.
+   */
+  boxWrap(str, width) {
+    if (width < this.minWidthToWrap) return str;
+    const rawLines = str.split(/\r\n|\n/);
+    const chunkPattern = /[\s]*[^\s]+/g;
+    const wrappedLines = [];
+    rawLines.forEach((line) => {
+      const chunks = line.match(chunkPattern);
+      if (chunks === null) {
+        wrappedLines.push("");
+        return;
+      }
+      let sumChunks = [chunks.shift()];
+      let sumWidth = this.displayWidth(sumChunks[0]);
+      chunks.forEach((chunk) => {
+        const visibleWidth = this.displayWidth(chunk);
+        if (sumWidth + visibleWidth <= width) {
+          sumChunks.push(chunk);
+          sumWidth += visibleWidth;
+          return;
+        }
+        wrappedLines.push(sumChunks.join(""));
+        const nextChunk = chunk.trimStart();
+        sumChunks = [nextChunk];
+        sumWidth = this.displayWidth(nextChunk);
+      });
+      wrappedLines.push(sumChunks.join(""));
+    });
+    return wrappedLines.join("\n");
+  }
+}
+function stripColor(str) {
+  const sgrPattern = /\x1b\[\d*(;\d*)*m/g;
+  return str.replace(sgrPattern, "");
+}
+function humanReadableArgName(arg) {
+  const nameOutput = arg.name + (arg.variadic === true ? "..." : "");
+  return arg.required ? "<" + nameOutput + ">" : "[" + nameOutput + "]";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Help
+});
+//# sourceMappingURL=Help.cjs.map

package/cjs/lib/internal/lazyProp.cjs

@@ -0,0 +1,41 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lazyProp_exports = {};
+__export(lazyProp_exports, {
+  default: () => lazyProp
+});
+module.exports = __toCommonJS(lazyProp_exports);
+function lazyProp(target, key, descriptor) {
+  const orig = descriptor.get;
+  if (typeof orig !== "function") {
+    throw new Error('"get" not a function');
+  }
+  descriptor.get = function() {
+    const value = orig.call(this);
+    Object.defineProperty(this, key, {
+      enumerable: false,
+      writable: false,
+      configurable: true,
+      value
+    });
+    return value;
+  };
+  return descriptor;
+}
+//# sourceMappingURL=lazyProp.cjs.map

package/cjs/lib/renderHelp.cjs

@@ -0,0 +1,33 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var renderHelp_exports = {};
+__export(renderHelp_exports, {
+  renderHelp: () => renderHelp
+});
+module.exports = __toCommonJS(renderHelp_exports);
+var import_Help = require("./Help");
+function renderHelp(cmd, help = new import_Help.Help()) {
+  const helper = Object.assign(help, cmd.helpConfiguration);
+  return helper.formatHelp(cmd, helper);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  renderHelp
+});
+//# sourceMappingURL=renderHelp.cjs.map

package/{index.js → esm/index.mjs}

@@ -3,4 +3,4 @@ export * from "./lib/CommandHelpAdapter";
 export * from "./lib/CommanderHelpAdapter";
 export * from "./lib/Help";
 export * from "./lib/renderHelp";
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.mjs.map