aurora-langium 0.2.28 → 0.3.0

package/dist/cjs/cli/index.cjs

@@ -1118,8 +1118,8 @@ var require_semaphore = __commonJS({
         this._waiting = [];
       }
       lock(thunk) {
-        return new Promise((resolve2, reject2) => {
-          this._waiting.push({ thunk, resolve: resolve2, reject: reject2 });
+        return new Promise((resolve3, reject2) => {
+          this._waiting.push({ thunk, resolve: resolve3, reject: reject2 });
           this.runNext();
         });
       }
@@ -1705,7 +1705,7 @@ var require_connection = __commonJS({
         }
       }
       Trace2.fromString = fromString;
-      function toString3(value) {
+      function toString4(value) {
         switch (value) {
           case Trace2.Off:
             return "off";
@@ -1719,7 +1719,7 @@ var require_connection = __commonJS({
             return "off";
         }
       }
-      Trace2.toString = toString3;
+      Trace2.toString = toString4;
     })(Trace || (exports2.Trace = Trace = {}));
     var TraceFormat;
     (function(TraceFormat2) {
@@ -2614,9 +2614,9 @@ ${JSON.stringify(message, null, 4)}`);
           if (typeof cancellationStrategy.sender.enableCancellation === "function") {
             cancellationStrategy.sender.enableCancellation(requestMessage);
           }
-          return new Promise(async (resolve2, reject2) => {
+          return new Promise(async (resolve3, reject2) => {
             const resolveWithCleanup = (r) => {
-              resolve2(r);
+              resolve3(r);
               cancellationStrategy.sender.cleanup(id);
               disposable == null ? void 0 : disposable.dispose();
             };
@@ -3027,10 +3027,10 @@ var require_ril = __commonJS({
         return api_1.Disposable.create(() => this.stream.off("end", listener));
       }
       write(data, encoding) {
-        return new Promise((resolve2, reject2) => {
+        return new Promise((resolve3, reject2) => {
           const callback = (error) => {
             if (error === void 0 || error === null) {
-              resolve2();
+              resolve3();
             } else {
               reject2(error);
             }
@@ -3137,7 +3137,7 @@ var require_main = __commonJS({
     exports2.createMessageConnection = exports2.createServerSocketTransport = exports2.createClientSocketTransport = exports2.createServerPipeTransport = exports2.createClientPipeTransport = exports2.generateRandomPipeName = exports2.StreamMessageWriter = exports2.StreamMessageReader = exports2.SocketMessageWriter = exports2.SocketMessageReader = exports2.PortMessageWriter = exports2.PortMessageReader = exports2.IPCMessageWriter = exports2.IPCMessageReader = void 0;
     var ril_1 = require_ril();
     ril_1.default.install();
-    var path2 = require("path");
+    var path4 = require("path");
     var os2 = require("os");
     var crypto_1 = require("crypto");
     var net_1 = require("net");
@@ -3273,9 +3273,9 @@ var require_main = __commonJS({
       }
       let result;
       if (XDG_RUNTIME_DIR) {
-        result = path2.join(XDG_RUNTIME_DIR, `vscode-ipc-${randomSuffix}.sock`);
+        result = path4.join(XDG_RUNTIME_DIR, `vscode-ipc-${randomSuffix}.sock`);
       } else {
-        result = path2.join(os2.tmpdir(), `vscode-${randomSuffix}.sock`);
+        result = path4.join(os2.tmpdir(), `vscode-${randomSuffix}.sock`);
       }
       const limit = safeIpcPathLengths.get(process.platform);
       if (limit !== void 0 && result.length > limit) {
@@ -3286,10 +3286,10 @@ var require_main = __commonJS({
     exports2.generateRandomPipeName = generateRandomPipeName;
     function createClientPipeTransport(pipeName, encoding = "utf-8") {
       let connectResolve;
-      const connected = new Promise((resolve2, _reject) => {
-        connectResolve = resolve2;
+      const connected = new Promise((resolve3, _reject) => {
+        connectResolve = resolve3;
       });
-      return new Promise((resolve2, reject2) => {
+      return new Promise((resolve3, reject2) => {
         let server = (0, net_1.createServer)((socket) => {
           server.close();
           connectResolve([
@@ -3300,7 +3300,7 @@ var require_main = __commonJS({
         server.on("error", reject2);
         server.listen(pipeName, () => {
           server.removeListener("error", reject2);
-          resolve2({
+          resolve3({
             onConnected: () => {
               return connected;
             }
@@ -3319,10 +3319,10 @@ var require_main = __commonJS({
     exports2.createServerPipeTransport = createServerPipeTransport;
     function createClientSocketTransport(port, encoding = "utf-8") {
       let connectResolve;
-      const connected = new Promise((resolve2, _reject) => {
-        connectResolve = resolve2;
+      const connected = new Promise((resolve3, _reject) => {
+        connectResolve = resolve3;
       });
-      return new Promise((resolve2, reject2) => {
+      return new Promise((resolve3, reject2) => {
         const server = (0, net_1.createServer)((socket) => {
           server.close();
           connectResolve([
@@ -3333,7 +3333,7 @@ var require_main = __commonJS({
         server.on("error", reject2);
         server.listen(port, "127.0.0.1", () => {
           server.removeListener("error", reject2);
-          resolve2({
+          resolve3({
             onConnected: () => {
               return connected;
             }
@@ -3631,8 +3631,8 @@ var require_main2 = __commonJS({
         }
         Diagnostic3.is = is;
       })(Diagnostic2 || (exports3.Diagnostic = Diagnostic2 = {}));
-      var Command2;
-      (function(Command3) {
+      var Command3;
+      (function(Command4) {
         function create(title, command) {
           var args = [];
           for (var _i = 2; _i < arguments.length; _i++) {
@@ -3644,13 +3644,13 @@ var require_main2 = __commonJS({
           }
           return result;
         }
-        Command3.create = create;
+        Command4.create = create;
         function is(value) {
           var candidate = value;
           return Is2.defined(candidate) && Is2.string(candidate.title) && Is2.string(candidate.command);
         }
-        Command3.is = is;
-      })(Command2 || (exports3.Command = Command2 = {}));
+        Command4.is = is;
+      })(Command3 || (exports3.Command = Command3 = {}));
       var TextEdit2;
       (function(TextEdit3) {
         function replace(range, newText) {
@@ -4427,7 +4427,7 @@ var require_main2 = __commonJS({
           if (typeof kindOrCommandOrEdit === "string") {
             checkKind = false;
             result.kind = kindOrCommandOrEdit;
-          } else if (Command2.is(kindOrCommandOrEdit)) {
+          } else if (Command3.is(kindOrCommandOrEdit)) {
             result.command = kindOrCommandOrEdit;
           } else {
             result.edit = kindOrCommandOrEdit;
@@ -4440,7 +4440,7 @@ var require_main2 = __commonJS({
         CodeAction3.create = create;
         function is(value) {
           var candidate = value;
-          return candidate && Is2.string(candidate.title) && (candidate.diagnostics === void 0 || Is2.typedArray(candidate.diagnostics, Diagnostic2.is)) && (candidate.kind === void 0 || Is2.string(candidate.kind)) && (candidate.edit !== void 0 || candidate.command !== void 0) && (candidate.command === void 0 || Command2.is(candidate.command)) && (candidate.isPreferred === void 0 || Is2.boolean(candidate.isPreferred)) && (candidate.edit === void 0 || WorkspaceEdit2.is(candidate.edit));
+          return candidate && Is2.string(candidate.title) && (candidate.diagnostics === void 0 || Is2.typedArray(candidate.diagnostics, Diagnostic2.is)) && (candidate.kind === void 0 || Is2.string(candidate.kind)) && (candidate.edit !== void 0 || candidate.command !== void 0) && (candidate.command === void 0 || Command3.is(candidate.command)) && (candidate.isPreferred === void 0 || Is2.boolean(candidate.isPreferred)) && (candidate.edit === void 0 || WorkspaceEdit2.is(candidate.edit));
         }
         CodeAction3.is = is;
       })(CodeAction2 || (exports3.CodeAction = CodeAction2 = {}));
@@ -4456,7 +4456,7 @@ var require_main2 = __commonJS({
         CodeLens3.create = create;
         function is(value) {
           var candidate = value;
-          return Is2.defined(candidate) && Range2.is(candidate.range) && (Is2.undefined(candidate.command) || Command2.is(candidate.command));
+          return Is2.defined(candidate) && Range2.is(candidate.range) && (Is2.undefined(candidate.command) || Command3.is(candidate.command));
         }
         CodeLens3.is = is;
       })(CodeLens2 || (exports3.CodeLens = CodeLens2 = {}));
@@ -4608,7 +4608,7 @@ var require_main2 = __commonJS({
         InlayHintLabelPart3.create = create;
         function is(value) {
           var candidate = value;
-          return Is2.objectLiteral(candidate) && (candidate.tooltip === void 0 || Is2.string(candidate.tooltip) || MarkupContent2.is(candidate.tooltip)) && (candidate.location === void 0 || Location3.is(candidate.location)) && (candidate.command === void 0 || Command2.is(candidate.command));
+          return Is2.objectLiteral(candidate) && (candidate.tooltip === void 0 || Is2.string(candidate.tooltip) || MarkupContent2.is(candidate.tooltip)) && (candidate.location === void 0 || Location3.is(candidate.location)) && (candidate.command === void 0 || Command3.is(candidate.command));
         }
         InlayHintLabelPart3.is = is;
       })(InlayHintLabelPart2 || (exports3.InlayHintLabelPart = InlayHintLabelPart2 = {}));
@@ -4849,7 +4849,7 @@ var require_main2 = __commonJS({
       );
       var Is2;
       (function(Is3) {
-        var toString3 = Object.prototype.toString;
+        var toString4 = Object.prototype.toString;
         function defined(value) {
           return typeof value !== "undefined";
         }
@@ -4863,27 +4863,27 @@ var require_main2 = __commonJS({
         }
         Is3.boolean = boolean;
         function string(value) {
-          return toString3.call(value) === "[object String]";
+          return toString4.call(value) === "[object String]";
         }
         Is3.string = string;
         function number(value) {
-          return toString3.call(value) === "[object Number]";
+          return toString4.call(value) === "[object Number]";
         }
         Is3.number = number;
         function numberRange(value, min2, max) {
-          return toString3.call(value) === "[object Number]" && min2 <= value && value <= max;
+          return toString4.call(value) === "[object Number]" && min2 <= value && value <= max;
         }
         Is3.numberRange = numberRange;
         function integer3(value) {
-          return toString3.call(value) === "[object Number]" && -2147483648 <= value && value <= 2147483647;
+          return toString4.call(value) === "[object Number]" && -2147483648 <= value && value <= 2147483647;
         }
         Is3.integer = integer3;
         function uinteger3(value) {
-          return toString3.call(value) === "[object Number]" && 0 <= value && value <= 2147483647;
+          return toString4.call(value) === "[object Number]" && 0 <= value && value <= 2147483647;
         }
         Is3.uinteger = uinteger3;
         function func(value) {
-          return toString3.call(value) === "[object Function]";
+          return toString4.call(value) === "[object Function]";
         }
         Is3.func = func;
         function objectLiteral(value) {
@@ -8130,8 +8130,8 @@ var require_server = __commonJS({
         if (value instanceof Promise) {
           return value;
         } else if (Is2.thenable(value)) {
-          return new Promise((resolve2, reject2) => {
-            value.then((resolved) => resolve2(resolved), (error) => reject2(error));
+          return new Promise((resolve3, reject2) => {
+            value.then((resolved) => resolve3(resolved), (error) => reject2(error));
           });
         } else {
           return Promise.resolve(value);
@@ -8376,8 +8376,8 @@ var require_files = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.resolveModulePath = exports2.FileSystem = exports2.resolveGlobalYarnPath = exports2.resolveGlobalNodePath = exports2.resolve = exports2.uriToFilePath = void 0;
     var url = require("url");
-    var path2 = require("path");
-    var fs3 = require("fs");
+    var path4 = require("path");
+    var fs5 = require("fs");
     var child_process_1 = require("child_process");
     function uriToFilePath(uri) {
       let parsed = url.parse(uri);
@@ -8395,13 +8395,13 @@ var require_files = __commonJS({
           segments.shift();
         }
       }
-      return path2.normalize(segments.join("/"));
+      return path4.normalize(segments.join("/"));
     }
     exports2.uriToFilePath = uriToFilePath;
     function isWindows() {
       return process.platform === "win32";
     }
-    function resolve2(moduleName, nodePath, cwd, tracer) {
+    function resolve3(moduleName, nodePath, cwd, tracer) {
       const nodePathKey = "NODE_PATH";
       const app = [
         "var p = process;",
@@ -8420,13 +8420,13 @@ var require_files = __commonJS({
         "}",
         "});"
       ].join("");
-      return new Promise((resolve3, reject2) => {
+      return new Promise((resolve4, reject2) => {
         let env2 = process.env;
         let newEnv = /* @__PURE__ */ Object.create(null);
         Object.keys(env2).forEach((key) => newEnv[key] = env2[key]);
-        if (nodePath && fs3.existsSync(nodePath)) {
+        if (nodePath && fs5.existsSync(nodePath)) {
           if (newEnv[nodePathKey]) {
-            newEnv[nodePathKey] = nodePath + path2.delimiter + newEnv[nodePathKey];
+            newEnv[nodePathKey] = nodePath + path4.delimiter + newEnv[nodePathKey];
           } else {
             newEnv[nodePathKey] = nodePath;
           }
@@ -8452,7 +8452,7 @@ var require_files = __commonJS({
             if (message2.c === "r") {
               cp.send({ c: "e" });
               if (message2.s) {
-                resolve3(message2.r);
+                resolve4(message2.r);
               } else {
                 reject2(new Error(`Failed to resolve module: ${moduleName}`));
               }
@@ -8468,7 +8468,7 @@ var require_files = __commonJS({
         }
       });
     }
-    exports2.resolve = resolve2;
+    exports2.resolve = resolve3;
     function resolveGlobalNodePath(tracer) {
       let npmCommand = "npm";
       const env2 = /* @__PURE__ */ Object.create(null);
@@ -8499,9 +8499,9 @@ var require_files = __commonJS({
         }
         if (prefix.length > 0) {
           if (isWindows()) {
-            return path2.join(prefix, "node_modules");
+            return path4.join(prefix, "node_modules");
           } else {
-            return path2.join(prefix, "lib", "node_modules");
+            return path4.join(prefix, "lib", "node_modules");
           }
         }
         return void 0;
@@ -8541,7 +8541,7 @@ var require_files = __commonJS({
           try {
             let yarn = JSON.parse(line);
             if (yarn.type === "log") {
-              return path2.join(yarn.data, "node_modules");
+              return path4.join(yarn.data, "node_modules");
             }
           } catch (e) {
           }
@@ -8564,36 +8564,36 @@ var require_files = __commonJS({
         if (process.platform === "win32") {
           _isCaseSensitive = false;
         } else {
-          _isCaseSensitive = !fs3.existsSync(__filename.toUpperCase()) || !fs3.existsSync(__filename.toLowerCase());
+          _isCaseSensitive = !fs5.existsSync(__filename.toUpperCase()) || !fs5.existsSync(__filename.toLowerCase());
         }
         return _isCaseSensitive;
       }
       FileSystem2.isCaseSensitive = isCaseSensitive;
       function isParent(parent, child) {
         if (isCaseSensitive()) {
-          return path2.normalize(child).indexOf(path2.normalize(parent)) === 0;
+          return path4.normalize(child).indexOf(path4.normalize(parent)) === 0;
         } else {
-          return path2.normalize(child).toLowerCase().indexOf(path2.normalize(parent).toLowerCase()) === 0;
+          return path4.normalize(child).toLowerCase().indexOf(path4.normalize(parent).toLowerCase()) === 0;
         }
       }
       FileSystem2.isParent = isParent;
     })(FileSystem || (exports2.FileSystem = FileSystem = {}));
     function resolveModulePath(workspaceRoot, moduleName, nodePath, tracer) {
       if (nodePath) {
-        if (!path2.isAbsolute(nodePath)) {
-          nodePath = path2.join(workspaceRoot, nodePath);
+        if (!path4.isAbsolute(nodePath)) {
+          nodePath = path4.join(workspaceRoot, nodePath);
         }
-        return resolve2(moduleName, nodePath, nodePath, tracer).then((value) => {
+        return resolve3(moduleName, nodePath, nodePath, tracer).then((value) => {
           if (FileSystem.isParent(nodePath, value)) {
             return value;
           } else {
             return Promise.reject(new Error(`Failed to load ${moduleName} from node path location.`));
           }
         }).then(void 0, (_error) => {
-          return resolve2(moduleName, resolveGlobalNodePath(tracer), workspaceRoot, tracer);
+          return resolve3(moduleName, resolveGlobalNodePath(tracer), workspaceRoot, tracer);
         });
       } else {
-        return resolve2(moduleName, resolveGlobalNodePath(tracer), workspaceRoot, tracer);
+        return resolve3(moduleName, resolveGlobalNodePath(tracer), workspaceRoot, tracer);
       }
     }
     exports2.resolveModulePath = resolveModulePath;
@@ -9502,8 +9502,8 @@ var require_async = __commonJS({
     var Deferred2 = class {
       constructor() {
         this._state = "unresolved";
-        this.promise = new Promise((resolve2, reject2) => {
-          this.resolve = resolve2;
+        this.promise = new Promise((resolve3, reject2) => {
+          this.resolve = resolve3;
           this.reject = reject2;
         });
         this.promise.then((res) => this._state = "resolved", (rej) => this._state = "rejected");
@@ -12575,7 +12575,7 @@ var require_context = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.Context = void 0;
     var id_1 = require_id();
-    var Context = class {
+    var Context2 = class {
       constructor(container) {
         __publicField(this, "id");
         __publicField(this, "container");
@@ -12591,7 +12591,7 @@ var require_context = __commonJS({
         this.currentRequest = currentRequest;
       }
     };
-    exports2.Context = Context;
+    exports2.Context = Context2;
   }
 });
 
@@ -13435,7 +13435,7 @@ var require_resolver = __commonJS({
       };
     }();
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.resolve = resolve2;
+    exports2.resolve = resolve3;
     var ERROR_MSGS = __importStar(require_error_msgs());
     var literal_types_1 = require_literal_types();
     var planner_1 = require_planner();
@@ -13581,7 +13581,7 @@ var require_resolver = __commonJS({
       };
       return containersIterator;
     };
-    function resolve2(context) {
+    function resolve3(context) {
       const resolveRequestFunction = _resolveRequest(context.plan.rootRequest.requestScope);
       return resolveRequestFunction(context.plan.rootRequest);
     }
@@ -16523,13 +16523,13 @@ var require_elk_bundled = __commonJS({
               this.id = id + 1;
               msg.id = id;
               var self2 = this;
-              return new Promise(function(resolve2, reject2) {
+              return new Promise(function(resolve3, reject2) {
                 self2.resolvers[id] = function(err, res) {
                   if (err) {
                     self2.convertGwtStyleError(err);
                     reject2(err);
                   } else {
-                    resolve2(res);
+                    resolve3(res);
                   }
                 };
                 self2.worker.postMessage(msg);
@@ -26764,7 +26764,7 @@ var require_elk_bundled = __commonJS({
               ++b.b;
               Ekb(a10.d, d);
             }
-            function fs3(a10, b) {
+            function fs5(a10, b) {
               var c;
               c = (uCb(a10), a10).g;
               lCb(!!c);
@@ -45855,7 +45855,7 @@ var require_elk_bundled = __commonJS({
             function m5c(c, d) {
               var e, f, g10;
               try {
-                g10 = fs3(c.a, d);
+                g10 = fs5(c.a, d);
                 return g10;
               } catch (b) {
                 b = ubb(b);
@@ -83785,7 +83785,7 @@ var require_elk_bundled = __commonJS({
             _2.Kb = function Azb(a10) {
               return CD(a10)[0];
             };
-            var NL = mdb(vke, "Collectors/lambda$28$Type", 1067);
+            var NL2 = mdb(vke, "Collectors/lambda$28$Type", 1067);
             bcb(713, 1, {}, Czb);
             _2.Ce = function Dzb(a10, b) {
               return Bzb(a10, b);
@@ -105220,11 +105220,2808 @@ var require_elk_bundled = __commonJS({
   }
 });
 
+// node_modules/commander/lib/error.js
+var require_error = __commonJS({
+  "node_modules/commander/lib/error.js"(exports2) {
+    var CommanderError2 = class extends Error {
+      /**
+       * Constructs the CommanderError class
+       * @param {number} exitCode suggested exit code which could be used with process.exit
+       * @param {string} code an id string representing the error
+       * @param {string} message human-readable description of the error
+       * @constructor
+       */
+      constructor(exitCode, code, message) {
+        super(message);
+        Error.captureStackTrace(this, this.constructor);
+        this.name = this.constructor.name;
+        this.code = code;
+        this.exitCode = exitCode;
+        this.nestedError = void 0;
+      }
+    };
+    var InvalidArgumentError2 = class extends CommanderError2 {
+      /**
+       * Constructs the InvalidArgumentError class
+       * @param {string} [message] explanation of why argument is invalid
+       * @constructor
+       */
+      constructor(message) {
+        super(1, "commander.invalidArgument", message);
+        Error.captureStackTrace(this, this.constructor);
+        this.name = this.constructor.name;
+      }
+    };
+    exports2.CommanderError = CommanderError2;
+    exports2.InvalidArgumentError = InvalidArgumentError2;
+  }
+});
+
+// node_modules/commander/lib/argument.js
+var require_argument = __commonJS({
+  "node_modules/commander/lib/argument.js"(exports2) {
+    var { InvalidArgumentError: InvalidArgumentError2 } = require_error();
+    var Argument2 = class {
+      /**
+       * Initialize a new command argument with the given name and description.
+       * The default is that the argument is required, and you can explicitly
+       * indicate this with <> around the name. Put [] around the name for an optional argument.
+       *
+       * @param {string} name
+       * @param {string} [description]
+       */
+      constructor(name, description) {
+        this.description = description || "";
+        this.variadic = false;
+        this.parseArg = void 0;
+        this.defaultValue = void 0;
+        this.defaultValueDescription = void 0;
+        this.argChoices = void 0;
+        switch (name[0]) {
+          case "<":
+            this.required = true;
+            this._name = name.slice(1, -1);
+            break;
+          case "[":
+            this.required = false;
+            this._name = name.slice(1, -1);
+            break;
+          default:
+            this.required = true;
+            this._name = name;
+            break;
+        }
+        if (this._name.length > 3 && this._name.slice(-3) === "...") {
+          this.variadic = true;
+          this._name = this._name.slice(0, -3);
+        }
+      }
+      /**
+       * Return argument name.
+       *
+       * @return {string}
+       */
+      name() {
+        return this._name;
+      }
+      /**
+       * @api private
+       */
+      _concatValue(value, previous) {
+        if (previous === this.defaultValue || !Array.isArray(previous)) {
+          return [value];
+        }
+        return previous.concat(value);
+      }
+      /**
+       * Set the default value, and optionally supply the description to be displayed in the help.
+       *
+       * @param {any} value
+       * @param {string} [description]
+       * @return {Argument}
+       */
+      default(value, description) {
+        this.defaultValue = value;
+        this.defaultValueDescription = description;
+        return this;
+      }
+      /**
+       * Set the custom handler for processing CLI command arguments into argument values.
+       *
+       * @param {Function} [fn]
+       * @return {Argument}
+       */
+      argParser(fn) {
+        this.parseArg = fn;
+        return this;
+      }
+      /**
+       * Only allow argument value to be one of choices.
+       *
+       * @param {string[]} values
+       * @return {Argument}
+       */
+      choices(values2) {
+        this.argChoices = values2.slice();
+        this.parseArg = (arg, previous) => {
+          if (!this.argChoices.includes(arg)) {
+            throw new InvalidArgumentError2(`Allowed choices are ${this.argChoices.join(", ")}.`);
+          }
+          if (this.variadic) {
+            return this._concatValue(arg, previous);
+          }
+          return arg;
+        };
+        return this;
+      }
+      /**
+       * Make argument required.
+       */
+      argRequired() {
+        this.required = true;
+        return this;
+      }
+      /**
+       * Make argument optional.
+       */
+      argOptional() {
+        this.required = false;
+        return this;
+      }
+    };
+    function humanReadableArgName(arg) {
+      const nameOutput = arg.name() + (arg.variadic === true ? "..." : "");
+      return arg.required ? "<" + nameOutput + ">" : "[" + nameOutput + "]";
+    }
+    exports2.Argument = Argument2;
+    exports2.humanReadableArgName = humanReadableArgName;
+  }
+});
+
+// node_modules/commander/lib/help.js
+var require_help = __commonJS({
+  "node_modules/commander/lib/help.js"(exports2) {
+    var { humanReadableArgName } = require_argument();
+    var Help2 = class {
+      constructor() {
+        this.helpWidth = void 0;
+        this.sortSubcommands = false;
+        this.sortOptions = false;
+        this.showGlobalOptions = false;
+      }
+      /**
+       * Get an array of the visible subcommands. Includes a placeholder for the implicit help command, if there is one.
+       *
+       * @param {Command} cmd
+       * @returns {Command[]}
+       */
+      visibleCommands(cmd) {
+        const visibleCommands = cmd.commands.filter((cmd2) => !cmd2._hidden);
+        if (cmd._hasImplicitHelpCommand()) {
+          const [, helpName, helpArgs] = cmd._helpCommandnameAndArgs.match(/([^ ]+) *(.*)/);
+          const helpCommand = cmd.createCommand(helpName).helpOption(false);
+          helpCommand.description(cmd._helpCommandDescription);
+          if (helpArgs)
+            helpCommand.arguments(helpArgs);
+          visibleCommands.push(helpCommand);
+        }
+        if (this.sortSubcommands) {
+          visibleCommands.sort((a2, b) => {
+            return a2.name().localeCompare(b.name());
+          });
+        }
+        return visibleCommands;
+      }
+      /**
+       * Compare options for sort.
+       *
+       * @param {Option} a
+       * @param {Option} b
+       * @returns number
+       */
+      compareOptions(a2, b) {
+        const getSortKey = (option2) => {
+          return option2.short ? option2.short.replace(/^-/, "") : option2.long.replace(/^--/, "");
+        };
+        return getSortKey(a2).localeCompare(getSortKey(b));
+      }
+      /**
+       * Get an array of the visible options. Includes a placeholder for the implicit help option, if there is one.
+       *
+       * @param {Command} cmd
+       * @returns {Option[]}
+       */
+      visibleOptions(cmd) {
+        const visibleOptions = cmd.options.filter((option2) => !option2.hidden);
+        const showShortHelpFlag = cmd._hasHelpOption && cmd._helpShortFlag && !cmd._findOption(cmd._helpShortFlag);
+        const showLongHelpFlag = cmd._hasHelpOption && !cmd._findOption(cmd._helpLongFlag);
+        if (showShortHelpFlag || showLongHelpFlag) {
+          let helpOption;
+          if (!showShortHelpFlag) {
+            helpOption = cmd.createOption(cmd._helpLongFlag, cmd._helpDescription);
+          } else if (!showLongHelpFlag) {
+            helpOption = cmd.createOption(cmd._helpShortFlag, cmd._helpDescription);
+          } else {
+            helpOption = cmd.createOption(cmd._helpFlags, cmd._helpDescription);
+          }
+          visibleOptions.push(helpOption);
+        }
+        if (this.sortOptions) {
+          visibleOptions.sort(this.compareOptions);
+        }
+        return visibleOptions;
+      }
+      /**
+       * Get an array of the visible global options. (Not including help.)
+       *
+       * @param {Command} cmd
+       * @returns {Option[]}
+       */
+      visibleGlobalOptions(cmd) {
+        if (!this.showGlobalOptions)
+          return [];
+        const globalOptions = [];
+        for (let parentCmd = cmd.parent; parentCmd; parentCmd = parentCmd.parent) {
+          const visibleOptions = parentCmd.options.filter((option2) => !option2.hidden);
+          globalOptions.push(...visibleOptions);
+        }
+        if (this.sortOptions) {
+          globalOptions.sort(this.compareOptions);
+        }
+        return globalOptions;
+      }
+      /**
+       * Get an array of the arguments if any have a description.
+       *
+       * @param {Command} cmd
+       * @returns {Argument[]}
+       */
+      visibleArguments(cmd) {
+        if (cmd._argsDescription) {
+          cmd._args.forEach((argument) => {
+            argument.description = argument.description || cmd._argsDescription[argument.name()] || "";
+          });
+        }
+        if (cmd._args.find((argument) => argument.description)) {
+          return cmd._args;
+        }
+        return [];
+      }
+      /**
+       * Get the command term to show in the list of subcommands.
+       *
+       * @param {Command} cmd
+       * @returns {string}
+       */
+      subcommandTerm(cmd) {
+        const args = cmd._args.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.
+       *
+       * @param {Option} option
+       * @returns {string}
+       */
+      optionTerm(option2) {
+        return option2.flags;
+      }
+      /**
+       * Get the argument term to show in the list of arguments.
+       *
+       * @param {Argument} argument
+       * @returns {string}
+       */
+      argumentTerm(argument) {
+        return argument.name();
+      }
+      /**
+       * Get the longest command term length.
+       *
+       * @param {Command} cmd
+       * @param {Help} helper
+       * @returns {number}
+       */
+      longestSubcommandTermLength(cmd, helper) {
+        return helper.visibleCommands(cmd).reduce((max, command) => {
+          return Math.max(max, helper.subcommandTerm(command).length);
+        }, 0);
+      }
+      /**
+       * Get the longest option term length.
+       *
+       * @param {Command} cmd
+       * @param {Help} helper
+       * @returns {number}
+       */
+      longestOptionTermLength(cmd, helper) {
+        return helper.visibleOptions(cmd).reduce((max, option2) => {
+          return Math.max(max, helper.optionTerm(option2).length);
+        }, 0);
+      }
+      /**
+       * Get the longest global option term length.
+       *
+       * @param {Command} cmd
+       * @param {Help} helper
+       * @returns {number}
+       */
+      longestGlobalOptionTermLength(cmd, helper) {
+        return helper.visibleGlobalOptions(cmd).reduce((max, option2) => {
+          return Math.max(max, helper.optionTerm(option2).length);
+        }, 0);
+      }
+      /**
+       * Get the longest argument term length.
+       *
+       * @param {Command} cmd
+       * @param {Help} helper
+       * @returns {number}
+       */
+      longestArgumentTermLength(cmd, helper) {
+        return helper.visibleArguments(cmd).reduce((max, argument) => {
+          return Math.max(max, helper.argumentTerm(argument).length);
+        }, 0);
+      }
+      /**
+       * Get the command usage to be displayed at the top of the built-in help.
+       *
+       * @param {Command} cmd
+       * @returns {string}
+       */
+      commandUsage(cmd) {
+        let cmdName = cmd._name;
+        if (cmd._aliases[0]) {
+          cmdName = cmdName + "|" + cmd._aliases[0];
+        }
+        let parentCmdNames = "";
+        for (let parentCmd = cmd.parent; parentCmd; parentCmd = parentCmd.parent) {
+          parentCmdNames = parentCmd.name() + " " + parentCmdNames;
+        }
+        return parentCmdNames + cmdName + " " + cmd.usage();
+      }
+      /**
+       * Get the description for the command.
+       *
+       * @param {Command} cmd
+       * @returns {string}
+       */
+      commandDescription(cmd) {
+        return cmd.description();
+      }
+      /**
+       * Get the subcommand summary to show in the list of subcommands.
+       * (Fallback to description for backwards compatibility.)
+       *
+       * @param {Command} cmd
+       * @returns {string}
+       */
+      subcommandDescription(cmd) {
+        return cmd.summary() || cmd.description();
+      }
+      /**
+       * Get the option description to show in the list of options.
+       *
+       * @param {Option} option
+       * @return {string}
+       */
+      optionDescription(option2) {
+        const extraInfo = [];
+        if (option2.argChoices) {
+          extraInfo.push(
+            // use stringify to match the display of the default value
+            `choices: ${option2.argChoices.map((choice) => JSON.stringify(choice)).join(", ")}`
+          );
+        }
+        if (option2.defaultValue !== void 0) {
+          const showDefault = option2.required || option2.optional || option2.isBoolean() && typeof option2.defaultValue === "boolean";
+          if (showDefault) {
+            extraInfo.push(`default: ${option2.defaultValueDescription || JSON.stringify(option2.defaultValue)}`);
+          }
+        }
+        if (option2.presetArg !== void 0 && option2.optional) {
+          extraInfo.push(`preset: ${JSON.stringify(option2.presetArg)}`);
+        }
+        if (option2.envVar !== void 0) {
+          extraInfo.push(`env: ${option2.envVar}`);
+        }
+        if (extraInfo.length > 0) {
+          return `${option2.description} (${extraInfo.join(", ")})`;
+        }
+        return option2.description;
+      }
+      /**
+       * Get the argument description to show in the list of arguments.
+       *
+       * @param {Argument} argument
+       * @return {string}
+       */
+      argumentDescription(argument) {
+        const extraInfo = [];
+        if (argument.argChoices) {
+          extraInfo.push(
+            // use stringify to match the display of the default value
+            `choices: ${argument.argChoices.map((choice) => JSON.stringify(choice)).join(", ")}`
+          );
+        }
+        if (argument.defaultValue !== void 0) {
+          extraInfo.push(`default: ${argument.defaultValueDescription || JSON.stringify(argument.defaultValue)}`);
+        }
+        if (extraInfo.length > 0) {
+          const extraDescripton = `(${extraInfo.join(", ")})`;
+          if (argument.description) {
+            return `${argument.description} ${extraDescripton}`;
+          }
+          return extraDescripton;
+        }
+        return argument.description;
+      }
+      /**
+       * Generate the built-in help text.
+       *
+       * @param {Command} cmd
+       * @param {Help} helper
+       * @returns {string}
+       */
+      formatHelp(cmd, helper) {
+        const termWidth = helper.padWidth(cmd, helper);
+        const helpWidth = helper.helpWidth || 80;
+        const itemIndentWidth = 2;
+        const itemSeparatorWidth = 2;
+        function formatItem(term, description) {
+          if (description) {
+            const fullText = `${term.padEnd(termWidth + itemSeparatorWidth)}${description}`;
+            return helper.wrap(fullText, helpWidth - itemIndentWidth, termWidth + itemSeparatorWidth);
+          }
+          return term;
+        }
+        function formatList(textArray) {
+          return textArray.join("\n").replace(/^/gm, " ".repeat(itemIndentWidth));
+        }
+        let output = [`Usage: ${helper.commandUsage(cmd)}`, ""];
+        const commandDescription = helper.commandDescription(cmd);
+        if (commandDescription.length > 0) {
+          output = output.concat([helper.wrap(commandDescription, helpWidth, 0), ""]);
+        }
+        const argumentList = helper.visibleArguments(cmd).map((argument) => {
+          return formatItem(helper.argumentTerm(argument), helper.argumentDescription(argument));
+        });
+        if (argumentList.length > 0) {
+          output = output.concat(["Arguments:", formatList(argumentList), ""]);
+        }
+        const optionList = helper.visibleOptions(cmd).map((option2) => {
+          return formatItem(helper.optionTerm(option2), helper.optionDescription(option2));
+        });
+        if (optionList.length > 0) {
+          output = output.concat(["Options:", formatList(optionList), ""]);
+        }
+        if (this.showGlobalOptions) {
+          const globalOptionList = helper.visibleGlobalOptions(cmd).map((option2) => {
+            return formatItem(helper.optionTerm(option2), helper.optionDescription(option2));
+          });
+          if (globalOptionList.length > 0) {
+            output = output.concat(["Global Options:", formatList(globalOptionList), ""]);
+          }
+        }
+        const commandList = helper.visibleCommands(cmd).map((cmd2) => {
+          return formatItem(helper.subcommandTerm(cmd2), helper.subcommandDescription(cmd2));
+        });
+        if (commandList.length > 0) {
+          output = output.concat(["Commands:", formatList(commandList), ""]);
+        }
+        return output.join("\n");
+      }
+      /**
+       * Calculate the pad width from the maximum term length.
+       *
+       * @param {Command} cmd
+       * @param {Help} helper
+       * @returns {number}
+       */
+      padWidth(cmd, helper) {
+        return Math.max(
+          helper.longestOptionTermLength(cmd, helper),
+          helper.longestGlobalOptionTermLength(cmd, helper),
+          helper.longestSubcommandTermLength(cmd, helper),
+          helper.longestArgumentTermLength(cmd, helper)
+        );
+      }
+      /**
+       * Wrap the given string to width characters per line, with lines after the first indented.
+       * Do not wrap if insufficient room for wrapping (minColumnWidth), or string is manually formatted.
+       *
+       * @param {string} str
+       * @param {number} width
+       * @param {number} indent
+       * @param {number} [minColumnWidth=40]
+       * @return {string}
+       *
+       */
+      wrap(str, width, indent, minColumnWidth = 40) {
+        const indents = " \\f\\t\\v\xA0\u1680\u2000-\u200A\u202F\u205F\u3000\uFEFF";
+        const manualIndent = new RegExp(`[\\n][${indents}]+`);
+        if (str.match(manualIndent))
+          return str;
+        const columnWidth = width - indent;
+        if (columnWidth < minColumnWidth)
+          return str;
+        const leadingStr = str.slice(0, indent);
+        const columnText = str.slice(indent).replace("\r\n", "\n");
+        const indentString = " ".repeat(indent);
+        const zeroWidthSpace = "\u200B";
+        const breaks = `\\s${zeroWidthSpace}`;
+        const regex = new RegExp(`
+|.{1,${columnWidth - 1}}([${breaks}]|$)|[^${breaks}]+?([${breaks}]|$)`, "g");
+        const lines = columnText.match(regex) || [];
+        return leadingStr + lines.map((line, i) => {
+          if (line === "\n")
+            return "";
+          return (i > 0 ? indentString : "") + line.trimEnd();
+        }).join("\n");
+      }
+    };
+    exports2.Help = Help2;
+  }
+});
+
+// node_modules/commander/lib/option.js
+var require_option = __commonJS({
+  "node_modules/commander/lib/option.js"(exports2) {
+    var { InvalidArgumentError: InvalidArgumentError2 } = require_error();
+    var Option3 = class {
+      /**
+       * Initialize a new `Option` with the given `flags` and `description`.
+       *
+       * @param {string} flags
+       * @param {string} [description]
+       */
+      constructor(flags, description) {
+        this.flags = flags;
+        this.description = description || "";
+        this.required = flags.includes("<");
+        this.optional = flags.includes("[");
+        this.variadic = /\w\.\.\.[>\]]$/.test(flags);
+        this.mandatory = false;
+        const optionFlags = splitOptionFlags(flags);
+        this.short = optionFlags.shortFlag;
+        this.long = optionFlags.longFlag;
+        this.negate = false;
+        if (this.long) {
+          this.negate = this.long.startsWith("--no-");
+        }
+        this.defaultValue = void 0;
+        this.defaultValueDescription = void 0;
+        this.presetArg = void 0;
+        this.envVar = void 0;
+        this.parseArg = void 0;
+        this.hidden = false;
+        this.argChoices = void 0;
+        this.conflictsWith = [];
+        this.implied = void 0;
+      }
+      /**
+       * Set the default value, and optionally supply the description to be displayed in the help.
+       *
+       * @param {any} value
+       * @param {string} [description]
+       * @return {Option}
+       */
+      default(value, description) {
+        this.defaultValue = value;
+        this.defaultValueDescription = description;
+        return this;
+      }
+      /**
+       * Preset to use when option used without option-argument, especially optional but also boolean and negated.
+       * The custom processing (parseArg) is called.
+       *
+       * @example
+       * new Option('--color').default('GREYSCALE').preset('RGB');
+       * new Option('--donate [amount]').preset('20').argParser(parseFloat);
+       *
+       * @param {any} arg
+       * @return {Option}
+       */
+      preset(arg) {
+        this.presetArg = arg;
+        return this;
+      }
+      /**
+       * Add option name(s) that conflict with this option.
+       * An error will be displayed if conflicting options are found during parsing.
+       *
+       * @example
+       * new Option('--rgb').conflicts('cmyk');
+       * new Option('--js').conflicts(['ts', 'jsx']);
+       *
+       * @param {string | string[]} names
+       * @return {Option}
+       */
+      conflicts(names) {
+        this.conflictsWith = this.conflictsWith.concat(names);
+        return this;
+      }
+      /**
+       * Specify implied option values for when this option is set and the implied options are not.
+       *
+       * The custom processing (parseArg) is not called on the implied values.
+       *
+       * @example
+       * program
+       *   .addOption(new Option('--log', 'write logging information to file'))
+       *   .addOption(new Option('--trace', 'log extra details').implies({ log: 'trace.txt' }));
+       *
+       * @param {Object} impliedOptionValues
+       * @return {Option}
+       */
+      implies(impliedOptionValues) {
+        let newImplied = impliedOptionValues;
+        if (typeof impliedOptionValues === "string") {
+          newImplied = { [impliedOptionValues]: true };
+        }
+        this.implied = Object.assign(this.implied || {}, newImplied);
+        return this;
+      }
+      /**
+       * Set environment variable to check for option value.
+       *
+       * An environment variable is only used if when processed the current option value is
+       * undefined, or the source of the current value is 'default' or 'config' or 'env'.
+       *
+       * @param {string} name
+       * @return {Option}
+       */
+      env(name) {
+        this.envVar = name;
+        return this;
+      }
+      /**
+       * Set the custom handler for processing CLI option arguments into option values.
+       *
+       * @param {Function} [fn]
+       * @return {Option}
+       */
+      argParser(fn) {
+        this.parseArg = fn;
+        return this;
+      }
+      /**
+       * Whether the option is mandatory and must have a value after parsing.
+       *
+       * @param {boolean} [mandatory=true]
+       * @return {Option}
+       */
+      makeOptionMandatory(mandatory = true) {
+        this.mandatory = !!mandatory;
+        return this;
+      }
+      /**
+       * Hide option in help.
+       *
+       * @param {boolean} [hide=true]
+       * @return {Option}
+       */
+      hideHelp(hide = true) {
+        this.hidden = !!hide;
+        return this;
+      }
+      /**
+       * @api private
+       */
+      _concatValue(value, previous) {
+        if (previous === this.defaultValue || !Array.isArray(previous)) {
+          return [value];
+        }
+        return previous.concat(value);
+      }
+      /**
+       * Only allow option value to be one of choices.
+       *
+       * @param {string[]} values
+       * @return {Option}
+       */
+      choices(values2) {
+        this.argChoices = values2.slice();
+        this.parseArg = (arg, previous) => {
+          if (!this.argChoices.includes(arg)) {
+            throw new InvalidArgumentError2(`Allowed choices are ${this.argChoices.join(", ")}.`);
+          }
+          if (this.variadic) {
+            return this._concatValue(arg, previous);
+          }
+          return arg;
+        };
+        return this;
+      }
+      /**
+       * Return option name.
+       *
+       * @return {string}
+       */
+      name() {
+        if (this.long) {
+          return this.long.replace(/^--/, "");
+        }
+        return this.short.replace(/^-/, "");
+      }
+      /**
+       * Return option name, in a camelcase format that can be used
+       * as a object attribute key.
+       *
+       * @return {string}
+       * @api private
+       */
+      attributeName() {
+        return camelcase(this.name().replace(/^no-/, ""));
+      }
+      /**
+       * Check if `arg` matches the short or long flag.
+       *
+       * @param {string} arg
+       * @return {boolean}
+       * @api private
+       */
+      is(arg) {
+        return this.short === arg || this.long === arg;
+      }
+      /**
+       * Return whether a boolean option.
+       *
+       * Options are one of boolean, negated, required argument, or optional argument.
+       *
+       * @return {boolean}
+       * @api private
+       */
+      isBoolean() {
+        return !this.required && !this.optional && !this.negate;
+      }
+    };
+    var DualOptions = class {
+      /**
+       * @param {Option[]} options
+       */
+      constructor(options) {
+        this.positiveOptions = /* @__PURE__ */ new Map();
+        this.negativeOptions = /* @__PURE__ */ new Map();
+        this.dualOptions = /* @__PURE__ */ new Set();
+        options.forEach((option2) => {
+          if (option2.negate) {
+            this.negativeOptions.set(option2.attributeName(), option2);
+          } else {
+            this.positiveOptions.set(option2.attributeName(), option2);
+          }
+        });
+        this.negativeOptions.forEach((value, key) => {
+          if (this.positiveOptions.has(key)) {
+            this.dualOptions.add(key);
+          }
+        });
+      }
+      /**
+       * Did the value come from the option, and not from possible matching dual option?
+       *
+       * @param {any} value
+       * @param {Option} option
+       * @returns {boolean}
+       */
+      valueFromOption(value, option2) {
+        const optionKey = option2.attributeName();
+        if (!this.dualOptions.has(optionKey))
+          return true;
+        const preset = this.negativeOptions.get(optionKey).presetArg;
+        const negativeValue = preset !== void 0 ? preset : false;
+        return option2.negate === (negativeValue === value);
+      }
+    };
+    function camelcase(str) {
+      return str.split("-").reduce((str2, word) => {
+        return str2 + word[0].toUpperCase() + word.slice(1);
+      });
+    }
+    function splitOptionFlags(flags) {
+      let shortFlag;
+      let longFlag;
+      const flagParts = flags.split(/[ |,]+/);
+      if (flagParts.length > 1 && !/^[[<]/.test(flagParts[1]))
+        shortFlag = flagParts.shift();
+      longFlag = flagParts.shift();
+      if (!shortFlag && /^-[^-]$/.test(longFlag)) {
+        shortFlag = longFlag;
+        longFlag = void 0;
+      }
+      return { shortFlag, longFlag };
+    }
+    exports2.Option = Option3;
+    exports2.splitOptionFlags = splitOptionFlags;
+    exports2.DualOptions = DualOptions;
+  }
+});
+
+// node_modules/commander/lib/suggestSimilar.js
+var require_suggestSimilar = __commonJS({
+  "node_modules/commander/lib/suggestSimilar.js"(exports2) {
+    var maxDistance = 3;
+    function editDistance(a2, b) {
+      if (Math.abs(a2.length - b.length) > maxDistance)
+        return Math.max(a2.length, b.length);
+      const d = [];
+      for (let i = 0; i <= a2.length; i++) {
+        d[i] = [i];
+      }
+      for (let j = 0; j <= b.length; j++) {
+        d[0][j] = j;
+      }
+      for (let j = 1; j <= b.length; j++) {
+        for (let i = 1; i <= a2.length; i++) {
+          let cost = 1;
+          if (a2[i - 1] === b[j - 1]) {
+            cost = 0;
+          } else {
+            cost = 1;
+          }
+          d[i][j] = Math.min(
+            d[i - 1][j] + 1,
+            // deletion
+            d[i][j - 1] + 1,
+            // insertion
+            d[i - 1][j - 1] + cost
+            // substitution
+          );
+          if (i > 1 && j > 1 && a2[i - 1] === b[j - 2] && a2[i - 2] === b[j - 1]) {
+            d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
+          }
+        }
+      }
+      return d[a2.length][b.length];
+    }
+    function suggestSimilar(word, candidates) {
+      if (!candidates || candidates.length === 0)
+        return "";
+      candidates = Array.from(new Set(candidates));
+      const searchingOptions = word.startsWith("--");
+      if (searchingOptions) {
+        word = word.slice(2);
+        candidates = candidates.map((candidate) => candidate.slice(2));
+      }
+      let similar = [];
+      let bestDistance = maxDistance;
+      const minSimilarity = 0.4;
+      candidates.forEach((candidate) => {
+        if (candidate.length <= 1)
+          return;
+        const distance = editDistance(word, candidate);
+        const length = Math.max(word.length, candidate.length);
+        const similarity = (length - distance) / length;
+        if (similarity > minSimilarity) {
+          if (distance < bestDistance) {
+            bestDistance = distance;
+            similar = [candidate];
+          } else if (distance === bestDistance) {
+            similar.push(candidate);
+          }
+        }
+      });
+      similar.sort((a2, b) => a2.localeCompare(b));
+      if (searchingOptions) {
+        similar = similar.map((candidate) => `--${candidate}`);
+      }
+      if (similar.length > 1) {
+        return `
+(Did you mean one of ${similar.join(", ")}?)`;
+      }
+      if (similar.length === 1) {
+        return `
+(Did you mean ${similar[0]}?)`;
+      }
+      return "";
+    }
+    exports2.suggestSimilar = suggestSimilar;
+  }
+});
+
+// node_modules/commander/lib/command.js
+var require_command = __commonJS({
+  "node_modules/commander/lib/command.js"(exports2) {
+    var EventEmitter = require("events").EventEmitter;
+    var childProcess = require("child_process");
+    var path4 = require("path");
+    var fs5 = require("fs");
+    var process3 = require("process");
+    var { Argument: Argument2, humanReadableArgName } = require_argument();
+    var { CommanderError: CommanderError2 } = require_error();
+    var { Help: Help2 } = require_help();
+    var { Option: Option3, splitOptionFlags, DualOptions } = require_option();
+    var { suggestSimilar } = require_suggestSimilar();
+    var Command3 = class _Command extends EventEmitter {
+      /**
+       * Initialize a new `Command`.
+       *
+       * @param {string} [name]
+       */
+      constructor(name) {
+        super();
+        this.commands = [];
+        this.options = [];
+        this.parent = null;
+        this._allowUnknownOption = false;
+        this._allowExcessArguments = true;
+        this._args = [];
+        this.args = [];
+        this.rawArgs = [];
+        this.processedArgs = [];
+        this._scriptPath = null;
+        this._name = name || "";
+        this._optionValues = {};
+        this._optionValueSources = {};
+        this._storeOptionsAsProperties = false;
+        this._actionHandler = null;
+        this._executableHandler = false;
+        this._executableFile = null;
+        this._executableDir = null;
+        this._defaultCommandName = null;
+        this._exitCallback = null;
+        this._aliases = [];
+        this._combineFlagAndOptionalValue = true;
+        this._description = "";
+        this._summary = "";
+        this._argsDescription = void 0;
+        this._enablePositionalOptions = false;
+        this._passThroughOptions = false;
+        this._lifeCycleHooks = {};
+        this._showHelpAfterError = false;
+        this._showSuggestionAfterError = true;
+        this._outputConfiguration = {
+          writeOut: (str) => process3.stdout.write(str),
+          writeErr: (str) => process3.stderr.write(str),
+          getOutHelpWidth: () => process3.stdout.isTTY ? process3.stdout.columns : void 0,
+          getErrHelpWidth: () => process3.stderr.isTTY ? process3.stderr.columns : void 0,
+          outputError: (str, write) => write(str)
+        };
+        this._hidden = false;
+        this._hasHelpOption = true;
+        this._helpFlags = "-h, --help";
+        this._helpDescription = "display help for command";
+        this._helpShortFlag = "-h";
+        this._helpLongFlag = "--help";
+        this._addImplicitHelpCommand = void 0;
+        this._helpCommandName = "help";
+        this._helpCommandnameAndArgs = "help [command]";
+        this._helpCommandDescription = "display help for command";
+        this._helpConfiguration = {};
+      }
+      /**
+       * Copy settings that are useful to have in common across root command and subcommands.
+       *
+       * (Used internally when adding a command using `.command()` so subcommands inherit parent settings.)
+       *
+       * @param {Command} sourceCommand
+       * @return {Command} `this` command for chaining
+       */
+      copyInheritedSettings(sourceCommand) {
+        this._outputConfiguration = sourceCommand._outputConfiguration;
+        this._hasHelpOption = sourceCommand._hasHelpOption;
+        this._helpFlags = sourceCommand._helpFlags;
+        this._helpDescription = sourceCommand._helpDescription;
+        this._helpShortFlag = sourceCommand._helpShortFlag;
+        this._helpLongFlag = sourceCommand._helpLongFlag;
+        this._helpCommandName = sourceCommand._helpCommandName;
+        this._helpCommandnameAndArgs = sourceCommand._helpCommandnameAndArgs;
+        this._helpCommandDescription = sourceCommand._helpCommandDescription;
+        this._helpConfiguration = sourceCommand._helpConfiguration;
+        this._exitCallback = sourceCommand._exitCallback;
+        this._storeOptionsAsProperties = sourceCommand._storeOptionsAsProperties;
+        this._combineFlagAndOptionalValue = sourceCommand._combineFlagAndOptionalValue;
+        this._allowExcessArguments = sourceCommand._allowExcessArguments;
+        this._enablePositionalOptions = sourceCommand._enablePositionalOptions;
+        this._showHelpAfterError = sourceCommand._showHelpAfterError;
+        this._showSuggestionAfterError = sourceCommand._showSuggestionAfterError;
+        return this;
+      }
+      /**
+       * Define a command.
+       *
+       * There are two styles of command: pay attention to where to put the description.
+       *
+       * @example
+       * // Command implemented using action handler (description is supplied separately to `.command`)
+       * program
+       *   .command('clone <source> [destination]')
+       *   .description('clone a repository into a newly created directory')
+       *   .action((source, destination) => {
+       *     console.log('clone command called');
+       *   });
+       *
+       * // Command implemented using separate executable file (description is second parameter to `.command`)
+       * program
+       *   .command('start <service>', 'start named service')
+       *   .command('stop [service]', 'stop named service, or all if no name supplied');
+       *
+       * @param {string} nameAndArgs - command name and arguments, args are `<required>` or `[optional]` and last may also be `variadic...`
+       * @param {Object|string} [actionOptsOrExecDesc] - configuration options (for action), or description (for executable)
+       * @param {Object} [execOpts] - configuration options (for executable)
+       * @return {Command} returns new command for action handler, or `this` for executable command
+       */
+      command(nameAndArgs, actionOptsOrExecDesc, execOpts) {
+        let desc = actionOptsOrExecDesc;
+        let opts = execOpts;
+        if (typeof desc === "object" && desc !== null) {
+          opts = desc;
+          desc = null;
+        }
+        opts = opts || {};
+        const [, name, args] = nameAndArgs.match(/([^ ]+) *(.*)/);
+        const cmd = this.createCommand(name);
+        if (desc) {
+          cmd.description(desc);
+          cmd._executableHandler = true;
+        }
+        if (opts.isDefault)
+          this._defaultCommandName = cmd._name;
+        cmd._hidden = !!(opts.noHelp || opts.hidden);
+        cmd._executableFile = opts.executableFile || null;
+        if (args)
+          cmd.arguments(args);
+        this.commands.push(cmd);
+        cmd.parent = this;
+        cmd.copyInheritedSettings(this);
+        if (desc)
+          return this;
+        return cmd;
+      }
+      /**
+       * Factory routine to create a new unattached command.
+       *
+       * See .command() for creating an attached subcommand, which uses this routine to
+       * create the command. You can override createCommand to customise subcommands.
+       *
+       * @param {string} [name]
+       * @return {Command} new command
+       */
+      createCommand(name) {
+        return new _Command(name);
+      }
+      /**
+       * You can customise the help with a subclass of Help by overriding createHelp,
+       * or by overriding Help properties using configureHelp().
+       *
+       * @return {Help}
+       */
+      createHelp() {
+        return Object.assign(new Help2(), this.configureHelp());
+      }
+      /**
+       * You can customise the help by overriding Help properties using configureHelp(),
+       * or with a subclass of Help by overriding createHelp().
+       *
+       * @param {Object} [configuration] - configuration options
+       * @return {Command|Object} `this` command for chaining, or stored configuration
+       */
+      configureHelp(configuration) {
+        if (configuration === void 0)
+          return this._helpConfiguration;
+        this._helpConfiguration = configuration;
+        return this;
+      }
+      /**
+       * The default output goes to stdout and stderr. You can customise this for special
+       * applications. You can also customise the display of errors by overriding outputError.
+       *
+       * The configuration properties are all functions:
+       *
+       *     // functions to change where being written, stdout and stderr
+       *     writeOut(str)
+       *     writeErr(str)
+       *     // matching functions to specify width for wrapping help
+       *     getOutHelpWidth()
+       *     getErrHelpWidth()
+       *     // functions based on what is being written out
+       *     outputError(str, write) // used for displaying errors, and not used for displaying help
+       *
+       * @param {Object} [configuration] - configuration options
+       * @return {Command|Object} `this` command for chaining, or stored configuration
+       */
+      configureOutput(configuration) {
+        if (configuration === void 0)
+          return this._outputConfiguration;
+        Object.assign(this._outputConfiguration, configuration);
+        return this;
+      }
+      /**
+       * Display the help or a custom message after an error occurs.
+       *
+       * @param {boolean|string} [displayHelp]
+       * @return {Command} `this` command for chaining
+       */
+      showHelpAfterError(displayHelp = true) {
+        if (typeof displayHelp !== "string")
+          displayHelp = !!displayHelp;
+        this._showHelpAfterError = displayHelp;
+        return this;
+      }
+      /**
+       * Display suggestion of similar commands for unknown commands, or options for unknown options.
+       *
+       * @param {boolean} [displaySuggestion]
+       * @return {Command} `this` command for chaining
+       */
+      showSuggestionAfterError(displaySuggestion = true) {
+        this._showSuggestionAfterError = !!displaySuggestion;
+        return this;
+      }
+      /**
+       * Add a prepared subcommand.
+       *
+       * See .command() for creating an attached subcommand which inherits settings from its parent.
+       *
+       * @param {Command} cmd - new subcommand
+       * @param {Object} [opts] - configuration options
+       * @return {Command} `this` command for chaining
+       */
+      addCommand(cmd, opts) {
+        if (!cmd._name) {
+          throw new Error(`Command passed to .addCommand() must have a name
+- specify the name in Command constructor or using .name()`);
+        }
+        opts = opts || {};
+        if (opts.isDefault)
+          this._defaultCommandName = cmd._name;
+        if (opts.noHelp || opts.hidden)
+          cmd._hidden = true;
+        this.commands.push(cmd);
+        cmd.parent = this;
+        return this;
+      }
+      /**
+       * Factory routine to create a new unattached argument.
+       *
+       * See .argument() for creating an attached argument, which uses this routine to
+       * create the argument. You can override createArgument to return a custom argument.
+       *
+       * @param {string} name
+       * @param {string} [description]
+       * @return {Argument} new argument
+       */
+      createArgument(name, description) {
+        return new Argument2(name, description);
+      }
+      /**
+       * Define argument syntax for command.
+       *
+       * The default is that the argument is required, and you can explicitly
+       * indicate this with <> around the name. Put [] around the name for an optional argument.
+       *
+       * @example
+       * program.argument('<input-file>');
+       * program.argument('[output-file]');
+       *
+       * @param {string} name
+       * @param {string} [description]
+       * @param {Function|*} [fn] - custom argument processing function
+       * @param {*} [defaultValue]
+       * @return {Command} `this` command for chaining
+       */
+      argument(name, description, fn, defaultValue) {
+        const argument = this.createArgument(name, description);
+        if (typeof fn === "function") {
+          argument.default(defaultValue).argParser(fn);
+        } else {
+          argument.default(fn);
+        }
+        this.addArgument(argument);
+        return this;
+      }
+      /**
+       * Define argument syntax for command, adding multiple at once (without descriptions).
+       *
+       * See also .argument().
+       *
+       * @example
+       * program.arguments('<cmd> [env]');
+       *
+       * @param {string} names
+       * @return {Command} `this` command for chaining
+       */
+      arguments(names) {
+        names.trim().split(/ +/).forEach((detail) => {
+          this.argument(detail);
+        });
+        return this;
+      }
+      /**
+       * Define argument syntax for command, adding a prepared argument.
+       *
+       * @param {Argument} argument
+       * @return {Command} `this` command for chaining
+       */
+      addArgument(argument) {
+        const previousArgument = this._args.slice(-1)[0];
+        if (previousArgument && previousArgument.variadic) {
+          throw new Error(`only the last argument can be variadic '${previousArgument.name()}'`);
+        }
+        if (argument.required && argument.defaultValue !== void 0 && argument.parseArg === void 0) {
+          throw new Error(`a default value for a required argument is never used: '${argument.name()}'`);
+        }
+        this._args.push(argument);
+        return this;
+      }
+      /**
+       * Override default decision whether to add implicit help command.
+       *
+       *    addHelpCommand() // force on
+       *    addHelpCommand(false); // force off
+       *    addHelpCommand('help [cmd]', 'display help for [cmd]'); // force on with custom details
+       *
+       * @return {Command} `this` command for chaining
+       */
+      addHelpCommand(enableOrNameAndArgs, description) {
+        if (enableOrNameAndArgs === false) {
+          this._addImplicitHelpCommand = false;
+        } else {
+          this._addImplicitHelpCommand = true;
+          if (typeof enableOrNameAndArgs === "string") {
+            this._helpCommandName = enableOrNameAndArgs.split(" ")[0];
+            this._helpCommandnameAndArgs = enableOrNameAndArgs;
+          }
+          this._helpCommandDescription = description || this._helpCommandDescription;
+        }
+        return this;
+      }
+      /**
+       * @return {boolean}
+       * @api private
+       */
+      _hasImplicitHelpCommand() {
+        if (this._addImplicitHelpCommand === void 0) {
+          return this.commands.length && !this._actionHandler && !this._findCommand("help");
+        }
+        return this._addImplicitHelpCommand;
+      }
+      /**
+       * Add hook for life cycle event.
+       *
+       * @param {string} event
+       * @param {Function} listener
+       * @return {Command} `this` command for chaining
+       */
+      hook(event, listener) {
+        const allowedValues = ["preSubcommand", "preAction", "postAction"];
+        if (!allowedValues.includes(event)) {
+          throw new Error(`Unexpected value for event passed to hook : '${event}'.
+Expecting one of '${allowedValues.join("', '")}'`);
+        }
+        if (this._lifeCycleHooks[event]) {
+          this._lifeCycleHooks[event].push(listener);
+        } else {
+          this._lifeCycleHooks[event] = [listener];
+        }
+        return this;
+      }
+      /**
+       * Register callback to use as replacement for calling process.exit.
+       *
+       * @param {Function} [fn] optional callback which will be passed a CommanderError, defaults to throwing
+       * @return {Command} `this` command for chaining
+       */
+      exitOverride(fn) {
+        if (fn) {
+          this._exitCallback = fn;
+        } else {
+          this._exitCallback = (err) => {
+            if (err.code !== "commander.executeSubCommandAsync") {
+              throw err;
+            } else {
+            }
+          };
+        }
+        return this;
+      }
+      /**
+       * Call process.exit, and _exitCallback if defined.
+       *
+       * @param {number} exitCode exit code for using with process.exit
+       * @param {string} code an id string representing the error
+       * @param {string} message human-readable description of the error
+       * @return never
+       * @api private
+       */
+      _exit(exitCode, code, message) {
+        if (this._exitCallback) {
+          this._exitCallback(new CommanderError2(exitCode, code, message));
+        }
+        process3.exit(exitCode);
+      }
+      /**
+       * Register callback `fn` for the command.
+       *
+       * @example
+       * program
+       *   .command('serve')
+       *   .description('start service')
+       *   .action(function() {
+       *      // do work here
+       *   });
+       *
+       * @param {Function} fn
+       * @return {Command} `this` command for chaining
+       */
+      action(fn) {
+        const listener = (args) => {
+          const expectedArgsCount = this._args.length;
+          const actionArgs = args.slice(0, expectedArgsCount);
+          if (this._storeOptionsAsProperties) {
+            actionArgs[expectedArgsCount] = this;
+          } else {
+            actionArgs[expectedArgsCount] = this.opts();
+          }
+          actionArgs.push(this);
+          return fn.apply(this, actionArgs);
+        };
+        this._actionHandler = listener;
+        return this;
+      }
+      /**
+       * Factory routine to create a new unattached option.
+       *
+       * See .option() for creating an attached option, which uses this routine to
+       * create the option. You can override createOption to return a custom option.
+       *
+       * @param {string} flags
+       * @param {string} [description]
+       * @return {Option} new option
+       */
+      createOption(flags, description) {
+        return new Option3(flags, description);
+      }
+      /**
+       * Add an option.
+       *
+       * @param {Option} option
+       * @return {Command} `this` command for chaining
+       */
+      addOption(option2) {
+        const oname = option2.name();
+        const name = option2.attributeName();
+        if (option2.negate) {
+          const positiveLongFlag = option2.long.replace(/^--no-/, "--");
+          if (!this._findOption(positiveLongFlag)) {
+            this.setOptionValueWithSource(name, option2.defaultValue === void 0 ? true : option2.defaultValue, "default");
+          }
+        } else if (option2.defaultValue !== void 0) {
+          this.setOptionValueWithSource(name, option2.defaultValue, "default");
+        }
+        this.options.push(option2);
+        const handleOptionValue = (val, invalidValueMessage, valueSource) => {
+          if (val == null && option2.presetArg !== void 0) {
+            val = option2.presetArg;
+          }
+          const oldValue = this.getOptionValue(name);
+          if (val !== null && option2.parseArg) {
+            try {
+              val = option2.parseArg(val, oldValue);
+            } catch (err) {
+              if (err.code === "commander.invalidArgument") {
+                const message = `${invalidValueMessage} ${err.message}`;
+                this.error(message, { exitCode: err.exitCode, code: err.code });
+              }
+              throw err;
+            }
+          } else if (val !== null && option2.variadic) {
+            val = option2._concatValue(val, oldValue);
+          }
+          if (val == null) {
+            if (option2.negate) {
+              val = false;
+            } else if (option2.isBoolean() || option2.optional) {
+              val = true;
+            } else {
+              val = "";
+            }
+          }
+          this.setOptionValueWithSource(name, val, valueSource);
+        };
+        this.on("option:" + oname, (val) => {
+          const invalidValueMessage = `error: option '${option2.flags}' argument '${val}' is invalid.`;
+          handleOptionValue(val, invalidValueMessage, "cli");
+        });
+        if (option2.envVar) {
+          this.on("optionEnv:" + oname, (val) => {
+            const invalidValueMessage = `error: option '${option2.flags}' value '${val}' from env '${option2.envVar}' is invalid.`;
+            handleOptionValue(val, invalidValueMessage, "env");
+          });
+        }
+        return this;
+      }
+      /**
+       * Internal implementation shared by .option() and .requiredOption()
+       *
+       * @api private
+       */
+      _optionEx(config, flags, description, fn, defaultValue) {
+        if (typeof flags === "object" && flags instanceof Option3) {
+          throw new Error("To add an Option object use addOption() instead of option() or requiredOption()");
+        }
+        const option2 = this.createOption(flags, description);
+        option2.makeOptionMandatory(!!config.mandatory);
+        if (typeof fn === "function") {
+          option2.default(defaultValue).argParser(fn);
+        } else if (fn instanceof RegExp) {
+          const regex = fn;
+          fn = (val, def) => {
+            const m = regex.exec(val);
+            return m ? m[0] : def;
+          };
+          option2.default(defaultValue).argParser(fn);
+        } else {
+          option2.default(fn);
+        }
+        return this.addOption(option2);
+      }
+      /**
+       * Define option with `flags`, `description` and optional
+       * coercion `fn`.
+       *
+       * The `flags` string contains the short and/or long flags,
+       * separated by comma, a pipe or space. The following are all valid
+       * all will output this way when `--help` is used.
+       *
+       *     "-p, --pepper"
+       *     "-p|--pepper"
+       *     "-p --pepper"
+       *
+       * @example
+       * // simple boolean defaulting to undefined
+       * program.option('-p, --pepper', 'add pepper');
+       *
+       * program.pepper
+       * // => undefined
+       *
+       * --pepper
+       * program.pepper
+       * // => true
+       *
+       * // simple boolean defaulting to true (unless non-negated option is also defined)
+       * program.option('-C, --no-cheese', 'remove cheese');
+       *
+       * program.cheese
+       * // => true
+       *
+       * --no-cheese
+       * program.cheese
+       * // => false
+       *
+       * // required argument
+       * program.option('-C, --chdir <path>', 'change the working directory');
+       *
+       * --chdir /tmp
+       * program.chdir
+       * // => "/tmp"
+       *
+       * // optional argument
+       * program.option('-c, --cheese [type]', 'add cheese [marble]');
+       *
+       * @param {string} flags
+       * @param {string} [description]
+       * @param {Function|*} [fn] - custom option processing function or default value
+       * @param {*} [defaultValue]
+       * @return {Command} `this` command for chaining
+       */
+      option(flags, description, fn, defaultValue) {
+        return this._optionEx({}, flags, description, fn, defaultValue);
+      }
+      /**
+      * Add a required option which must have a value after parsing. This usually means
+      * the option must be specified on the command line. (Otherwise the same as .option().)
+      *
+      * The `flags` string contains the short and/or long flags, separated by comma, a pipe or space.
+      *
+      * @param {string} flags
+      * @param {string} [description]
+      * @param {Function|*} [fn] - custom option processing function or default value
+      * @param {*} [defaultValue]
+      * @return {Command} `this` command for chaining
+      */
+      requiredOption(flags, description, fn, defaultValue) {
+        return this._optionEx({ mandatory: true }, flags, description, fn, defaultValue);
+      }
+      /**
+       * Alter parsing of short flags with optional values.
+       *
+       * @example
+       * // for `.option('-f,--flag [value]'):
+       * program.combineFlagAndOptionalValue(true);  // `-f80` is treated like `--flag=80`, this is the default behaviour
+       * program.combineFlagAndOptionalValue(false) // `-fb` is treated like `-f -b`
+       *
+       * @param {Boolean} [combine=true] - if `true` or omitted, an optional value can be specified directly after the flag.
+       */
+      combineFlagAndOptionalValue(combine = true) {
+        this._combineFlagAndOptionalValue = !!combine;
+        return this;
+      }
+      /**
+       * Allow unknown options on the command line.
+       *
+       * @param {Boolean} [allowUnknown=true] - if `true` or omitted, no error will be thrown
+       * for unknown options.
+       */
+      allowUnknownOption(allowUnknown = true) {
+        this._allowUnknownOption = !!allowUnknown;
+        return this;
+      }
+      /**
+       * Allow excess command-arguments on the command line. Pass false to make excess arguments an error.
+       *
+       * @param {Boolean} [allowExcess=true] - if `true` or omitted, no error will be thrown
+       * for excess arguments.
+       */
+      allowExcessArguments(allowExcess = true) {
+        this._allowExcessArguments = !!allowExcess;
+        return this;
+      }
+      /**
+       * Enable positional options. Positional means global options are specified before subcommands which lets
+       * subcommands reuse the same option names, and also enables subcommands to turn on passThroughOptions.
+       * The default behaviour is non-positional and global options may appear anywhere on the command line.
+       *
+       * @param {Boolean} [positional=true]
+       */
+      enablePositionalOptions(positional = true) {
+        this._enablePositionalOptions = !!positional;
+        return this;
+      }
+      /**
+       * Pass through options that come after command-arguments rather than treat them as command-options,
+       * so actual command-options come before command-arguments. Turning this on for a subcommand requires
+       * positional options to have been enabled on the program (parent commands).
+       * The default behaviour is non-positional and options may appear before or after command-arguments.
+       *
+       * @param {Boolean} [passThrough=true]
+       * for unknown options.
+       */
+      passThroughOptions(passThrough = true) {
+        this._passThroughOptions = !!passThrough;
+        if (!!this.parent && passThrough && !this.parent._enablePositionalOptions) {
+          throw new Error("passThroughOptions can not be used without turning on enablePositionalOptions for parent command(s)");
+        }
+        return this;
+      }
+      /**
+        * Whether to store option values as properties on command object,
+        * or store separately (specify false). In both cases the option values can be accessed using .opts().
+        *
+        * @param {boolean} [storeAsProperties=true]
+        * @return {Command} `this` command for chaining
+        */
+      storeOptionsAsProperties(storeAsProperties = true) {
+        this._storeOptionsAsProperties = !!storeAsProperties;
+        if (this.options.length) {
+          throw new Error("call .storeOptionsAsProperties() before adding options");
+        }
+        return this;
+      }
+      /**
+       * Retrieve option value.
+       *
+       * @param {string} key
+       * @return {Object} value
+       */
+      getOptionValue(key) {
+        if (this._storeOptionsAsProperties) {
+          return this[key];
+        }
+        return this._optionValues[key];
+      }
+      /**
+       * Store option value.
+       *
+       * @param {string} key
+       * @param {Object} value
+       * @return {Command} `this` command for chaining
+       */
+      setOptionValue(key, value) {
+        return this.setOptionValueWithSource(key, value, void 0);
+      }
+      /**
+        * Store option value and where the value came from.
+        *
+        * @param {string} key
+        * @param {Object} value
+        * @param {string} source - expected values are default/config/env/cli/implied
+        * @return {Command} `this` command for chaining
+        */
+      setOptionValueWithSource(key, value, source) {
+        if (this._storeOptionsAsProperties) {
+          this[key] = value;
+        } else {
+          this._optionValues[key] = value;
+        }
+        this._optionValueSources[key] = source;
+        return this;
+      }
+      /**
+        * Get source of option value.
+        * Expected values are default | config | env | cli | implied
+        *
+        * @param {string} key
+        * @return {string}
+        */
+      getOptionValueSource(key) {
+        return this._optionValueSources[key];
+      }
+      /**
+        * Get source of option value. See also .optsWithGlobals().
+        * Expected values are default | config | env | cli | implied
+        *
+        * @param {string} key
+        * @return {string}
+        */
+      getOptionValueSourceWithGlobals(key) {
+        let source;
+        getCommandAndParents(this).forEach((cmd) => {
+          if (cmd.getOptionValueSource(key) !== void 0) {
+            source = cmd.getOptionValueSource(key);
+          }
+        });
+        return source;
+      }
+      /**
+       * Get user arguments from implied or explicit arguments.
+       * Side-effects: set _scriptPath if args included script. Used for default program name, and subcommand searches.
+       *
+       * @api private
+       */
+      _prepareUserArgs(argv, parseOptions) {
+        if (argv !== void 0 && !Array.isArray(argv)) {
+          throw new Error("first parameter to parse must be array or undefined");
+        }
+        parseOptions = parseOptions || {};
+        if (argv === void 0) {
+          argv = process3.argv;
+          if (process3.versions && process3.versions.electron) {
+            parseOptions.from = "electron";
+          }
+        }
+        this.rawArgs = argv.slice();
+        let userArgs;
+        switch (parseOptions.from) {
+          case void 0:
+          case "node":
+            this._scriptPath = argv[1];
+            userArgs = argv.slice(2);
+            break;
+          case "electron":
+            if (process3.defaultApp) {
+              this._scriptPath = argv[1];
+              userArgs = argv.slice(2);
+            } else {
+              userArgs = argv.slice(1);
+            }
+            break;
+          case "user":
+            userArgs = argv.slice(0);
+            break;
+          default:
+            throw new Error(`unexpected parse option { from: '${parseOptions.from}' }`);
+        }
+        if (!this._name && this._scriptPath)
+          this.nameFromFilename(this._scriptPath);
+        this._name = this._name || "program";
+        return userArgs;
+      }
+      /**
+       * Parse `argv`, setting options and invoking commands when defined.
+       *
+       * The default expectation is that the arguments are from node and have the application as argv[0]
+       * and the script being run in argv[1], with user parameters after that.
+       *
+       * @example
+       * program.parse(process.argv);
+       * program.parse(); // implicitly use process.argv and auto-detect node vs electron conventions
+       * program.parse(my-args, { from: 'user' }); // just user supplied arguments, nothing special about argv[0]
+       *
+       * @param {string[]} [argv] - optional, defaults to process.argv
+       * @param {Object} [parseOptions] - optionally specify style of options with from: node/user/electron
+       * @param {string} [parseOptions.from] - where the args are from: 'node', 'user', 'electron'
+       * @return {Command} `this` command for chaining
+       */
+      parse(argv, parseOptions) {
+        const userArgs = this._prepareUserArgs(argv, parseOptions);
+        this._parseCommand([], userArgs);
+        return this;
+      }
+      /**
+       * Parse `argv`, setting options and invoking commands when defined.
+       *
+       * Use parseAsync instead of parse if any of your action handlers are async. Returns a Promise.
+       *
+       * The default expectation is that the arguments are from node and have the application as argv[0]
+       * and the script being run in argv[1], with user parameters after that.
+       *
+       * @example
+       * await program.parseAsync(process.argv);
+       * await program.parseAsync(); // implicitly use process.argv and auto-detect node vs electron conventions
+       * await program.parseAsync(my-args, { from: 'user' }); // just user supplied arguments, nothing special about argv[0]
+       *
+       * @param {string[]} [argv]
+       * @param {Object} [parseOptions]
+       * @param {string} parseOptions.from - where the args are from: 'node', 'user', 'electron'
+       * @return {Promise}
+       */
+      async parseAsync(argv, parseOptions) {
+        const userArgs = this._prepareUserArgs(argv, parseOptions);
+        await this._parseCommand([], userArgs);
+        return this;
+      }
+      /**
+       * Execute a sub-command executable.
+       *
+       * @api private
+       */
+      _executeSubCommand(subcommand, args) {
+        args = args.slice();
+        let launchWithNode = false;
+        const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
+        function findFile(baseDir, baseName) {
+          const localBin = path4.resolve(baseDir, baseName);
+          if (fs5.existsSync(localBin))
+            return localBin;
+          if (sourceExt.includes(path4.extname(baseName)))
+            return void 0;
+          const foundExt = sourceExt.find((ext) => fs5.existsSync(`${localBin}${ext}`));
+          if (foundExt)
+            return `${localBin}${foundExt}`;
+          return void 0;
+        }
+        this._checkForMissingMandatoryOptions();
+        this._checkForConflictingOptions();
+        let executableFile = subcommand._executableFile || `${this._name}-${subcommand._name}`;
+        let executableDir = this._executableDir || "";
+        if (this._scriptPath) {
+          let resolvedScriptPath;
+          try {
+            resolvedScriptPath = fs5.realpathSync(this._scriptPath);
+          } catch (err) {
+            resolvedScriptPath = this._scriptPath;
+          }
+          executableDir = path4.resolve(path4.dirname(resolvedScriptPath), executableDir);
+        }
+        if (executableDir) {
+          let localFile = findFile(executableDir, executableFile);
+          if (!localFile && !subcommand._executableFile && this._scriptPath) {
+            const legacyName = path4.basename(this._scriptPath, path4.extname(this._scriptPath));
+            if (legacyName !== this._name) {
+              localFile = findFile(executableDir, `${legacyName}-${subcommand._name}`);
+            }
+          }
+          executableFile = localFile || executableFile;
+        }
+        launchWithNode = sourceExt.includes(path4.extname(executableFile));
+        let proc;
+        if (process3.platform !== "win32") {
+          if (launchWithNode) {
+            args.unshift(executableFile);
+            args = incrementNodeInspectorPort(process3.execArgv).concat(args);
+            proc = childProcess.spawn(process3.argv[0], args, { stdio: "inherit" });
+          } else {
+            proc = childProcess.spawn(executableFile, args, { stdio: "inherit" });
+          }
+        } else {
+          args.unshift(executableFile);
+          args = incrementNodeInspectorPort(process3.execArgv).concat(args);
+          proc = childProcess.spawn(process3.execPath, args, { stdio: "inherit" });
+        }
+        if (!proc.killed) {
+          const signals = ["SIGUSR1", "SIGUSR2", "SIGTERM", "SIGINT", "SIGHUP"];
+          signals.forEach((signal) => {
+            process3.on(signal, () => {
+              if (proc.killed === false && proc.exitCode === null) {
+                proc.kill(signal);
+              }
+            });
+          });
+        }
+        const exitCallback = this._exitCallback;
+        if (!exitCallback) {
+          proc.on("close", process3.exit.bind(process3));
+        } else {
+          proc.on("close", () => {
+            exitCallback(new CommanderError2(process3.exitCode || 0, "commander.executeSubCommandAsync", "(close)"));
+          });
+        }
+        proc.on("error", (err) => {
+          if (err.code === "ENOENT") {
+            const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
+            const executableMissing = `'${executableFile}' does not exist
+ - if '${subcommand._name}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
+ - if the default executable name is not suitable, use the executableFile option to supply a custom name or path
+ - ${executableDirMessage}`;
+            throw new Error(executableMissing);
+          } else if (err.code === "EACCES") {
+            throw new Error(`'${executableFile}' not executable`);
+          }
+          if (!exitCallback) {
+            process3.exit(1);
+          } else {
+            const wrappedError = new CommanderError2(1, "commander.executeSubCommandAsync", "(error)");
+            wrappedError.nestedError = err;
+            exitCallback(wrappedError);
+          }
+        });
+        this.runningCommand = proc;
+      }
+      /**
+       * @api private
+       */
+      _dispatchSubcommand(commandName, operands, unknown) {
+        const subCommand = this._findCommand(commandName);
+        if (!subCommand)
+          this.help({ error: true });
+        let hookResult;
+        hookResult = this._chainOrCallSubCommandHook(hookResult, subCommand, "preSubcommand");
+        hookResult = this._chainOrCall(hookResult, () => {
+          if (subCommand._executableHandler) {
+            this._executeSubCommand(subCommand, operands.concat(unknown));
+          } else {
+            return subCommand._parseCommand(operands, unknown);
+          }
+        });
+        return hookResult;
+      }
+      /**
+       * Invoke help directly if possible, or dispatch if necessary.
+       * e.g. help foo
+       *
+       * @api private
+       */
+      _dispatchHelpCommand(subcommandName) {
+        if (!subcommandName) {
+          this.help();
+        }
+        const subCommand = this._findCommand(subcommandName);
+        if (subCommand && !subCommand._executableHandler) {
+          subCommand.help();
+        }
+        return this._dispatchSubcommand(subcommandName, [], [this._helpLongFlag]);
+      }
+      /**
+       * Check this.args against expected this._args.
+       *
+       * @api private
+       */
+      _checkNumberOfArguments() {
+        this._args.forEach((arg, i) => {
+          if (arg.required && this.args[i] == null) {
+            this.missingArgument(arg.name());
+          }
+        });
+        if (this._args.length > 0 && this._args[this._args.length - 1].variadic) {
+          return;
+        }
+        if (this.args.length > this._args.length) {
+          this._excessArguments(this.args);
+        }
+      }
+      /**
+       * Process this.args using this._args and save as this.processedArgs!
+       *
+       * @api private
+       */
+      _processArguments() {
+        const myParseArg = (argument, value, previous) => {
+          let parsedValue = value;
+          if (value !== null && argument.parseArg) {
+            try {
+              parsedValue = argument.parseArg(value, previous);
+            } catch (err) {
+              if (err.code === "commander.invalidArgument") {
+                const message = `error: command-argument value '${value}' is invalid for argument '${argument.name()}'. ${err.message}`;
+                this.error(message, { exitCode: err.exitCode, code: err.code });
+              }
+              throw err;
+            }
+          }
+          return parsedValue;
+        };
+        this._checkNumberOfArguments();
+        const processedArgs = [];
+        this._args.forEach((declaredArg, index) => {
+          let value = declaredArg.defaultValue;
+          if (declaredArg.variadic) {
+            if (index < this.args.length) {
+              value = this.args.slice(index);
+              if (declaredArg.parseArg) {
+                value = value.reduce((processed, v) => {
+                  return myParseArg(declaredArg, v, processed);
+                }, declaredArg.defaultValue);
+              }
+            } else if (value === void 0) {
+              value = [];
+            }
+          } else if (index < this.args.length) {
+            value = this.args[index];
+            if (declaredArg.parseArg) {
+              value = myParseArg(declaredArg, value, declaredArg.defaultValue);
+            }
+          }
+          processedArgs[index] = value;
+        });
+        this.processedArgs = processedArgs;
+      }
+      /**
+       * Once we have a promise we chain, but call synchronously until then.
+       *
+       * @param {Promise|undefined} promise
+       * @param {Function} fn
+       * @return {Promise|undefined}
+       * @api private
+       */
+      _chainOrCall(promise, fn) {
+        if (promise && promise.then && typeof promise.then === "function") {
+          return promise.then(() => fn());
+        }
+        return fn();
+      }
+      /**
+       *
+       * @param {Promise|undefined} promise
+       * @param {string} event
+       * @return {Promise|undefined}
+       * @api private
+       */
+      _chainOrCallHooks(promise, event) {
+        let result = promise;
+        const hooks = [];
+        getCommandAndParents(this).reverse().filter((cmd) => cmd._lifeCycleHooks[event] !== void 0).forEach((hookedCommand) => {
+          hookedCommand._lifeCycleHooks[event].forEach((callback) => {
+            hooks.push({ hookedCommand, callback });
+          });
+        });
+        if (event === "postAction") {
+          hooks.reverse();
+        }
+        hooks.forEach((hookDetail) => {
+          result = this._chainOrCall(result, () => {
+            return hookDetail.callback(hookDetail.hookedCommand, this);
+          });
+        });
+        return result;
+      }
+      /**
+       *
+       * @param {Promise|undefined} promise
+       * @param {Command} subCommand
+       * @param {string} event
+       * @return {Promise|undefined}
+       * @api private
+       */
+      _chainOrCallSubCommandHook(promise, subCommand, event) {
+        let result = promise;
+        if (this._lifeCycleHooks[event] !== void 0) {
+          this._lifeCycleHooks[event].forEach((hook) => {
+            result = this._chainOrCall(result, () => {
+              return hook(this, subCommand);
+            });
+          });
+        }
+        return result;
+      }
+      /**
+       * Process arguments in context of this command.
+       * Returns action result, in case it is a promise.
+       *
+       * @api private
+       */
+      _parseCommand(operands, unknown) {
+        const parsed = this.parseOptions(unknown);
+        this._parseOptionsEnv();
+        this._parseOptionsImplied();
+        operands = operands.concat(parsed.operands);
+        unknown = parsed.unknown;
+        this.args = operands.concat(unknown);
+        if (operands && this._findCommand(operands[0])) {
+          return this._dispatchSubcommand(operands[0], operands.slice(1), unknown);
+        }
+        if (this._hasImplicitHelpCommand() && operands[0] === this._helpCommandName) {
+          return this._dispatchHelpCommand(operands[1]);
+        }
+        if (this._defaultCommandName) {
+          outputHelpIfRequested(this, unknown);
+          return this._dispatchSubcommand(this._defaultCommandName, operands, unknown);
+        }
+        if (this.commands.length && this.args.length === 0 && !this._actionHandler && !this._defaultCommandName) {
+          this.help({ error: true });
+        }
+        outputHelpIfRequested(this, parsed.unknown);
+        this._checkForMissingMandatoryOptions();
+        this._checkForConflictingOptions();
+        const checkForUnknownOptions = () => {
+          if (parsed.unknown.length > 0) {
+            this.unknownOption(parsed.unknown[0]);
+          }
+        };
+        const commandEvent = `command:${this.name()}`;
+        if (this._actionHandler) {
+          checkForUnknownOptions();
+          this._processArguments();
+          let actionResult;
+          actionResult = this._chainOrCallHooks(actionResult, "preAction");
+          actionResult = this._chainOrCall(actionResult, () => this._actionHandler(this.processedArgs));
+          if (this.parent) {
+            actionResult = this._chainOrCall(actionResult, () => {
+              this.parent.emit(commandEvent, operands, unknown);
+            });
+          }
+          actionResult = this._chainOrCallHooks(actionResult, "postAction");
+          return actionResult;
+        }
+        if (this.parent && this.parent.listenerCount(commandEvent)) {
+          checkForUnknownOptions();
+          this._processArguments();
+          this.parent.emit(commandEvent, operands, unknown);
+        } else if (operands.length) {
+          if (this._findCommand("*")) {
+            return this._dispatchSubcommand("*", operands, unknown);
+          }
+          if (this.listenerCount("command:*")) {
+            this.emit("command:*", operands, unknown);
+          } else if (this.commands.length) {
+            this.unknownCommand();
+          } else {
+            checkForUnknownOptions();
+            this._processArguments();
+          }
+        } else if (this.commands.length) {
+          checkForUnknownOptions();
+          this.help({ error: true });
+        } else {
+          checkForUnknownOptions();
+          this._processArguments();
+        }
+      }
+      /**
+       * Find matching command.
+       *
+       * @api private
+       */
+      _findCommand(name) {
+        if (!name)
+          return void 0;
+        return this.commands.find((cmd) => cmd._name === name || cmd._aliases.includes(name));
+      }
+      /**
+       * Return an option matching `arg` if any.
+       *
+       * @param {string} arg
+       * @return {Option}
+       * @api private
+       */
+      _findOption(arg) {
+        return this.options.find((option2) => option2.is(arg));
+      }
+      /**
+       * Display an error message if a mandatory option does not have a value.
+       * Called after checking for help flags in leaf subcommand.
+       *
+       * @api private
+       */
+      _checkForMissingMandatoryOptions() {
+        for (let cmd = this; cmd; cmd = cmd.parent) {
+          cmd.options.forEach((anOption) => {
+            if (anOption.mandatory && cmd.getOptionValue(anOption.attributeName()) === void 0) {
+              cmd.missingMandatoryOptionValue(anOption);
+            }
+          });
+        }
+      }
+      /**
+       * Display an error message if conflicting options are used together in this.
+       *
+       * @api private
+       */
+      _checkForConflictingLocalOptions() {
+        const definedNonDefaultOptions = this.options.filter(
+          (option2) => {
+            const optionKey = option2.attributeName();
+            if (this.getOptionValue(optionKey) === void 0) {
+              return false;
+            }
+            return this.getOptionValueSource(optionKey) !== "default";
+          }
+        );
+        const optionsWithConflicting = definedNonDefaultOptions.filter(
+          (option2) => option2.conflictsWith.length > 0
+        );
+        optionsWithConflicting.forEach((option2) => {
+          const conflictingAndDefined = definedNonDefaultOptions.find(
+            (defined) => option2.conflictsWith.includes(defined.attributeName())
+          );
+          if (conflictingAndDefined) {
+            this._conflictingOption(option2, conflictingAndDefined);
+          }
+        });
+      }
+      /**
+       * Display an error message if conflicting options are used together.
+       * Called after checking for help flags in leaf subcommand.
+       *
+       * @api private
+       */
+      _checkForConflictingOptions() {
+        for (let cmd = this; cmd; cmd = cmd.parent) {
+          cmd._checkForConflictingLocalOptions();
+        }
+      }
+      /**
+       * Parse options from `argv` removing known options,
+       * and return argv split into operands and unknown arguments.
+       *
+       * Examples:
+       *
+       *     argv => operands, unknown
+       *     --known kkk op => [op], []
+       *     op --known kkk => [op], []
+       *     sub --unknown uuu op => [sub], [--unknown uuu op]
+       *     sub -- --unknown uuu op => [sub --unknown uuu op], []
+       *
+       * @param {String[]} argv
+       * @return {{operands: String[], unknown: String[]}}
+       */
+      parseOptions(argv) {
+        const operands = [];
+        const unknown = [];
+        let dest = operands;
+        const args = argv.slice();
+        function maybeOption(arg) {
+          return arg.length > 1 && arg[0] === "-";
+        }
+        let activeVariadicOption = null;
+        while (args.length) {
+          const arg = args.shift();
+          if (arg === "--") {
+            if (dest === unknown)
+              dest.push(arg);
+            dest.push(...args);
+            break;
+          }
+          if (activeVariadicOption && !maybeOption(arg)) {
+            this.emit(`option:${activeVariadicOption.name()}`, arg);
+            continue;
+          }
+          activeVariadicOption = null;
+          if (maybeOption(arg)) {
+            const option2 = this._findOption(arg);
+            if (option2) {
+              if (option2.required) {
+                const value = args.shift();
+                if (value === void 0)
+                  this.optionMissingArgument(option2);
+                this.emit(`option:${option2.name()}`, value);
+              } else if (option2.optional) {
+                let value = null;
+                if (args.length > 0 && !maybeOption(args[0])) {
+                  value = args.shift();
+                }
+                this.emit(`option:${option2.name()}`, value);
+              } else {
+                this.emit(`option:${option2.name()}`);
+              }
+              activeVariadicOption = option2.variadic ? option2 : null;
+              continue;
+            }
+          }
+          if (arg.length > 2 && arg[0] === "-" && arg[1] !== "-") {
+            const option2 = this._findOption(`-${arg[1]}`);
+            if (option2) {
+              if (option2.required || option2.optional && this._combineFlagAndOptionalValue) {
+                this.emit(`option:${option2.name()}`, arg.slice(2));
+              } else {
+                this.emit(`option:${option2.name()}`);
+                args.unshift(`-${arg.slice(2)}`);
+              }
+              continue;
+            }
+          }
+          if (/^--[^=]+=/.test(arg)) {
+            const index = arg.indexOf("=");
+            const option2 = this._findOption(arg.slice(0, index));
+            if (option2 && (option2.required || option2.optional)) {
+              this.emit(`option:${option2.name()}`, arg.slice(index + 1));
+              continue;
+            }
+          }
+          if (maybeOption(arg)) {
+            dest = unknown;
+          }
+          if ((this._enablePositionalOptions || this._passThroughOptions) && operands.length === 0 && unknown.length === 0) {
+            if (this._findCommand(arg)) {
+              operands.push(arg);
+              if (args.length > 0)
+                unknown.push(...args);
+              break;
+            } else if (arg === this._helpCommandName && this._hasImplicitHelpCommand()) {
+              operands.push(arg);
+              if (args.length > 0)
+                operands.push(...args);
+              break;
+            } else if (this._defaultCommandName) {
+              unknown.push(arg);
+              if (args.length > 0)
+                unknown.push(...args);
+              break;
+            }
+          }
+          if (this._passThroughOptions) {
+            dest.push(arg);
+            if (args.length > 0)
+              dest.push(...args);
+            break;
+          }
+          dest.push(arg);
+        }
+        return { operands, unknown };
+      }
+      /**
+       * Return an object containing local option values as key-value pairs.
+       *
+       * @return {Object}
+       */
+      opts() {
+        if (this._storeOptionsAsProperties) {
+          const result = {};
+          const len = this.options.length;
+          for (let i = 0; i < len; i++) {
+            const key = this.options[i].attributeName();
+            result[key] = key === this._versionOptionName ? this._version : this[key];
+          }
+          return result;
+        }
+        return this._optionValues;
+      }
+      /**
+       * Return an object containing merged local and global option values as key-value pairs.
+       *
+       * @return {Object}
+       */
+      optsWithGlobals() {
+        return getCommandAndParents(this).reduce(
+          (combinedOptions, cmd) => Object.assign(combinedOptions, cmd.opts()),
+          {}
+        );
+      }
+      /**
+       * Display error message and exit (or call exitOverride).
+       *
+       * @param {string} message
+       * @param {Object} [errorOptions]
+       * @param {string} [errorOptions.code] - an id string representing the error
+       * @param {number} [errorOptions.exitCode] - used with process.exit
+       */
+      error(message, errorOptions) {
+        this._outputConfiguration.outputError(`${message}
+`, this._outputConfiguration.writeErr);
+        if (typeof this._showHelpAfterError === "string") {
+          this._outputConfiguration.writeErr(`${this._showHelpAfterError}
+`);
+        } else if (this._showHelpAfterError) {
+          this._outputConfiguration.writeErr("\n");
+          this.outputHelp({ error: true });
+        }
+        const config = errorOptions || {};
+        const exitCode = config.exitCode || 1;
+        const code = config.code || "commander.error";
+        this._exit(exitCode, code, message);
+      }
+      /**
+       * Apply any option related environment variables, if option does
+       * not have a value from cli or client code.
+       *
+       * @api private
+       */
+      _parseOptionsEnv() {
+        this.options.forEach((option2) => {
+          if (option2.envVar && option2.envVar in process3.env) {
+            const optionKey = option2.attributeName();
+            if (this.getOptionValue(optionKey) === void 0 || ["default", "config", "env"].includes(this.getOptionValueSource(optionKey))) {
+              if (option2.required || option2.optional) {
+                this.emit(`optionEnv:${option2.name()}`, process3.env[option2.envVar]);
+              } else {
+                this.emit(`optionEnv:${option2.name()}`);
+              }
+            }
+          }
+        });
+      }
+      /**
+       * Apply any implied option values, if option is undefined or default value.
+       *
+       * @api private
+       */
+      _parseOptionsImplied() {
+        const dualHelper = new DualOptions(this.options);
+        const hasCustomOptionValue = (optionKey) => {
+          return this.getOptionValue(optionKey) !== void 0 && !["default", "implied"].includes(this.getOptionValueSource(optionKey));
+        };
+        this.options.filter((option2) => option2.implied !== void 0 && hasCustomOptionValue(option2.attributeName()) && dualHelper.valueFromOption(this.getOptionValue(option2.attributeName()), option2)).forEach((option2) => {
+          Object.keys(option2.implied).filter((impliedKey) => !hasCustomOptionValue(impliedKey)).forEach((impliedKey) => {
+            this.setOptionValueWithSource(impliedKey, option2.implied[impliedKey], "implied");
+          });
+        });
+      }
+      /**
+       * Argument `name` is missing.
+       *
+       * @param {string} name
+       * @api private
+       */
+      missingArgument(name) {
+        const message = `error: missing required argument '${name}'`;
+        this.error(message, { code: "commander.missingArgument" });
+      }
+      /**
+       * `Option` is missing an argument.
+       *
+       * @param {Option} option
+       * @api private
+       */
+      optionMissingArgument(option2) {
+        const message = `error: option '${option2.flags}' argument missing`;
+        this.error(message, { code: "commander.optionMissingArgument" });
+      }
+      /**
+       * `Option` does not have a value, and is a mandatory option.
+       *
+       * @param {Option} option
+       * @api private
+       */
+      missingMandatoryOptionValue(option2) {
+        const message = `error: required option '${option2.flags}' not specified`;
+        this.error(message, { code: "commander.missingMandatoryOptionValue" });
+      }
+      /**
+       * `Option` conflicts with another option.
+       *
+       * @param {Option} option
+       * @param {Option} conflictingOption
+       * @api private
+       */
+      _conflictingOption(option2, conflictingOption) {
+        const findBestOptionFromValue = (option3) => {
+          const optionKey = option3.attributeName();
+          const optionValue = this.getOptionValue(optionKey);
+          const negativeOption = this.options.find((target) => target.negate && optionKey === target.attributeName());
+          const positiveOption = this.options.find((target) => !target.negate && optionKey === target.attributeName());
+          if (negativeOption && (negativeOption.presetArg === void 0 && optionValue === false || negativeOption.presetArg !== void 0 && optionValue === negativeOption.presetArg)) {
+            return negativeOption;
+          }
+          return positiveOption || option3;
+        };
+        const getErrorMessage = (option3) => {
+          const bestOption = findBestOptionFromValue(option3);
+          const optionKey = bestOption.attributeName();
+          const source = this.getOptionValueSource(optionKey);
+          if (source === "env") {
+            return `environment variable '${bestOption.envVar}'`;
+          }
+          return `option '${bestOption.flags}'`;
+        };
+        const message = `error: ${getErrorMessage(option2)} cannot be used with ${getErrorMessage(conflictingOption)}`;
+        this.error(message, { code: "commander.conflictingOption" });
+      }
+      /**
+       * Unknown option `flag`.
+       *
+       * @param {string} flag
+       * @api private
+       */
+      unknownOption(flag) {
+        if (this._allowUnknownOption)
+          return;
+        let suggestion = "";
+        if (flag.startsWith("--") && this._showSuggestionAfterError) {
+          let candidateFlags = [];
+          let command = this;
+          do {
+            const moreFlags = command.createHelp().visibleOptions(command).filter((option2) => option2.long).map((option2) => option2.long);
+            candidateFlags = candidateFlags.concat(moreFlags);
+            command = command.parent;
+          } while (command && !command._enablePositionalOptions);
+          suggestion = suggestSimilar(flag, candidateFlags);
+        }
+        const message = `error: unknown option '${flag}'${suggestion}`;
+        this.error(message, { code: "commander.unknownOption" });
+      }
+      /**
+       * Excess arguments, more than expected.
+       *
+       * @param {string[]} receivedArgs
+       * @api private
+       */
+      _excessArguments(receivedArgs) {
+        if (this._allowExcessArguments)
+          return;
+        const expected = this._args.length;
+        const s = expected === 1 ? "" : "s";
+        const forSubcommand = this.parent ? ` for '${this.name()}'` : "";
+        const message = `error: too many arguments${forSubcommand}. Expected ${expected} argument${s} but got ${receivedArgs.length}.`;
+        this.error(message, { code: "commander.excessArguments" });
+      }
+      /**
+       * Unknown command.
+       *
+       * @api private
+       */
+      unknownCommand() {
+        const unknownName = this.args[0];
+        let suggestion = "";
+        if (this._showSuggestionAfterError) {
+          const candidateNames = [];
+          this.createHelp().visibleCommands(this).forEach((command) => {
+            candidateNames.push(command.name());
+            if (command.alias())
+              candidateNames.push(command.alias());
+          });
+          suggestion = suggestSimilar(unknownName, candidateNames);
+        }
+        const message = `error: unknown command '${unknownName}'${suggestion}`;
+        this.error(message, { code: "commander.unknownCommand" });
+      }
+      /**
+       * Set the program version to `str`.
+       *
+       * This method auto-registers the "-V, --version" flag
+       * which will print the version number when passed.
+       *
+       * You can optionally supply the  flags and description to override the defaults.
+       *
+       * @param {string} str
+       * @param {string} [flags]
+       * @param {string} [description]
+       * @return {this | string} `this` command for chaining, or version string if no arguments
+       */
+      version(str, flags, description) {
+        if (str === void 0)
+          return this._version;
+        this._version = str;
+        flags = flags || "-V, --version";
+        description = description || "output the version number";
+        const versionOption = this.createOption(flags, description);
+        this._versionOptionName = versionOption.attributeName();
+        this.options.push(versionOption);
+        this.on("option:" + versionOption.name(), () => {
+          this._outputConfiguration.writeOut(`${str}
+`);
+          this._exit(0, "commander.version", str);
+        });
+        return this;
+      }
+      /**
+       * Set the description.
+       *
+       * @param {string} [str]
+       * @param {Object} [argsDescription]
+       * @return {string|Command}
+       */
+      description(str, argsDescription) {
+        if (str === void 0 && argsDescription === void 0)
+          return this._description;
+        this._description = str;
+        if (argsDescription) {
+          this._argsDescription = argsDescription;
+        }
+        return this;
+      }
+      /**
+       * Set the summary. Used when listed as subcommand of parent.
+       *
+       * @param {string} [str]
+       * @return {string|Command}
+       */
+      summary(str) {
+        if (str === void 0)
+          return this._summary;
+        this._summary = str;
+        return this;
+      }
+      /**
+       * Set an alias for the command.
+       *
+       * You may call more than once to add multiple aliases. Only the first alias is shown in the auto-generated help.
+       *
+       * @param {string} [alias]
+       * @return {string|Command}
+       */
+      alias(alias) {
+        if (alias === void 0)
+          return this._aliases[0];
+        let command = this;
+        if (this.commands.length !== 0 && this.commands[this.commands.length - 1]._executableHandler) {
+          command = this.commands[this.commands.length - 1];
+        }
+        if (alias === command._name)
+          throw new Error("Command alias can't be the same as its name");
+        command._aliases.push(alias);
+        return this;
+      }
+      /**
+       * Set aliases for the command.
+       *
+       * Only the first alias is shown in the auto-generated help.
+       *
+       * @param {string[]} [aliases]
+       * @return {string[]|Command}
+       */
+      aliases(aliases) {
+        if (aliases === void 0)
+          return this._aliases;
+        aliases.forEach((alias) => this.alias(alias));
+        return this;
+      }
+      /**
+       * Set / get the command usage `str`.
+       *
+       * @param {string} [str]
+       * @return {String|Command}
+       */
+      usage(str) {
+        if (str === void 0) {
+          if (this._usage)
+            return this._usage;
+          const args = this._args.map((arg) => {
+            return humanReadableArgName(arg);
+          });
+          return [].concat(
+            this.options.length || this._hasHelpOption ? "[options]" : [],
+            this.commands.length ? "[command]" : [],
+            this._args.length ? args : []
+          ).join(" ");
+        }
+        this._usage = str;
+        return this;
+      }
+      /**
+       * Get or set the name of the command.
+       *
+       * @param {string} [str]
+       * @return {string|Command}
+       */
+      name(str) {
+        if (str === void 0)
+          return this._name;
+        this._name = str;
+        return this;
+      }
+      /**
+       * Set the name of the command from script filename, such as process.argv[1],
+       * or require.main.filename, or __filename.
+       *
+       * (Used internally and public although not documented in README.)
+       *
+       * @example
+       * program.nameFromFilename(require.main.filename);
+       *
+       * @param {string} filename
+       * @return {Command}
+       */
+      nameFromFilename(filename) {
+        this._name = path4.basename(filename, path4.extname(filename));
+        return this;
+      }
+      /**
+       * Get or set the directory for searching for executable subcommands of this command.
+       *
+       * @example
+       * program.executableDir(__dirname);
+       * // or
+       * program.executableDir('subcommands');
+       *
+       * @param {string} [path]
+       * @return {string|Command}
+       */
+      executableDir(path5) {
+        if (path5 === void 0)
+          return this._executableDir;
+        this._executableDir = path5;
+        return this;
+      }
+      /**
+       * Return program help documentation.
+       *
+       * @param {{ error: boolean }} [contextOptions] - pass {error:true} to wrap for stderr instead of stdout
+       * @return {string}
+       */
+      helpInformation(contextOptions) {
+        const helper = this.createHelp();
+        if (helper.helpWidth === void 0) {
+          helper.helpWidth = contextOptions && contextOptions.error ? this._outputConfiguration.getErrHelpWidth() : this._outputConfiguration.getOutHelpWidth();
+        }
+        return helper.formatHelp(this, helper);
+      }
+      /**
+       * @api private
+       */
+      _getHelpContext(contextOptions) {
+        contextOptions = contextOptions || {};
+        const context = { error: !!contextOptions.error };
+        let write;
+        if (context.error) {
+          write = (arg) => this._outputConfiguration.writeErr(arg);
+        } else {
+          write = (arg) => this._outputConfiguration.writeOut(arg);
+        }
+        context.write = contextOptions.write || write;
+        context.command = this;
+        return context;
+      }
+      /**
+       * Output help information for this command.
+       *
+       * Outputs built-in help, and custom text added using `.addHelpText()`.
+       *
+       * @param {{ error: boolean } | Function} [contextOptions] - pass {error:true} to write to stderr instead of stdout
+       */
+      outputHelp(contextOptions) {
+        let deprecatedCallback;
+        if (typeof contextOptions === "function") {
+          deprecatedCallback = contextOptions;
+          contextOptions = void 0;
+        }
+        const context = this._getHelpContext(contextOptions);
+        getCommandAndParents(this).reverse().forEach((command) => command.emit("beforeAllHelp", context));
+        this.emit("beforeHelp", context);
+        let helpInformation = this.helpInformation(context);
+        if (deprecatedCallback) {
+          helpInformation = deprecatedCallback(helpInformation);
+          if (typeof helpInformation !== "string" && !Buffer.isBuffer(helpInformation)) {
+            throw new Error("outputHelp callback must return a string or a Buffer");
+          }
+        }
+        context.write(helpInformation);
+        this.emit(this._helpLongFlag);
+        this.emit("afterHelp", context);
+        getCommandAndParents(this).forEach((command) => command.emit("afterAllHelp", context));
+      }
+      /**
+       * You can pass in flags and a description to override the help
+       * flags and help description for your command. Pass in false to
+       * disable the built-in help option.
+       *
+       * @param {string | boolean} [flags]
+       * @param {string} [description]
+       * @return {Command} `this` command for chaining
+       */
+      helpOption(flags, description) {
+        if (typeof flags === "boolean") {
+          this._hasHelpOption = flags;
+          return this;
+        }
+        this._helpFlags = flags || this._helpFlags;
+        this._helpDescription = description || this._helpDescription;
+        const helpFlags = splitOptionFlags(this._helpFlags);
+        this._helpShortFlag = helpFlags.shortFlag;
+        this._helpLongFlag = helpFlags.longFlag;
+        return this;
+      }
+      /**
+       * Output help information and exit.
+       *
+       * Outputs built-in help, and custom text added using `.addHelpText()`.
+       *
+       * @param {{ error: boolean }} [contextOptions] - pass {error:true} to write to stderr instead of stdout
+       */
+      help(contextOptions) {
+        this.outputHelp(contextOptions);
+        let exitCode = process3.exitCode || 0;
+        if (exitCode === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) {
+          exitCode = 1;
+        }
+        this._exit(exitCode, "commander.help", "(outputHelp)");
+      }
+      /**
+       * Add additional text to be displayed with the built-in help.
+       *
+       * Position is 'before' or 'after' to affect just this command,
+       * and 'beforeAll' or 'afterAll' to affect this command and all its subcommands.
+       *
+       * @param {string} position - before or after built-in help
+       * @param {string | Function} text - string to add, or a function returning a string
+       * @return {Command} `this` command for chaining
+       */
+      addHelpText(position, text) {
+        const allowedValues = ["beforeAll", "before", "after", "afterAll"];
+        if (!allowedValues.includes(position)) {
+          throw new Error(`Unexpected value for position to addHelpText.
+Expecting one of '${allowedValues.join("', '")}'`);
+        }
+        const helpEvent = `${position}Help`;
+        this.on(helpEvent, (context) => {
+          let helpStr;
+          if (typeof text === "function") {
+            helpStr = text({ error: context.error, command: context.command });
+          } else {
+            helpStr = text;
+          }
+          if (helpStr) {
+            context.write(`${helpStr}
+`);
+          }
+        });
+        return this;
+      }
+    };
+    function outputHelpIfRequested(cmd, args) {
+      const helpOption = cmd._hasHelpOption && args.find((arg) => arg === cmd._helpLongFlag || arg === cmd._helpShortFlag);
+      if (helpOption) {
+        cmd.outputHelp();
+        cmd._exit(0, "commander.helpDisplayed", "(outputHelp)");
+      }
+    }
+    function incrementNodeInspectorPort(args) {
+      return args.map((arg) => {
+        if (!arg.startsWith("--inspect")) {
+          return arg;
+        }
+        let debugOption;
+        let debugHost = "127.0.0.1";
+        let debugPort = "9229";
+        let match;
+        if ((match = arg.match(/^(--inspect(-brk)?)$/)) !== null) {
+          debugOption = match[1];
+        } else if ((match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+)$/)) !== null) {
+          debugOption = match[1];
+          if (/^\d+$/.test(match[3])) {
+            debugPort = match[3];
+          } else {
+            debugHost = match[3];
+          }
+        } else if ((match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+):(\d+)$/)) !== null) {
+          debugOption = match[1];
+          debugHost = match[3];
+          debugPort = match[4];
+        }
+        if (debugOption && debugPort !== "0") {
+          return `${debugOption}=${debugHost}:${parseInt(debugPort) + 1}`;
+        }
+        return arg;
+      });
+    }
+    function getCommandAndParents(startCommand) {
+      const result = [];
+      for (let command = startCommand; command; command = command.parent) {
+        result.push(command);
+      }
+      return result;
+    }
+    exports2.Command = Command3;
+  }
+});
+
+// node_modules/commander/index.js
+var require_commander = __commonJS({
+  "node_modules/commander/index.js"(exports2, module2) {
+    var { Argument: Argument2 } = require_argument();
+    var { Command: Command3 } = require_command();
+    var { CommanderError: CommanderError2, InvalidArgumentError: InvalidArgumentError2 } = require_error();
+    var { Help: Help2 } = require_help();
+    var { Option: Option3 } = require_option();
+    exports2 = module2.exports = new Command3();
+    exports2.program = exports2;
+    exports2.Argument = Argument2;
+    exports2.Command = Command3;
+    exports2.CommanderError = CommanderError2;
+    exports2.Help = Help2;
+    exports2.InvalidArgumentError = InvalidArgumentError2;
+    exports2.InvalidOptionArgumentError = InvalidArgumentError2;
+    exports2.Option = Option3;
+  }
+});
+
 // src/cli/index.ts
 var cli_exports = {};
 __export(cli_exports, {
   AstUtils: () => ast_utils_exports,
   GenAst: () => ast_exports2,
+  getAuroraServices: () => getAuroraServices,
+  getEmptyAuroraServices: () => getEmptyAuroraServices,
   parse: () => parse
 });
 module.exports = __toCommonJS(cli_exports);
@@ -109927,19 +112724,19 @@ function toKey(value) {
 var toKey_default = toKey;
 
 // node_modules/lodash-es/_baseGet.js
-function baseGet(object, path2) {
-  path2 = castPath_default(path2, object);
-  var index = 0, length = path2.length;
+function baseGet(object, path4) {
+  path4 = castPath_default(path4, object);
+  var index = 0, length = path4.length;
   while (object != null && index < length) {
-    object = object[toKey_default(path2[index++])];
+    object = object[toKey_default(path4[index++])];
   }
   return index && index == length ? object : void 0;
 }
 var baseGet_default = baseGet;
 
 // node_modules/lodash-es/get.js
-function get(object, path2, defaultValue) {
-  var result = object == null ? void 0 : baseGet_default(object, path2);
+function get(object, path4, defaultValue) {
+  var result = object == null ? void 0 : baseGet_default(object, path4);
   return result === void 0 ? defaultValue : result;
 }
 var get_default = get;
@@ -110851,11 +113648,11 @@ function baseHasIn(object, key) {
 var baseHasIn_default = baseHasIn;
 
 // node_modules/lodash-es/_hasPath.js
-function hasPath(object, path2, hasFunc) {
-  path2 = castPath_default(path2, object);
-  var index = -1, length = path2.length, result = false;
+function hasPath(object, path4, hasFunc) {
+  path4 = castPath_default(path4, object);
+  var index = -1, length = path4.length, result = false;
   while (++index < length) {
-    var key = toKey_default(path2[index]);
+    var key = toKey_default(path4[index]);
     if (!(result = object != null && hasFunc(object, key))) {
       break;
     }
@@ -110870,21 +113667,21 @@ function hasPath(object, path2, hasFunc) {
 var hasPath_default = hasPath;
 
 // node_modules/lodash-es/hasIn.js
-function hasIn(object, path2) {
-  return object != null && hasPath_default(object, path2, baseHasIn_default);
+function hasIn(object, path4) {
+  return object != null && hasPath_default(object, path4, baseHasIn_default);
 }
 var hasIn_default = hasIn;
 
 // node_modules/lodash-es/_baseMatchesProperty.js
 var COMPARE_PARTIAL_FLAG6 = 1;
 var COMPARE_UNORDERED_FLAG4 = 2;
-function baseMatchesProperty(path2, srcValue) {
-  if (isKey_default(path2) && isStrictComparable_default(srcValue)) {
-    return matchesStrictComparable_default(toKey_default(path2), srcValue);
+function baseMatchesProperty(path4, srcValue) {
+  if (isKey_default(path4) && isStrictComparable_default(srcValue)) {
+    return matchesStrictComparable_default(toKey_default(path4), srcValue);
   }
   return function(object) {
-    var objValue = get_default(object, path2);
-    return objValue === void 0 && objValue === srcValue ? hasIn_default(object, path2) : baseIsEqual_default(srcValue, objValue, COMPARE_PARTIAL_FLAG6 | COMPARE_UNORDERED_FLAG4);
+    var objValue = get_default(object, path4);
+    return objValue === void 0 && objValue === srcValue ? hasIn_default(object, path4) : baseIsEqual_default(srcValue, objValue, COMPARE_PARTIAL_FLAG6 | COMPARE_UNORDERED_FLAG4);
   };
 }
 var baseMatchesProperty_default = baseMatchesProperty;
@@ -110898,16 +113695,16 @@ function baseProperty(key) {
 var baseProperty_default = baseProperty;
 
 // node_modules/lodash-es/_basePropertyDeep.js
-function basePropertyDeep(path2) {
+function basePropertyDeep(path4) {
   return function(object) {
-    return baseGet_default(object, path2);
+    return baseGet_default(object, path4);
   };
 }
 var basePropertyDeep_default = basePropertyDeep;
 
 // node_modules/lodash-es/property.js
-function property(path2) {
-  return isKey_default(path2) ? baseProperty_default(toKey_default(path2)) : basePropertyDeep_default(path2);
+function property(path4) {
+  return isKey_default(path4) ? baseProperty_default(toKey_default(path4)) : basePropertyDeep_default(path4);
 }
 var property_default = property;
 
@@ -111275,8 +114072,8 @@ function baseHas(object, key) {
 var baseHas_default = baseHas;
 
 // node_modules/lodash-es/has.js
-function has(object, path2) {
-  return object != null && hasPath_default(object, path2, baseHas_default);
+function has(object, path4) {
+  return object != null && hasPath_default(object, path4, baseHas_default);
 }
 var has_default = has;
 
@@ -111424,14 +114221,14 @@ function negate(predicate) {
 var negate_default = negate;
 
 // node_modules/lodash-es/_baseSet.js
-function baseSet(object, path2, value, customizer) {
+function baseSet(object, path4, value, customizer) {
   if (!isObject_default(object)) {
     return object;
   }
-  path2 = castPath_default(path2, object);
-  var index = -1, length = path2.length, lastIndex = length - 1, nested = object;
+  path4 = castPath_default(path4, object);
+  var index = -1, length = path4.length, lastIndex = length - 1, nested = object;
   while (nested != null && ++index < length) {
-    var key = toKey_default(path2[index]), newValue = value;
+    var key = toKey_default(path4[index]), newValue = value;
     if (key === "__proto__" || key === "constructor" || key === "prototype") {
       return object;
     }
@@ -111439,7 +114236,7 @@ function baseSet(object, path2, value, customizer) {
       var objValue = nested[key];
       newValue = customizer ? customizer(objValue, key, nested) : void 0;
       if (newValue === void 0) {
-        newValue = isObject_default(objValue) ? objValue : isIndex_default(path2[index + 1]) ? [] : {};
+        newValue = isObject_default(objValue) ? objValue : isIndex_default(path4[index + 1]) ? [] : {};
       }
     }
     assignValue_default(nested, key, newValue);
@@ -111453,9 +114250,9 @@ var baseSet_default = baseSet;
 function basePickBy(object, paths, predicate) {
   var index = -1, length = paths.length, result = {};
   while (++index < length) {
-    var path2 = paths[index], value = baseGet_default(object, path2);
-    if (predicate(value, path2)) {
-      baseSet_default(result, castPath_default(path2, object), value);
+    var path4 = paths[index], value = baseGet_default(object, path4);
+    if (predicate(value, path4)) {
+      baseSet_default(result, castPath_default(path4, object), value);
     }
   }
   return result;
@@ -111471,8 +114268,8 @@ function pickBy(object, predicate) {
     return [prop];
   });
   predicate = baseIteratee_default(predicate);
-  return basePickBy_default(object, props, function(value, path2) {
-    return predicate(value, path2[0]);
+  return basePickBy_default(object, props, function(value, path4) {
+    return predicate(value, path4[0]);
   });
 }
 var pickBy_default = pickBy;
@@ -113069,12 +115866,12 @@ function assignCategoriesMapProp(tokenTypes) {
     singleAssignCategoriesToksMap([], currTokType);
   });
 }
-function singleAssignCategoriesToksMap(path2, nextNode) {
-  forEach_default(path2, (pathNode) => {
+function singleAssignCategoriesToksMap(path4, nextNode) {
+  forEach_default(path4, (pathNode) => {
     nextNode.categoryMatchesMap[pathNode.tokenTypeIdx] = true;
   });
   forEach_default(nextNode.CATEGORIES, (nextCategory) => {
-    const newPath = path2.concat(nextNode);
+    const newPath = path4.concat(nextNode);
     if (!includes_default(newPath, nextCategory)) {
       singleAssignCategoriesToksMap(newPath, nextCategory);
     }
@@ -113918,10 +116715,10 @@ var GastRefResolverVisitor = class extends GAstVisitor {
 
 // node_modules/chevrotain/lib/src/parse/grammar/interpreter.js
 var AbstractNextPossibleTokensWalker = class extends RestWalker {
-  constructor(topProd, path2) {
+  constructor(topProd, path4) {
     super();
     this.topProd = topProd;
-    this.path = path2;
+    this.path = path4;
     this.possibleTokTypes = [];
     this.nextProductionName = "";
     this.nextProductionOccurrence = 0;
@@ -113965,9 +116762,9 @@ var AbstractNextPossibleTokensWalker = class extends RestWalker {
   }
 };
 var NextAfterTokenWalker = class extends AbstractNextPossibleTokensWalker {
-  constructor(topProd, path2) {
-    super(topProd, path2);
-    this.path = path2;
+  constructor(topProd, path4) {
+    super(topProd, path4);
+    this.path = path4;
     this.nextTerminalName = "";
     this.nextTerminalOccurrence = 0;
     this.nextTerminalName = this.path.lastTok.name;
@@ -114575,10 +117372,10 @@ function initializeArrayOfArrays(size) {
   }
   return result;
 }
-function pathToHashKeys(path2) {
+function pathToHashKeys(path4) {
   let keys2 = [""];
-  for (let i = 0; i < path2.length; i++) {
-    const tokType = path2[i];
+  for (let i = 0; i < path4.length; i++) {
+    const tokType = path4[i];
     const longerKeys = [];
     for (let j = 0; j < keys2.length; j++) {
       const currShorterKey = keys2[j];
@@ -114818,7 +117615,7 @@ function validateRuleIsOverridden(ruleName, definedRulesNames, className) {
   }
   return errors;
 }
-function validateNoLeftRecursion(topRule, currRule, errMsgProvider, path2 = []) {
+function validateNoLeftRecursion(topRule, currRule, errMsgProvider, path4 = []) {
   const errors = [];
   const nextNonTerminals = getFirstNoneTerminal(currRule.definition);
   if (isEmpty_default(nextNonTerminals)) {
@@ -114830,15 +117627,15 @@ function validateNoLeftRecursion(topRule, currRule, errMsgProvider, path2 = [])
       errors.push({
         message: errMsgProvider.buildLeftRecursionError({
           topLevelRule: topRule,
-          leftRecursionPath: path2
+          leftRecursionPath: path4
         }),
         type: ParserDefinitionErrorType.LEFT_RECURSION,
         ruleName
       });
     }
-    const validNextSteps = difference_default(nextNonTerminals, path2.concat([topRule]));
+    const validNextSteps = difference_default(nextNonTerminals, path4.concat([topRule]));
     const errorsFromNextSteps = flatMap_default(validNextSteps, (currRefRule) => {
-      const newPath = clone_default(path2);
+      const newPath = clone_default(path4);
       newPath.push(currRefRule);
       return validateNoLeftRecursion(topRule, currRefRule, errMsgProvider, newPath);
     });
@@ -117698,7 +120495,7 @@ var LLStarLookaheadStrategy = class extends LLkLookaheadStrategy {
       occurrence: prodOccurrence,
       prodType: "Alternation",
       rule
-    }), (currAlt) => map_default(currAlt, (path2) => path2[0]));
+    }), (currAlt) => map_default(currAlt, (path4) => path4[0]));
     if (isLL1Sequence(partialAlts, false) && !dynamicTokensEnabled) {
       const choiceToAlt = reduce_default(partialAlts, (result, currAlt, idx) => {
         forEach_default(currAlt, (currTokType) => {
@@ -117843,7 +120640,7 @@ function adaptivePredict(dfaCaches, decision, predicateSet, logging) {
 function performLookahead(dfa, s0, predicateSet, logging) {
   let previousD = s0;
   let i = 1;
-  const path2 = [];
+  const path4 = [];
   let t = this.LA(i++);
   while (true) {
     let d = getExistingTargetState(previousD, t);
@@ -117851,13 +120648,13 @@ function performLookahead(dfa, s0, predicateSet, logging) {
       d = computeLookaheadTarget.apply(this, [dfa, previousD, t, i, predicateSet, logging]);
     }
     if (d === DFA_ERROR) {
-      return buildAdaptivePredictError(path2, previousD, t);
+      return buildAdaptivePredictError(path4, previousD, t);
     }
     if (d.isAcceptState === true) {
       return d.prediction;
     }
     previousD = d;
-    path2.push(t);
+    path4.push(t);
     t = this.LA(i++);
   }
 }
@@ -117930,13 +120727,13 @@ function getProductionDslName2(prod) {
     throw Error("non exhaustive match");
   }
 }
-function buildAdaptivePredictError(path2, previous, current) {
+function buildAdaptivePredictError(path4, previous, current) {
   const nextTransitions = flatMap_default(previous.configs.elements, (e) => e.state.transitions);
   const nextTokenTypes = uniqBy_default(nextTransitions.filter((e) => e instanceof AtomTransition).map((e) => e.tokenType), (e) => e.tokenTypeIdx);
   return {
     actualToken: current,
     possibleTokenTypes: nextTokenTypes,
-    tokenPath: path2
+    tokenPath: path4
   };
 }
 function getExistingTargetState(state, token) {
@@ -118379,7 +121176,7 @@ var Diagnostic;
   Diagnostic2.is = is;
 })(Diagnostic || (Diagnostic = {}));
 var Command;
-(function(Command2) {
+(function(Command3) {
   function create(title, command, ...args) {
     let result = { title, command };
     if (Is.defined(args) && args.length > 0) {
@@ -118387,12 +121184,12 @@ var Command;
     }
     return result;
   }
-  Command2.create = create;
+  Command3.create = create;
   function is(value) {
     let candidate = value;
     return Is.defined(candidate) && Is.string(candidate.title) && Is.string(candidate.command);
   }
-  Command2.is = is;
+  Command3.is = is;
 })(Command || (Command = {}));
 var TextEdit;
 (function(TextEdit2) {
@@ -119278,7 +122075,7 @@ var FullTextDocument = class {
 };
 var Is;
 (function(Is2) {
-  const toString3 = Object.prototype.toString;
+  const toString4 = Object.prototype.toString;
   function defined(value) {
     return typeof value !== "undefined";
   }
@@ -119292,27 +122089,27 @@ var Is;
   }
   Is2.boolean = boolean;
   function string(value) {
-    return toString3.call(value) === "[object String]";
+    return toString4.call(value) === "[object String]";
   }
   Is2.string = string;
   function number(value) {
-    return toString3.call(value) === "[object Number]";
+    return toString4.call(value) === "[object Number]";
   }
   Is2.number = number;
   function numberRange(value, min2, max) {
-    return toString3.call(value) === "[object Number]" && min2 <= value && value <= max;
+    return toString4.call(value) === "[object Number]" && min2 <= value && value <= max;
   }
   Is2.numberRange = numberRange;
   function integer2(value) {
-    return toString3.call(value) === "[object Number]" && -2147483648 <= value && value <= 2147483647;
+    return toString4.call(value) === "[object Number]" && -2147483648 <= value && value <= 2147483647;
   }
   Is2.integer = integer2;
   function uinteger2(value) {
-    return toString3.call(value) === "[object Number]" && 0 <= value && value <= 2147483647;
+    return toString4.call(value) === "[object Number]" && 0 <= value && value <= 2147483647;
   }
   Is2.uinteger = uinteger2;
   function func(value) {
-    return toString3.call(value) === "[object Function]";
+    return toString4.call(value) === "[object Function]";
   }
   Is2.func = func;
   function objectLiteral(value) {
@@ -120504,11 +123301,11 @@ __reExport(cancellation_exports, __toESM(require_cancellation(), 1));
 
 // node_modules/langium/lib/utils/promise-utils.js
 function delayNextTick() {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     if (typeof setImmediate === "undefined") {
-      setTimeout(resolve2, 0);
+      setTimeout(resolve3, 0);
     } else {
-      setImmediate(resolve2);
+      setImmediate(resolve3);
     }
   });
 }
@@ -120540,9 +123337,9 @@ async function interruptAndCheck(token) {
 }
 var Deferred = class {
   constructor() {
-    this.promise = new Promise((resolve2, reject2) => {
+    this.promise = new Promise((resolve3, reject2) => {
       this.resolve = (arg) => {
-        resolve2(arg);
+        resolve3(arg);
         return this;
       };
       this.reject = (err) => {
@@ -121601,12 +124398,12 @@ var DefaultReferences = class {
     const nameNode = this.nameProvider.getNameNode(targetNode);
     if (nameNode) {
       const doc = getDocument(targetNode);
-      const path2 = this.nodeLocator.getAstNodePath(targetNode);
+      const path4 = this.nodeLocator.getAstNodePath(targetNode);
       return {
         sourceUri: doc.uri,
-        sourcePath: path2,
+        sourcePath: path4,
         targetUri: doc.uri,
-        targetPath: path2,
+        targetPath: path4,
         segment: toDocumentSegment(nameNode),
         local: true
       };
@@ -122656,9 +125453,9 @@ var DefaultAstNodeDescriptionProvider = class {
   createDescription(node, name, document2) {
     const doc = document2 !== null && document2 !== void 0 ? document2 : getDocument(node);
     name !== null && name !== void 0 ? name : name = this.nameProvider.getName(node);
-    const path2 = this.astNodeLocator.getAstNodePath(node);
+    const path4 = this.astNodeLocator.getAstNodePath(node);
     if (!name) {
-      throw new Error(`Node at path ${path2} has no name.`);
+      throw new Error(`Node at path ${path4} has no name.`);
     }
     let nameNodeSegment;
     const nameSegmentGetter = () => {
@@ -122674,7 +125471,7 @@ var DefaultAstNodeDescriptionProvider = class {
       selectionSegment: toDocumentSegment(node.$cstNode),
       type: node.$type,
       documentUri: doc.uri,
-      path: path2
+      path: path4
     };
   }
 };
@@ -122738,8 +125535,8 @@ var DefaultAstNodeLocator = class {
     }
     return $containerProperty;
   }
-  getAstNode(node, path2) {
-    const segments = path2.split(this.segmentSeparator);
+  getAstNode(node, path4) {
+    const segments = path4.split(this.segmentSeparator);
     return segments.reduce((previousValue, currentValue) => {
       if (!previousValue || currentValue.length === 0) {
         return previousValue;
@@ -123087,15 +125884,15 @@ var DefaultDocumentBuilder = class {
     } else if (cancelToken.isCancellationRequested) {
       return Promise.reject(OperationCancelled);
     }
-    return new Promise((resolve2, reject2) => {
+    return new Promise((resolve3, reject2) => {
       const buildDisposable = this.onBuildPhase(state, () => {
         buildDisposable.dispose();
         cancelDisposable.dispose();
         if (uri) {
           const document2 = this.langiumDocuments.getDocument(uri);
-          resolve2(document2 === null || document2 === void 0 ? void 0 : document2.uri);
+          resolve3(document2 === null || document2 === void 0 ? void 0 : document2.uri);
         } else {
-          resolve2(void 0);
+          resolve3(void 0);
         }
       });
       const cancelDisposable = cancelToken.onCancellationRequested(() => {
@@ -130448,6 +133245,828 @@ var IdCacheImpl = class {
   }
 };
 
+// node_modules/langium/lib/generate/generator-tracing.js
+function getSourceRegion(sourceSpec) {
+  var _a, _b;
+  if (!sourceSpec) {
+    return void 0;
+  } else if ("astNode" in sourceSpec) {
+    return getSourceRegionOfAstNode(sourceSpec);
+  } else if (Array.isArray(sourceSpec)) {
+    return sourceSpec.reduce(mergeDocumentSegment, void 0);
+  } else {
+    const sourceRegion = sourceSpec;
+    const sourceFileURIviaCstNode = isCstNode(sourceRegion) ? getDocumentURIOrUndefined((_b = (_a = sourceRegion === null || sourceRegion === void 0 ? void 0 : sourceRegion.root) === null || _a === void 0 ? void 0 : _a.astNode) !== null && _b !== void 0 ? _b : sourceRegion === null || sourceRegion === void 0 ? void 0 : sourceRegion.astNode) : void 0;
+    return copyDocumentSegment(sourceRegion, sourceFileURIviaCstNode);
+  }
+}
+function isCstNode(segment) {
+  return typeof segment !== "undefined" && "element" in segment && "text" in segment;
+}
+function getDocumentURIOrUndefined(astNode) {
+  try {
+    return getDocument(astNode).uri.toString();
+  } catch (e) {
+    return void 0;
+  }
+}
+function getSourceRegionOfAstNode(sourceSpec) {
+  var _a, _b;
+  const { astNode, property: property2, index } = sourceSpec !== null && sourceSpec !== void 0 ? sourceSpec : {};
+  const textRegion = (_a = astNode === null || astNode === void 0 ? void 0 : astNode.$cstNode) !== null && _a !== void 0 ? _a : astNode === null || astNode === void 0 ? void 0 : astNode.$textRegion;
+  if (astNode === void 0 || textRegion === void 0) {
+    return void 0;
+  } else if (property2 === void 0) {
+    return copyDocumentSegment(textRegion, getDocumentURI(astNode));
+  } else {
+    const getSingleOrCompoundRegion = (regions) => {
+      if (index !== void 0 && index > -1 && Array.isArray(astNode[property2])) {
+        return index < regions.length ? regions[index] : void 0;
+      } else {
+        return regions.reduce(mergeDocumentSegment, void 0);
+      }
+    };
+    if ((_b = textRegion.assignments) === null || _b === void 0 ? void 0 : _b[property2]) {
+      const region = getSingleOrCompoundRegion(textRegion.assignments[property2]);
+      return region && copyDocumentSegment(region, getDocumentURI(astNode));
+    } else if (astNode.$cstNode) {
+      const region = getSingleOrCompoundRegion(findNodesForProperty(astNode.$cstNode, property2));
+      return region && copyDocumentSegment(region, getDocumentURI(astNode));
+    } else {
+      return void 0;
+    }
+  }
+}
+function getDocumentURI(astNode) {
+  var _a, _b, _c, _d;
+  if (astNode.$cstNode) {
+    return (_b = (_a = getDocument(astNode)) === null || _a === void 0 ? void 0 : _a.uri) === null || _b === void 0 ? void 0 : _b.toString();
+  } else if (astNode.$textRegion) {
+    return astNode.$textRegion.documentURI || ((_d = (_c = new TreeStreamImpl(astNode, (n) => n.$container ? [n.$container] : []).find((n) => {
+      var _a2;
+      return (_a2 = n.$textRegion) === null || _a2 === void 0 ? void 0 : _a2.documentURI;
+    })) === null || _c === void 0 ? void 0 : _c.$textRegion) === null || _d === void 0 ? void 0 : _d.documentURI);
+  } else {
+    return void 0;
+  }
+}
+function copyDocumentSegment(region, fileURI) {
+  var _a, _b;
+  const result = {
+    offset: region.offset,
+    end: (_a = region.end) !== null && _a !== void 0 ? _a : region.offset + region.length,
+    length: (_b = region.length) !== null && _b !== void 0 ? _b : region.end - region.offset
+  };
+  if (region.range) {
+    result.range = region.range;
+  }
+  fileURI !== null && fileURI !== void 0 ? fileURI : fileURI = region.fileURI;
+  if (fileURI) {
+    result.fileURI = fileURI;
+  }
+  return result;
+}
+function mergeDocumentSegment(prev, curr) {
+  var _a, _b;
+  if (!prev) {
+    return curr && copyDocumentSegment(curr);
+  } else if (!curr) {
+    return prev && copyDocumentSegment(prev);
+  }
+  const prevEnd = (_a = prev.end) !== null && _a !== void 0 ? _a : prev.offset + prev.length;
+  const currEnd = (_b = curr.end) !== null && _b !== void 0 ? _b : curr.offset + curr.length;
+  const offset = Math.min(prev.offset, curr.offset);
+  const end = Math.max(prevEnd, currEnd);
+  const length = end - offset;
+  const result = {
+    offset,
+    end,
+    length
+  };
+  if (prev.range && curr.range) {
+    result.range = {
+      start: curr.range.start.line < prev.range.start.line || curr.range.start.line === prev.range.start.line && curr.range.start.character < prev.range.start.character ? curr.range.start : prev.range.start,
+      end: curr.range.end.line > prev.range.end.line || curr.range.end.line === prev.range.end.line && curr.range.end.character > prev.range.end.character ? curr.range.end : prev.range.end
+    };
+  }
+  if (prev.fileURI || curr.fileURI) {
+    const prevURI = prev.fileURI;
+    const currURI = curr.fileURI;
+    const fileURI = prevURI && currURI && prevURI !== currURI ? `<unmergable text regions of ${prevURI}, ${currURI}>` : prevURI !== null && prevURI !== void 0 ? prevURI : currURI;
+    result.fileURI = fileURI;
+  }
+  return result;
+}
+
+// node_modules/langium/lib/generate/node-processor.js
+var Context = class {
+  constructor(defaultIndent) {
+    this.defaultIndentation = "    ";
+    this.pendingIndent = true;
+    this.currentIndents = [];
+    this.recentNonImmediateIndents = [];
+    this.traceData = [];
+    this.lines = [[]];
+    this.length = 0;
+    if (typeof defaultIndent === "string") {
+      this.defaultIndentation = defaultIndent;
+    } else if (typeof defaultIndent === "number") {
+      this.defaultIndentation = "".padStart(defaultIndent);
+    }
+  }
+  get content() {
+    return this.lines.map((e) => e.join("")).join("");
+  }
+  get contentLength() {
+    return this.length;
+  }
+  get currentLineNumber() {
+    return this.lines.length - 1;
+  }
+  get currentLineContent() {
+    return this.lines[this.currentLineNumber].join("");
+  }
+  get currentPosition() {
+    return {
+      offset: this.contentLength,
+      line: this.currentLineNumber,
+      character: this.currentLineContent.length
+    };
+  }
+  append(value, isIndent) {
+    if (value.length > 0) {
+      const beforePos = isIndent && this.currentPosition;
+      this.lines[this.currentLineNumber].push(value);
+      this.length += value.length;
+      if (beforePos) {
+        this.indentPendingTraceRegions(beforePos);
+      }
+    }
+  }
+  indentPendingTraceRegions(before) {
+    for (let i = this.traceData.length - 1; i >= 0; i--) {
+      const tr = this.traceData[i];
+      if (tr.targetStart && tr.targetStart.offset === before.offset)
+        tr.targetStart = this.currentPosition;
+    }
+  }
+  increaseIndent(node) {
+    this.currentIndents.push(node);
+    if (!node.indentImmediately) {
+      this.recentNonImmediateIndents.push(node);
+    }
+  }
+  decreaseIndent() {
+    this.currentIndents.pop();
+  }
+  get relevantIndents() {
+    return this.currentIndents.filter((i) => !this.recentNonImmediateIndents.includes(i));
+  }
+  resetCurrentLine() {
+    this.length -= this.lines[this.currentLineNumber].join("").length;
+    this.lines[this.currentLineNumber] = [];
+    this.pendingIndent = true;
+  }
+  addNewLine() {
+    this.pendingIndent = true;
+    this.lines.push([]);
+    this.recentNonImmediateIndents.length = 0;
+  }
+  pushTraceRegion(sourceRegion) {
+    const region = createTraceRegion(sourceRegion, this.currentPosition, (it) => {
+      var _a, _b;
+      return (_b = (_a = this.traceData[this.traceData.length - 1]) === null || _a === void 0 ? void 0 : _a.children) === null || _b === void 0 ? void 0 : _b.push(it);
+    });
+    this.traceData.push(region);
+    return region;
+  }
+  popTraceRegion(expected) {
+    const traceRegion = this.traceData.pop();
+    this.assertTrue(traceRegion === expected, "Trace region mismatch!");
+    return traceRegion;
+  }
+  getParentTraceSourceFileURI() {
+    var _a;
+    for (let i = this.traceData.length - 1; i > -1; i--) {
+      const fileUri = (_a = this.traceData[i].sourceRegion) === null || _a === void 0 ? void 0 : _a.fileURI;
+      if (fileUri)
+        return fileUri;
+    }
+    return void 0;
+  }
+  assertTrue(condition, msg) {
+    if (!condition) {
+      throw new Error(msg);
+    }
+  }
+};
+function createTraceRegion(sourceRegion, targetStart, accept) {
+  const result = {
+    sourceRegion,
+    targetRegion: void 0,
+    children: [],
+    targetStart,
+    complete: (targetEnd) => {
+      var _a, _b;
+      result.targetRegion = {
+        offset: result.targetStart.offset,
+        end: targetEnd.offset,
+        length: targetEnd.offset - result.targetStart.offset,
+        range: {
+          start: {
+            line: result.targetStart.line,
+            character: result.targetStart.character
+          },
+          end: {
+            line: targetEnd.line,
+            character: targetEnd.character
+          }
+        }
+      };
+      delete result.targetStart;
+      if (((_a = result.children) === null || _a === void 0 ? void 0 : _a.length) === 0) {
+        delete result.children;
+      }
+      if ((_b = result.targetRegion) === null || _b === void 0 ? void 0 : _b.length) {
+        accept(result);
+      }
+      delete result.complete;
+      return result;
+    }
+  };
+  return result;
+}
+function processGeneratorNode(node, defaultIndentation) {
+  const context = new Context(defaultIndentation);
+  const trace = context.pushTraceRegion(void 0);
+  processNodeInternal(node, context);
+  context.popTraceRegion(trace);
+  trace.complete && trace.complete(context.currentPosition);
+  const singleChild = trace.children && trace.children.length === 1 ? trace.children[0] : void 0;
+  const singleChildTargetRegion = singleChild === null || singleChild === void 0 ? void 0 : singleChild.targetRegion;
+  const rootTargetRegion = trace.targetRegion;
+  if (singleChildTargetRegion && singleChild.sourceRegion && singleChildTargetRegion.offset === rootTargetRegion.offset && singleChildTargetRegion.length === rootTargetRegion.length) {
+    return { text: context.content, trace: singleChild };
+  } else {
+    return { text: context.content, trace };
+  }
+}
+function processNodeInternal(node, context) {
+  if (typeof node === "string") {
+    processStringNode(node, context);
+  } else if (node instanceof IndentNode) {
+    processIndentNode(node, context);
+  } else if (node instanceof CompositeGeneratorNode) {
+    processCompositeNode(node, context);
+  } else if (node instanceof NewLineNode) {
+    processNewLineNode(node, context);
+  }
+}
+function hasContent(node, ctx) {
+  if (typeof node === "string") {
+    return node.length !== 0;
+  } else if (node instanceof CompositeGeneratorNode) {
+    return node.contents.some((e) => hasContent(e, ctx));
+  } else if (node instanceof NewLineNode) {
+    return !(node.ifNotEmpty && ctx.currentLineContent.length === 0);
+  } else {
+    return false;
+  }
+}
+function processStringNode(node, context) {
+  if (node) {
+    if (context.pendingIndent) {
+      handlePendingIndent(context, false);
+    }
+    context.append(node);
+  }
+}
+function handlePendingIndent(ctx, endOfLine) {
+  var _a;
+  let indent = "";
+  for (const indentNode of ctx.relevantIndents.filter((e) => e.indentEmptyLines || !endOfLine)) {
+    indent += (_a = indentNode.indentation) !== null && _a !== void 0 ? _a : ctx.defaultIndentation;
+  }
+  ctx.append(indent, true);
+  ctx.pendingIndent = false;
+}
+function processCompositeNode(node, context) {
+  let traceRegion = void 0;
+  const sourceRegion = getSourceRegion(node.tracedSource);
+  if (sourceRegion) {
+    traceRegion = context.pushTraceRegion(sourceRegion);
+  }
+  for (const child of node.contents) {
+    processNodeInternal(child, context);
+  }
+  if (traceRegion) {
+    context.popTraceRegion(traceRegion);
+    const parentsFileURI = context.getParentTraceSourceFileURI();
+    if (parentsFileURI && (sourceRegion === null || sourceRegion === void 0 ? void 0 : sourceRegion.fileURI) === parentsFileURI) {
+      delete sourceRegion.fileURI;
+    }
+    traceRegion.complete && traceRegion.complete(context.currentPosition);
+  }
+}
+function processIndentNode(node, context) {
+  var _a;
+  if (hasContent(node, context)) {
+    if (node.indentImmediately && !context.pendingIndent) {
+      context.append((_a = node.indentation) !== null && _a !== void 0 ? _a : context.defaultIndentation, true);
+    }
+    try {
+      context.increaseIndent(node);
+      processCompositeNode(node, context);
+    } finally {
+      context.decreaseIndent();
+    }
+  }
+}
+function processNewLineNode(node, context) {
+  if (node.ifNotEmpty && !hasNonWhitespace(context.currentLineContent)) {
+    context.resetCurrentLine();
+  } else {
+    if (context.pendingIndent) {
+      handlePendingIndent(context, true);
+    }
+    context.append(node.lineDelimiter);
+    context.addNewLine();
+  }
+}
+function hasNonWhitespace(text) {
+  return text.trimStart() !== "";
+}
+
+// node_modules/langium/lib/generate/template-string.js
+var SNLE = Object.freeze("__\xABSKIP^NEW^LINE^IF^EMPTY\xBB__");
+var nonWhitespace = /\S|$/;
+function findIndentation(lines) {
+  const indents = lines.filter((line) => line.length > 0).map((line) => line.search(nonWhitespace));
+  const min2 = indents.length === 0 ? 0 : Math.min(...indents);
+  return Math.max(0, min2);
+}
+
+// node_modules/langium/lib/generate/template-node.js
+function expandToNode(staticParts, ...substitutions) {
+  const templateProps = findIndentationAndTemplateStructure(staticParts);
+  const splitAndMerged = splitTemplateLinesAndMergeWithSubstitutions(staticParts, substitutions, templateProps);
+  return composeFinalGeneratorNode(splitAndMerged);
+}
+function expandTracedToNode(source, property2, index) {
+  return (staticParts, ...substitutions) => {
+    return traceToNode(source, property2, index)(expandToNode(staticParts, ...substitutions));
+  };
+}
+function findIndentationAndTemplateStructure(staticParts) {
+  const lines = staticParts.join("_").split(NEWLINE_REGEXP);
+  const omitFirstLine = lines.length > 1 && lines[0].trim().length === 0;
+  const omitLastLine = omitFirstLine && lines.length > 1 && lines[lines.length - 1].trim().length === 0;
+  if (lines.length === 1 || lines.length !== 0 && lines[0].trim().length !== 0 || lines.length === 2 && lines[1].trim().length === 0) {
+    return {
+      indentation: 0,
+      //''
+      omitFirstLine,
+      omitLastLine,
+      trimLastLine: lines.length !== 1 && lines[lines.length - 1].trim().length === 0
+    };
+  } else {
+    let sliced = omitFirstLine ? lines.slice(1) : lines;
+    sliced = omitLastLine ? sliced.slice(0, sliced.length - 1) : sliced;
+    sliced = sliced.filter((e) => e.length !== 0);
+    const indentation = findIndentation(sliced);
+    return {
+      indentation,
+      omitFirstLine,
+      // in the subsequent steps omit the last line only if it is empty or if it only contains whitespace of which the common indentation is not a valid prefix;
+      //  in other words: keep the last line if it matches the common indentation (and maybe contains non-whitespace), a non-match may be due to mistaken usage of tabs and spaces
+      omitLastLine: omitLastLine && (lines[lines.length - 1].length < indentation || !lines[lines.length - 1].startsWith(sliced[0].substring(0, indentation)))
+    };
+  }
+}
+function splitTemplateLinesAndMergeWithSubstitutions(staticParts, substitutions, { indentation, omitFirstLine, omitLastLine, trimLastLine }) {
+  const splitAndMerged = [];
+  staticParts.forEach((part, i) => {
+    splitAndMerged.push(...part.split(NEWLINE_REGEXP).map((e, j) => j === 0 || e.length < indentation ? e : e.substring(indentation)).reduce(
+      // treat the particular (potentially multiple) lines of the <i>th template segment (part),
+      //  s.t. all the effective lines are collected and separated by the NEWLINE node
+      // note: different reduce functions are provided for the initial template segment vs. the remaining segments
+      i === 0 ? (result, line, j) => (
+        // special handling of the initial template segment, which may contain line-breaks;
+        //  suppresses the injection of unintended NEWLINE indicators for templates like
+        //   expandToNode`
+        //    someText
+        //    ${something}
+        //   `
+        j === 0 ? omitFirstLine ? [] : [line] : j === 1 && result.length === 0 ? [line] : result.concat(NEWLINE, line)
+      ) : (result, line, j) => (
+        // handling of the remaining template segments
+        j === 0 ? [line] : result.concat(NEWLINE, line)
+      ),
+      []
+      // start with an empty array
+    ).filter(
+      (e) => !(typeof e === "string" && e.length === 0)
+      // drop empty strings, they don't contribute anything but might confuse subsequent processing
+    ).concat(
+      // append the corresponding substitution after each segment (part),
+      //  note that 'substitutions[i]' will be undefined for the last segment
+      isGeneratorNode(substitutions[i]) ? substitutions[i] : substitutions[i] !== void 0 ? { content: String(substitutions[i]) } : i < substitutions.length ? UNDEFINED_SEGMENT : []
+      /* don't concat anything as we passed behind the last substitution, since 'i' enumerates the indices of 'staticParts',
+              but 'substitutions' has one entry less and 'substitutions[staticParts.length -1 ]' will always be undefined */
+    ));
+  });
+  const splitAndMergedLength = splitAndMerged.length;
+  const lastItem = splitAndMergedLength !== 0 ? splitAndMerged[splitAndMergedLength - 1] : void 0;
+  if ((omitLastLine || trimLastLine) && typeof lastItem === "string" && lastItem.trim().length === 0) {
+    if (omitFirstLine && splitAndMergedLength !== 1 && splitAndMerged[splitAndMergedLength - 2] === NEWLINE) {
+      return splitAndMerged.slice(0, splitAndMergedLength - 2);
+    } else {
+      return splitAndMerged.slice(0, splitAndMergedLength - 1);
+    }
+  } else {
+    return splitAndMerged;
+  }
+}
+var NEWLINE = { isNewLine: true };
+var UNDEFINED_SEGMENT = { isUndefinedSegment: true };
+var isNewLineMarker = (nl) => nl === NEWLINE;
+var isUndefinedSegmentMarker = (us) => us === UNDEFINED_SEGMENT;
+var isSubstitutionWrapper = (s) => s.content !== void 0;
+function composeFinalGeneratorNode(splitAndMerged) {
+  const result = splitAndMerged.reduce((res, segment, i) => isUndefinedSegmentMarker(segment) ? res : isNewLineMarker(segment) ? {
+    // in case of a newLine marker append an 'ifNotEmpty' newLine by default, but
+    //  append an unconditional newLine if and only if:
+    //   * the template starts with the current line break, i.e. the first line is empty
+    //   * the current newLine marker directly follows another one, i.e. the current line is empty
+    //   * the current newline marker directly follows a substitution contributing a string (or some non-GeneratorNode being converted to a string)
+    //   * the current newline marker directly follows a (template static) string that
+    //      * is the initial token of the template
+    //      * is the initial token of the line, maybe just indentation
+    //      * follows a a substitution contributing a string (or some non-GeneratorNode being converted to a string), maybe is just irrelevant trailing whitespace
+    // in particular do _not_ append an unconditional newLine if the last substitution of a line contributes 'undefined' or an instance of 'GeneratorNode'
+    //  which may be a newline itself or be empty or (transitively) contain a trailing newline itself
+    // node: i === 0
+    //     || isNewLineMarker(splitAndMerged[i - 1]) || isSubstitutionWrapper(splitAndMerged[i - 1]) /* implies: typeof content === 'string', esp. !undefined */
+    //     || typeof splitAndMerged[i - 1] === 'string' && (
+    //         i === 1 || isNewLineMarker(splitAndMerged[i - 2]) || isSubstitutionWrapper(splitAndMerged[i - 2]) /* implies: typeof content === 'string', esp. !undefined */
+    //     )
+    //     ? res.node.appendNewLine() : res.node.appendNewLineIfNotEmpty()
+    //
+    // UPDATE cs: inverting the logic leads to the following, I hope I didn't miss anything:
+    // in case of a newLine marker append an unconditional newLine by default, but
+    //  append an 'ifNotEmpty' newLine if and only if:
+    //   * the template doesn't start with a newLine marker and
+    //      * the current newline marker directly follows a substitution contributing an `undefined` or an instance of 'GeneratorNode', or
+    //      * the current newline marker directly follows a (template static) string (containing potentially unintended trailing whitespace)
+    //          that in turn directly follows a substitution contributing an `undefined` or an instance of 'GeneratorNode'
+    node: i !== 0 && (isUndefinedSegmentMarker(splitAndMerged[i - 1]) || isGeneratorNode(splitAndMerged[i - 1])) || i > 1 && typeof splitAndMerged[i - 1] === "string" && (isUndefinedSegmentMarker(splitAndMerged[i - 2]) || isGeneratorNode(splitAndMerged[i - 2])) ? res.node.appendNewLineIfNotEmpty() : res.node.appendNewLine()
+  } : (() => {
+    var _a;
+    const indent = (i === 0 || isNewLineMarker(splitAndMerged[i - 1])) && typeof segment === "string" && segment.length !== 0 ? "".padStart(segment.length - segment.trimStart().length) : "";
+    const content = isSubstitutionWrapper(segment) ? segment.content : segment;
+    let indented;
+    return {
+      node: res.indented ? res.node : indent.length !== 0 ? res.node.indent({ indentation: indent, indentImmediately: false, indentedChildren: (ind) => indented = ind.append(content) }) : res.node.append(content),
+      indented: (
+        // if an indentNode has been created in this cycle, just register it,
+        //  otherwise check for a earlier registered indentNode and add the current segment to that one
+        indented !== null && indented !== void 0 ? indented : (_a = res.indented) === null || _a === void 0 ? void 0 : _a.append(content)
+      )
+    };
+  })(), { node: new CompositeGeneratorNode() });
+  return result.node;
+}
+
+// node_modules/langium/lib/generate/generator-node.js
+var EOL = typeof process === "undefined" ? "\n" : process.platform === "win32" ? "\r\n" : "\n";
+function isGeneratorNode(node) {
+  return node instanceof CompositeGeneratorNode || node instanceof IndentNode || node instanceof NewLineNode;
+}
+function toString3(input, defaultIndentation) {
+  if (isGeneratorNode(input))
+    return processGeneratorNode(input, defaultIndentation).text;
+  else
+    return String(input);
+}
+var CompositeGeneratorNode = class _CompositeGeneratorNode {
+  /**
+   * Constructor.
+   *
+   * @param content a var arg mixture of `strings` and {@link GeneratorNode GeneratorNodes}
+   *   describing the initial content of this {@link CompositeGeneratorNode}
+   *
+   * @example
+   *   new CompositeGeneratorNode(
+   *      'Hello World!', NL
+   *   );
+   */
+  constructor(...content) {
+    this.contents = [];
+    this.append(...content);
+  }
+  isEmpty() {
+    return this.contents.length === 0;
+  }
+  trace(source, property2, index) {
+    if (isAstNode(source)) {
+      this.tracedSource = { astNode: source, property: property2, index };
+      if (this.tracedSource.property === void 0 && this.tracedSource.index !== void 0 && this.tracedSource.index > -1) {
+        throw new Error("Generation support: 'property' argument must not be 'undefined' if a non-negative value is assigned to 'index' in 'CompositeGeneratorNode.trace(...)'.");
+      }
+    } else {
+      this.tracedSource = source;
+    }
+    return this;
+  }
+  /**
+   * Appends `strings` and instances of {@link GeneratorNode} to `this` generator node.
+   *
+   * @param content a var arg mixture of `strings`, {@link GeneratorNode GeneratorNodes}, or single param
+   *  functions that are immediately called with `this` node as argument, and which may append elements themselves.
+   *
+   * @returns `this` {@link CompositeGeneratorNode} for convenience.
+   *
+   * @example
+   *   new CompositeGeneratorNode().append(
+   *      'Hello', ' ', `${name}!`, NL, someOtherNode, 'NL', node => generateContent(node)
+   *   ).append(
+   *      'The end!'
+   *   );
+   */
+  append(...content) {
+    for (const arg of content) {
+      if (typeof arg === "function") {
+        arg(this);
+      } else if (arg) {
+        this.contents.push(arg);
+      }
+    }
+    return this;
+  }
+  /**
+   * Appends `strings` and instances of {@link GeneratorNode} to `this` generator node, if `condition` is equal to `true`.
+   *
+   * If `condition` is satisfied this method delegates to {@link append}, otherwise it returns just `this`.
+   *
+   * @param condition a boolean value indicating whether to append the elements of `args` to `this`.
+   *
+   * @param content a var arg mixture of `strings`, {@link GeneratorNode GeneratorNodes}, or single param
+   *  functions that are immediately called with `this` node as argument, and which may append elements themselves.
+   *
+   * @returns `this` {@link CompositeGeneratorNode} for convenience.
+   *
+   * @example
+   *   new CompositeGeneratorNode().append(
+   *      'Hello World!'
+   *   ).appendNewLine().appendIf(
+   *      entity !== undefined, `Hello ${entity?.name}!`
+   *   ).appendNewLineIfNotEmpty();
+   */
+  appendIf(condition, ...content) {
+    return condition ? this.append(...content) : this;
+  }
+  /**
+   * Appends a strict {@link NewLineNode} to `this` node.
+   * Strict {@link NewLineNode}s yield mandatory linebreaks in the derived generated text.
+   *
+   * @returns `this` {@link CompositeGeneratorNode} for convenience.
+   *
+   * @example
+   *   new CompositeGeneratorNode().append(
+   *      'Hello World!'
+   *   ).appendNewLine();
+   */
+  appendNewLine() {
+    return this.append(NL);
+  }
+  /**
+   * Appends a strict {@link NewLineNode} to `this` node, if `condition` is equal to `true`.
+   * Strict {@link NewLineNode}s yield mandatory linebreaks in the derived generated text.
+   *
+   * @param condition a boolean value indicating whether to append a {@link NewLineNode} to `this`.
+   *
+   * @returns `this` {@link CompositeGeneratorNode} for convenience.
+   *
+   * @example
+   *   new CompositeGeneratorNode().append(
+   *      'Hello World!'
+   *   ).appendNewLineIf(entity !== undefined).appendIf(
+   *      entity !== undefined, `Hello ${entity?.name}!`
+   *   )
+   */
+  appendNewLineIf(condition) {
+    return condition ? this.append(NL) : this;
+  }
+  /**
+   * Appends a soft {@link NewLineNode} to `this` node.
+   * Soft {@link NewLineNode}s yield linebreaks in the derived generated text only if the preceding line is non-empty,
+   * i.e. there are non-whitespace characters added to the generated text since the last linebreak.
+   *
+   * @returns `this` {@link CompositeGeneratorNode} for convenience.
+   *
+   * @example
+   *   new CompositeGeneratorNode().appendIf(
+   *      entity !== undefined, `Hello ${entity?.name}!`
+   *   ).appendNewLineIfNotEmpty();
+   */
+  appendNewLineIfNotEmpty() {
+    return this.append(NLEmpty);
+  }
+  /**
+   * Appends a soft {@link NewLineNode} to `this` node, if `condition` is equal to `true`.
+   * Soft {@link NewLineNode}s yield linebreaks in the derived generated text only if the preceding line is non-empty,
+   * i.e. there are non-whitespace characters added to the generated text since the last linebreak.
+   *
+   * @param condition a boolean value indicating whether to append a {@link NewLineNode} to `this`.
+   *
+   * @returns `this` {@link CompositeGeneratorNode} for convenience.
+   *
+   * @example
+   *   new CompositeGeneratorNode().append(
+   *      entity.label ?? ''
+   *   ).appendNewLineIfNotEmptyIf(entity.description !== undefined).append(
+   *      entity.description
+   *   )
+   */
+  appendNewLineIfNotEmptyIf(condition) {
+    return condition ? this.appendNewLineIfNotEmpty() : this;
+  }
+  /**
+   * Convenience method for appending content in form of a template to `this` generation node.
+   *
+   * See {@link expandToNode} for details.
+   *
+   * @returns `this` {@link CompositeGeneratorNode} for convenience.
+   *
+   * @example
+   *   new CompositeGeneratorNode().appendTemplate
+   *       `Hello World!`
+   *   .appendNewLine()
+   */
+  appendTemplate(staticParts, ...substitutions) {
+    return this.append(expandToNode(staticParts, ...substitutions));
+  }
+  /**
+   * Convenience method for appending content in form of a template to `this` generator node, if `condition` is equal to `true`.
+   *
+   * This method returns a tag function that takes the desired template and does the processing.
+   *
+   * If `condition` is satisfied the tagged template delegates to {@link appendTemplate}, otherwise it returns just `this`.
+   *
+   * See {@link expandToNode} for details.
+   *
+   * @param condition a boolean value indicating whether to append the template content to `this`.
+   *
+   * @returns a tag function behaving as described above, which in turn returns `this` {@link CompositeGeneratorNode} for convenience.
+   *
+   * @example
+   *   new CompositeGeneratorNode().appendTemplate
+   *       `Hello World!`
+   *   .appendNewLine().appendTemplateIf(entity !== undefined)
+   *       `Hello ${entity?.name}!`
+   *   .appendNewLineIfNotEmpty()
+   */
+  appendTemplateIf(condition) {
+    return condition ? (staticParts, ...substitutions) => this.appendTemplate(staticParts, ...substitutions) : () => this;
+  }
+  /**
+   * Adds an area of indented text output.
+   * The content to be indented can be provided as an array consisting of strings and/or generation nodes
+   * (undefined is permitted), or via a callback offering the `indentingNode` to which the content shall be appended.
+   * Alternatively, an object satisfying {@link IndentConfig} can be provided taking the children as Array or via
+   * a callback as described previously via the `indentedChildren` property.
+   *
+   * The remaining properties of {@link IndentConfig} have the following effects:
+   *  - `indentation`: a specific indentation length or string, defaults to the global indentation setting if omitted, see {@link toString},
+   *  - `indentEmptyLines`: apply indentation to empty lines, defaults to `false`
+   *  - `indentImmediately`: apply the indentation immediately starting at the first line, defaults to `true`, might be set to `false`
+   *    if preceding content is not terminated by any `newline`. If `false` the indentation is inserted only after child `newline` nodes
+   *    followed by further content.
+   *
+   * @param childrenOrConfig an {@link Array} or callback contributing the children, or a config object satisfying {@link IndentConfig} alternatively.
+   *
+   * @returns `this` {@link CompositeGeneratorNode} for convenience.
+   *
+   * @example
+   *   new CompositeGeneratorNode().append(
+   *       '{'
+   *   ).indent(indentingNode =>
+   *       indentingNode.append(
+   *           'name:', name, ','
+   *       ).appendNewLine().appendIf(description !== undefined,
+   *           'description:', description
+   *       ).appendNewLineIfNotEmpty()
+   *   ).append(
+   *       '}'
+   *   );
+   */
+  indent(childrenOrConfig) {
+    const { indentedChildren, indentation, indentEmptyLines, indentImmediately } = Array.isArray(childrenOrConfig) || typeof childrenOrConfig === "function" ? { indentedChildren: childrenOrConfig } : typeof childrenOrConfig === "object" ? childrenOrConfig : {};
+    const node = new IndentNode(indentation, indentImmediately, indentEmptyLines);
+    this.contents.push(node);
+    if (Array.isArray(indentedChildren)) {
+      node.append(...indentedChildren);
+    } else if (indentedChildren) {
+      node.append(indentedChildren);
+    }
+    return this;
+  }
+  // implementation:
+  appendTraced(source, property2, index) {
+    return (content) => {
+      return this.append(new _CompositeGeneratorNode().trace(source, property2, index).append(content));
+    };
+  }
+  // implementation:
+  appendTracedIf(condition, source, property2, index) {
+    return condition ? this.appendTraced(typeof source === "function" ? source() : source, property2, index) : () => this;
+  }
+  // implementation:
+  appendTracedTemplate(source, property2, index) {
+    return (staticParts, ...substitutions) => {
+      return this.append(expandTracedToNode(source, property2, index)(staticParts, ...substitutions));
+    };
+  }
+  // implementation:
+  appendTracedTemplateIf(condition, source, property2, index) {
+    return condition ? this.appendTracedTemplate(typeof source === "function" ? source() : source, property2, index) : () => this;
+  }
+};
+function traceToNode(astNode, property2, index) {
+  return (content) => {
+    if (content instanceof CompositeGeneratorNode && content.tracedSource === void 0) {
+      return content.trace(astNode, property2, index);
+    } else {
+      return new CompositeGeneratorNode().trace(astNode, property2, index).append(content);
+    }
+  };
+}
+var IndentNode = class extends CompositeGeneratorNode {
+  constructor(indentation, indentImmediately = true, indentEmptyLines = false) {
+    super();
+    this.indentImmediately = true;
+    this.indentEmptyLines = false;
+    if (typeof indentation === "string") {
+      this.indentation = indentation;
+    } else if (typeof indentation === "number") {
+      this.indentation = "".padStart(indentation);
+    }
+    this.indentImmediately = indentImmediately;
+    this.indentEmptyLines = indentEmptyLines;
+  }
+};
+var NewLineNode = class {
+  constructor(lineDelimiter, ifNotEmpty = false) {
+    this.ifNotEmpty = false;
+    this.lineDelimiter = lineDelimiter !== null && lineDelimiter !== void 0 ? lineDelimiter : EOL;
+    this.ifNotEmpty = ifNotEmpty;
+  }
+};
+var NL = new NewLineNode();
+var NLEmpty = new NewLineNode(void 0, true);
+
+// node_modules/langium/lib/generate/node-joiner.js
+var defaultToGenerated = (e) => e === void 0 || typeof e === "string" || isGeneratorNode(e) ? e : String(e);
+function joinToNode(iterable, toGeneratedOrOptions = defaultToGenerated, options = {}) {
+  const toGenerated = typeof toGeneratedOrOptions === "function" ? toGeneratedOrOptions : defaultToGenerated;
+  const { filter: filter2, prefix, suffix, separator, appendNewLineIfNotEmpty, skipNewLineAfterLastItem } = typeof toGeneratedOrOptions === "object" ? toGeneratedOrOptions : options;
+  const prefixFunc = typeof prefix === "function" ? prefix : () => prefix;
+  const suffixFunc = typeof suffix === "function" ? suffix : () => suffix;
+  return reduceWithIsLast(iterable, (node, it, i, isLast) => {
+    if (filter2 && !filter2(it, i, isLast)) {
+      return node;
+    }
+    const content = toGenerated(it, i, isLast);
+    return content === void 0 ? (
+      /* in this case don't append anything to */
+      node
+    ) : (
+      /* otherwise: */
+      (node !== null && node !== void 0 ? node : node = new CompositeGeneratorNode()).append(prefixFunc(it, i, isLast)).append(content).append(suffixFunc(it, i, isLast)).appendIf(!isLast, separator).appendNewLineIfNotEmptyIf(
+        // append 'newLineIfNotEmpty' elements only if 'node' has some content already,
+        //  as if the parent is an IndentNode with 'indentImmediately' set to 'false'
+        //  the indentation is not properly applied to the first non-empty line of the (this) child node
+        // besides, append the newLine only if more lines are following, if appending a newline
+        //  is not suppressed for the final item
+        !node.isEmpty() && !!appendNewLineIfNotEmpty && (!isLast || !skipNewLineAfterLastItem)
+      )
+    );
+  });
+}
+function reduceWithIsLast(iterable, callbackfn, initial) {
+  const iterator = iterable[Symbol.iterator]();
+  let next = iterator.next();
+  let index = 0;
+  let result = initial;
+  while (!next.done) {
+    const nextNext = iterator.next();
+    result = callbackfn(result, next.value, index, Boolean(nextNext.done));
+    next = nextNext;
+    index++;
+  }
+  return result;
+}
+
 // src/language/aurora-diagram-generator.ts
 var ngoFilter = [];
 function clearNGOFilter() {
@@ -131344,6 +134963,13 @@ async function extractAstNode(fileName, services) {
   var _a;
   return (_a = (await extractDocument(fileName, services)).parseResult) == null ? void 0 : _a.value;
 }
+function extractDestinationAndName(filePath, destination) {
+  filePath = path.basename(filePath, path.extname(filePath)).replace(/[.-]/g, "");
+  return {
+    destination: destination != null ? destination : path.join(path.dirname(filePath), "generated"),
+    name: path.basename(filePath)
+  };
+}
 
 // node_modules/langium/lib/node/node-file-system-provider.js
 var fs2 = __toESM(require("fs"), 1);
@@ -131369,6 +134995,77 @@ var NodeFileSystem = {
   fileSystemProvider: () => new NodeFileSystemProvider()
 };
 
+// node_modules/commander/esm.mjs
+var import_index = __toESM(require_commander(), 1);
+var {
+  program,
+  createCommand,
+  createArgument,
+  createOption,
+  CommanderError,
+  InvalidArgumentError,
+  InvalidOptionArgumentError,
+  // deprecated old name
+  Command: Command2,
+  Argument,
+  Option: Option2,
+  Help
+} = import_index.default;
+
+// src/cli/generator.ts
+var fs3 = __toESM(require("fs"), 1);
+var path2 = __toESM(require("path"), 1);
+function generateJavaScript(model, filePath, destination) {
+  const data = extractDestinationAndName(filePath, destination);
+  const generatedFilePath = `${path2.join(data.destination, data.name)}.js`;
+  const fileNode = expandToNode`
+        "use strict";
+
+        ${joinToNode(model.imports, (greeting) => `console.log('Hello, ${greeting.importedNamespace}!');`, { appendNewLineIfNotEmpty: true })}
+    `.appendNewLineIfNotEmpty();
+  if (!fs3.existsSync(data.destination)) {
+    fs3.mkdirSync(data.destination, { recursive: true });
+  }
+  fs3.writeFileSync(generatedFilePath, toString3(fileNode));
+  return generatedFilePath;
+}
+
+// src/cli/main.ts
+var fs4 = __toESM(require("fs/promises"), 1);
+var path3 = __toESM(require("path"), 1);
+var __dirname = path3.resolve();
+var packagePath = path3.resolve(__dirname, "..", "..", "package.json");
+async function loadPackageContent() {
+  const packageContent = await fs4.readFile(packagePath, "utf-8");
+  return JSON.parse(packageContent);
+}
+var getAuroraServices = async () => {
+  const services = await Promise.resolve(createAuroraServices(NodeFileSystem));
+  return services;
+};
+var getEmptyAuroraServices = async () => {
+  const services = await Promise.resolve(createAuroraServices(EmptyFileSystem));
+  return services;
+};
+var generateAction = async (fileName, opts) => {
+  const services = createAuroraServices(NodeFileSystem).Aurora;
+  const PCM4 = await extractAstNode(fileName, services);
+  const generatedFilePath = generateJavaScript(PCM4, fileName, opts.destination);
+  console.log(source_default.green(`JavaScript code generated successfully: ${generatedFilePath}`));
+};
+async function main() {
+  const program2 = new Command2();
+  const packageContent = await loadPackageContent();
+  program2.version(packageContent.version);
+  const fileExtensions = AuroraLanguageMetaData.fileExtensions.join(", ");
+  program2.command("generate").argument("<file>", `source file (possible file extensions: ${fileExtensions})`).option("-d, --destination <dir>", "destination directory of generating").description('generates JavaScript code that prints "Hello, {name}!" for each greeting in a source file').action(generateAction);
+  program2.parse(process.argv);
+}
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
+
 // src/cli/index.ts
 var parse = async (fileName) => {
   const services = createAuroraServices(NodeFileSystem).Aurora;
@@ -131379,6 +135076,8 @@ var parse = async (fileName) => {
 0 && (module.exports = {
   AstUtils,
   GenAst,
+  getAuroraServices,
+  getEmptyAuroraServices,
   parse
 });
 /*! Bundled license information: