@bemoje/cli 0.2.1 → 1.0.0

package/lib/Help.js

@@ -0,0 +1,477 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+const _Help = class _Help {
+  constructor() {
+    /** output helpWidth, long lines are wrapped to fit */
+    __publicField(this, "helpWidth", process.stdout.isTTY ? process.stdout.columns : 80);
+    __publicField(this, "minWidthToWrap", 40);
+    __publicField(this, "sortSubcommands");
+    __publicField(this, "sortOptions");
+    __publicField(this, "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 = /* @__PURE__ */ __name((option) => {
+      return option.short ? option.short.replace(/^-/, "") : option.long.replace(/^--/, "");
+    }, "getSortKey");
+    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);
+    }
+    __name(callFormatItem, "callFormatItem");
+    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");
+  }
+};
+__name(_Help, "Help");
+let Help = _Help;
+function stripColor(str) {
+  const sgrPattern = /\x1b\[\d*(;\d*)*m/g;
+  return str.replace(sgrPattern, "");
+}
+__name(stripColor, "stripColor");
+function humanReadableArgName(arg) {
+  const nameOutput = arg.name + (arg.variadic === true ? "..." : "");
+  return arg.required ? "<" + nameOutput + ">" : "[" + nameOutput + "]";
+}
+__name(humanReadableArgName, "humanReadableArgName");
+export {
+  Help
+};
+//# sourceMappingURL=Help.js.map

package/lib/internal/lazyProp.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Decorator to make a getter accessor property lazy loaded by setting the property value on the object
+ */
+export default function lazyProp(target: unknown, key: string | symbol, descriptor: PropertyDescriptor): PropertyDescriptor;
+//# sourceMappingURL=lazyProp.d.ts.map

package/lib/internal/lazyProp.js

@@ -0,0 +1,24 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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;
+}
+__name(lazyProp, "lazyProp");
+export {
+  lazyProp as default
+};
+//# sourceMappingURL=lazyProp.js.map

package/lib/renderHelp.d.ts

@@ -0,0 +1,6 @@
+import { ICommandHelp, IHelp } from './Help';
+/**
+ * Renders help for a command using the specified help instance.
+ */
+export declare function renderHelp(cmd: ICommandHelp, help?: IHelp): string;
+//# sourceMappingURL=renderHelp.d.ts.map

package/lib/renderHelp.js

@@ -0,0 +1,12 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { Help } from "./Help";
+function renderHelp(cmd, help = new Help()) {
+  const helper = Object.assign(help, cmd.helpConfiguration);
+  return helper.formatHelp(cmd, helper);
+}
+__name(renderHelp, "renderHelp");
+export {
+  renderHelp
+};
+//# sourceMappingURL=renderHelp.js.map

package/package.json

@@ -1,46 +1,55 @@
 {
   "name": "@bemoje/cli",
-  "version": "0.2.1",
-  "type": "commonjs",
-  "main": "cjs/index.js",
-  "types": "cjs/index.d.ts",
-  "dependencies": {
-    "@bemoje/array": "latest",
-    "@bemoje/err": "latest",
-    "@bemoje/fs": "latest",
-    "@bemoje/function": "latest",
-    "@bemoje/is": "latest",
-    "@bemoje/jsondb": "latest",
-    "@bemoje/node": "latest",
-    "@bemoje/object": "latest",
-    "@bemoje/os": "latest",
-    "@bemoje/parse": "latest",
-    "@bemoje/string": "latest",
-    "@bemoje/types": "latest",
-    "@commander-js/extra-typings": "^11.1.0",
-    "ansi-colors": "^4.1.3",
-    "eventemitter3": "^5.0.1",
-    "fs-extra": "^11.2.0",
-    "is-async-function": "^2.0.0",
-    "tslib": "latest"
+  "description": "A type-safe CLI builder focused on command composition and help generation without execution coupling. Parse arguments, generate help, and integrate with existing CLI frameworks through a clean, fluent API.",
+  "version": "1.0.0",
+  "private": false,
+  "sideEffects": false,
+  "type": "module",
+  "module": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./index.js": "./index.js",
+    "./index.d.ts": "./index.d.ts",
+    "./*": "./lib/*",
+    "./package.json": "./package.json"
+  },
+  "typings": "index.d.ts",
+  "dependencies": {},
+  "devDependencies": {
+    "commander": "^14.0.0"
   },
   "license": "MIT",
-  "keywords": [],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bemoje/mono.git"
+  },
+  "keywords": [
+    "cli",
+    "command-line",
+    "argument-parser",
+    "options-parser",
+    "typescript",
+    "type-safe",
+    "fluent-api",
+    "help-generation",
+    "commander",
+    "commander.js",
+    "subcommands",
+    "validation",
+    "parsing",
+    "composition",
+    "adapter",
+    "terminal",
+    "console",
+    "args",
+    "argv",
+    "bemoje",
+    "cli"
+  ],
   "author": {
     "name": "Benjamin Møller Jensen",
     "email": "bemoje@bemoje.net",
     "url": "https://github.com/bemoje/"
   },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/bemoje/tsmono.git"
-  },
-  "funding": {
-    "type": "patreon",
-    "url": "https://www.patreon.com/user?u=40752770"
-  },
-  "bugs": {
-    "url": "https://github.com/bemoje/tsmono/issues"
-  },
-  "homepage": "https://github.com/bemoje/tsmono"
+  "homepage": "https://github.com/bemoje/mono/tree/main/libs/cli"
 }

package/cjs/arg/ArgumentBuilder.d.ts

@@ -1,23 +0,0 @@
-import { Argument } from '@commander-js/extra-typings';
-import { ArgumentParserSelector } from './ArgumentParserSelector';
-import { ArgumentReader } from './ArgumentReader';
-import { ArgumentValidatorSelector } from './ArgumentValidatorSelector';
-import { CommandBuilder } from '../cmd/CommandBuilder';
-/**
- * Wrapper around the @see Argument class from 'commander'.
- */
-export declare class ArgumentBuilder {
-    readonly cmd: CommandBuilder;
-    readonly $: Argument;
-    readonly index: number;
-    constructor(cmd: CommandBuilder, name: string);
-    get hasValidators(): boolean;
-    get hasParser(): boolean;
-    description(...lines: string[]): this;
-    default(value: unknown, description?: string): this;
-    choices(values: readonly string[]): this;
-    get parser(): ArgumentParserSelector;
-    get validator(): ArgumentValidatorSelector;
-    get get(): ArgumentReader;
-}
-//# sourceMappingURL=ArgumentBuilder.d.ts.map

package/cjs/arg/ArgumentBuilder.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ArgumentBuilder.d.ts","sourceRoot":"","sources":["../../../../../packages/cli/src/arg/ArgumentBuilder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAA;AACtD,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAA;AACjE,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AACjD,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAA;AACvE,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAGtD;;GAEG;AACH,qBAAa,eAAe;IAId,QAAQ,CAAC,GAAG,EAAE,cAAc;IAHxC,QAAQ,CAAC,CAAC,EAAE,QAAQ,CAAA;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;gBAED,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM;IAOtD,IAAI,aAAa,YAEhB;IAED,IAAI,SAAS,YAEZ;IAED,WAAW,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE;IAK9B,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,WAAW,CAAC,EAAE,MAAM;IAK5C,OAAO,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE;IAKjC,IAAI,MAAM,2BAET;IAED,IAAI,SAAS,8BAEZ;IAED,IAAI,GAAG,mBAEN;CACF"}