@teambit/cli 0.0.0-387ca83bd6d05e8441bf8d4e938b4a402307cc6b

package/dist/default-error-handler.js

@@ -0,0 +1,81 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.sendToAnalyticsAndSentry = sendToAnalyticsAndSentry;
+function _chalk() {
+  const data = _interopRequireDefault(require("chalk"));
+  _chalk = function () {
+    return data;
+  };
+  return data;
+}
+function _bitError() {
+  const data = require("@teambit/bit-error");
+  _bitError = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy() {
+  const data = require("@teambit/legacy.analytics");
+  _legacy = function () {
+    return data;
+  };
+  return data;
+}
+function _legacyCli() {
+  const data = require("@teambit/legacy.cli.error");
+  _legacyCli = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+// all errors that the command does not handle comes to this switch statement
+// if you handle the error, then return true
+
+/**
+ * if err.userError is set, it inherits from AbstractError, which are user errors not Bit errors
+ * and should not be reported to Sentry.
+ * reason why we don't check (err instanceof AbstractError) is that it could be thrown from a fork,
+ * in which case, it loses its class and has only the fields.
+ */
+function sendToAnalyticsAndSentry(err) {
+  const possiblyHashedError = (0, _legacyCli().hashErrorIfNeeded)(err);
+  // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+  const shouldNotReportToSentry = Boolean(err.isUserError || err.code === 'EACCES');
+  // only level FATAL are reported to Sentry.
+  const level = shouldNotReportToSentry ? _legacy().LEVEL.INFO : _legacy().LEVEL.FATAL;
+  _legacy().Analytics.setError(level, possiblyHashedError);
+}
+function handleNonBitCustomErrors(err) {
+  // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+  if (err.code === 'EACCES' && err.path) {
+    // see #1774
+    return _chalk().default.red(
+    // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+    `error: you do not have permissions to access '${err.path}', were you running bit, npm or git as root?`);
+  }
+  // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!
+  return _chalk().default.red(err.message || err);
+}
+var _default = err => {
+  const getErrMsg = () => {
+    if (err instanceof _bitError().BitError) {
+      return err.report();
+    }
+    return handleNonBitCustomErrors(err);
+  };
+  sendToAnalyticsAndSentry(err);
+  const errorMessage = getErrMsg();
+  return {
+    message: _chalk().default.red(errorMessage),
+    error: err
+  };
+};
+exports.default = _default;
+
+//# sourceMappingURL=default-error-handler.js.map

package/dist/default-error-handler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_chalk","data","_interopRequireDefault","require","_bitError","_legacy","_legacyCli","e","__esModule","default","sendToAnalyticsAndSentry","err","possiblyHashedError","hashErrorIfNeeded","shouldNotReportToSentry","Boolean","isUserError","code","level","LEVEL","INFO","FATAL","Analytics","setError","handleNonBitCustomErrors","path","chalk","red","message","_default","getErrMsg","BitError","report","errorMessage","error","exports"],"sources":["default-error-handler.ts"],"sourcesContent":["// all errors that the command does not handle comes to this switch statement\n// if you handle the error, then return true\nimport chalk from 'chalk';\nimport { BitError } from '@teambit/bit-error';\nimport { Analytics, LEVEL } from '@teambit/legacy.analytics';\nimport { hashErrorIfNeeded } from '@teambit/legacy.cli.error';\n\n/**\n * if err.userError is set, it inherits from AbstractError, which are user errors not Bit errors\n * and should not be reported to Sentry.\n * reason why we don't check (err instanceof AbstractError) is that it could be thrown from a fork,\n * in which case, it loses its class and has only the fields.\n */\nexport function sendToAnalyticsAndSentry(err: Error) {\n  const possiblyHashedError = hashErrorIfNeeded(err);\n  // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!\n  const shouldNotReportToSentry = Boolean(err.isUserError || err.code === 'EACCES');\n  // only level FATAL are reported to Sentry.\n  const level = shouldNotReportToSentry ? LEVEL.INFO : LEVEL.FATAL;\n  Analytics.setError(level, possiblyHashedError);\n}\n\nfunction handleNonBitCustomErrors(err: Error): string {\n  // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!\n  if (err.code === 'EACCES' && err.path) {\n    // see #1774\n    return chalk.red(\n      // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!\n      `error: you do not have permissions to access '${err.path}', were you running bit, npm or git as root?`\n    );\n  }\n  // @ts-ignore AUTO-ADDED-AFTER-MIGRATION-PLEASE-FIX!\n  return chalk.red(err.message || err);\n}\n\nexport default (err: Error): { message: string; error: Error } => {\n  const getErrMsg = (): string => {\n    if (err instanceof BitError) {\n      return err.report();\n    }\n    return handleNonBitCustomErrors(err);\n  };\n  sendToAnalyticsAndSentry(err);\n  const errorMessage = getErrMsg();\n  return { message: chalk.red(errorMessage), error: err };\n};\n"],"mappings":";;;;;;;AAEA,SAAAA,OAAA;EAAA,MAAAC,IAAA,GAAAC,sBAAA,CAAAC,OAAA;EAAAH,MAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAG,UAAA;EAAA,MAAAH,IAAA,GAAAE,OAAA;EAAAC,SAAA,YAAAA,CAAA;IAAA,OAAAH,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAI,QAAA;EAAA,MAAAJ,IAAA,GAAAE,OAAA;EAAAE,OAAA,YAAAA,CAAA;IAAA,OAAAJ,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAK,WAAA;EAAA,MAAAL,IAAA,GAAAE,OAAA;EAAAG,UAAA,YAAAA,CAAA;IAAA,OAAAL,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAA8D,SAAAC,uBAAAK,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAL9D;AACA;;AAMA;AACA;AACA;AACA;AACA;AACA;AACO,SAASG,wBAAwBA,CAACC,GAAU,EAAE;EACnD,MAAMC,mBAAmB,GAAG,IAAAC,8BAAiB,EAACF,GAAG,CAAC;EAClD;EACA,MAAMG,uBAAuB,GAAGC,OAAO,CAACJ,GAAG,CAACK,WAAW,IAAIL,GAAG,CAACM,IAAI,KAAK,QAAQ,CAAC;EACjF;EACA,MAAMC,KAAK,GAAGJ,uBAAuB,GAAGK,eAAK,CAACC,IAAI,GAAGD,eAAK,CAACE,KAAK;EAChEC,mBAAS,CAACC,QAAQ,CAACL,KAAK,EAAEN,mBAAmB,CAAC;AAChD;AAEA,SAASY,wBAAwBA,CAACb,GAAU,EAAU;EACpD;EACA,IAAIA,GAAG,CAACM,IAAI,KAAK,QAAQ,IAAIN,GAAG,CAACc,IAAI,EAAE;IACrC;IACA,OAAOC,gBAAK,CAACC,GAAG;IACd;IACA,iDAAiDhB,GAAG,CAACc,IAAI,8CAC3D,CAAC;EACH;EACA;EACA,OAAOC,gBAAK,CAACC,GAAG,CAAChB,GAAG,CAACiB,OAAO,IAAIjB,GAAG,CAAC;AACtC;AAAC,IAAAkB,QAAA,GAEelB,GAAU,IAAwC;EAChE,MAAMmB,SAAS,GAAGA,CAAA,KAAc;IAC9B,IAAInB,GAAG,YAAYoB,oBAAQ,EAAE;MAC3B,OAAOpB,GAAG,CAACqB,MAAM,CAAC,CAAC;IACrB;IACA,OAAOR,wBAAwB,CAACb,GAAG,CAAC;EACtC,CAAC;EACDD,wBAAwB,CAACC,GAAG,CAAC;EAC7B,MAAMsB,YAAY,GAAGH,SAAS,CAAC,CAAC;EAChC,OAAO;IAAEF,OAAO,EAAEF,gBAAK,CAACC,GAAG,CAACM,YAAY,CAAC;IAAEC,KAAK,EAAEvB;EAAI,CAAC;AACzD,CAAC;AAAAwB,OAAA,CAAA1B,OAAA,GAAAoB,QAAA","ignoreList":[]}

package/dist/esm.mjs

@@ -0,0 +1,17 @@
+// eslint-disable-next-line import/no-unresolved
+import cjsModule from './index.js';
+
+export const CLIAspect = cjsModule.CLIAspect;
+export const MainRuntime = cjsModule.MainRuntime;
+export const handleUnhandledRejection = cjsModule.handleUnhandledRejection;
+export const handleErrorAndExit = cjsModule.handleErrorAndExit;
+export const setExitOnUnhandledRejection = cjsModule.setExitOnUnhandledRejection;
+export const defaultErrorHandler = cjsModule.defaultErrorHandler;
+export const globalFlags = cjsModule.globalFlags;
+export const CLIParser = cjsModule.CLIParser;
+export const YargsExitWorkaround = cjsModule.YargsExitWorkaround;
+export const getArgsData = cjsModule.getArgsData;
+export const getCommandName = cjsModule.getCommandName;
+export const getFlagsData = cjsModule.getFlagsData;
+
+export default cjsModule;

package/dist/exceptions/already-exists.d.ts

@@ -0,0 +1,4 @@
+import { BitError } from '@teambit/bit-error';
+export declare class AlreadyExistsError extends BitError {
+    constructor(type: string, name: string);
+}

package/dist/exceptions/already-exists.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AlreadyExistsError = void 0;
+function _bitError() {
+  const data = require("@teambit/bit-error");
+  _bitError = function () {
+    return data;
+  };
+  return data;
+}
+class AlreadyExistsError extends _bitError().BitError {
+  constructor(type, name) {
+    super(`${type} ${name} already exists.`);
+  }
+}
+exports.AlreadyExistsError = AlreadyExistsError;
+
+//# sourceMappingURL=already-exists.js.map

package/dist/exceptions/already-exists.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_bitError","data","require","AlreadyExistsError","BitError","constructor","type","name","exports"],"sources":["already-exists.ts"],"sourcesContent":["import { BitError } from '@teambit/bit-error';\n\nexport class AlreadyExistsError extends BitError {\n  constructor(type: string, name: string) {\n    super(`${type} ${name} already exists.`);\n  }\n}\n"],"mappings":";;;;;;AAAA,SAAAA,UAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,SAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEO,MAAME,kBAAkB,SAASC,oBAAQ,CAAC;EAC/CC,WAAWA,CAACC,IAAY,EAAEC,IAAY,EAAE;IACtC,KAAK,CAAC,GAAGD,IAAI,IAAIC,IAAI,kBAAkB,CAAC;EAC1C;AACF;AAACC,OAAA,CAAAL,kBAAA,GAAAA,kBAAA","ignoreList":[]}

package/dist/exceptions/command-not-found.d.ts

@@ -0,0 +1,7 @@
+import { BitError } from '@teambit/bit-error';
+export declare class CommandNotFound extends BitError {
+    commandName: string;
+    suggestion?: string;
+    constructor(commandName: string, suggestion?: string);
+    report(): string;
+}

package/dist/exceptions/command-not-found.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CommandNotFound = void 0;
+function _bitError() {
+  const data = require("@teambit/bit-error");
+  _bitError = function () {
+    return data;
+  };
+  return data;
+}
+function _chalk() {
+  const data = _interopRequireDefault(require("chalk"));
+  _chalk = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+class CommandNotFound extends _bitError().BitError {
+  constructor(commandName, suggestion) {
+    super(`command ${commandName} was not found`);
+    _defineProperty(this, "commandName", void 0);
+    _defineProperty(this, "suggestion", void 0);
+    this.commandName = commandName;
+    this.suggestion = suggestion;
+  }
+  report() {
+    let output = _chalk().default.yellow(`warning: '${_chalk().default.bold(this.commandName)}' is not a valid command.
+see 'bit help' for additional information`);
+    if (this.suggestion) {
+      output += `\nDid you mean ${_chalk().default.bold(this.suggestion)}?`;
+    }
+    return output;
+  }
+}
+exports.CommandNotFound = CommandNotFound;
+
+//# sourceMappingURL=command-not-found.js.map

package/dist/exceptions/command-not-found.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_bitError","data","require","_chalk","_interopRequireDefault","e","__esModule","default","_defineProperty","r","t","_toPropertyKey","Object","defineProperty","value","enumerable","configurable","writable","i","_toPrimitive","Symbol","toPrimitive","call","TypeError","String","Number","CommandNotFound","BitError","constructor","commandName","suggestion","report","output","chalk","yellow","bold","exports"],"sources":["command-not-found.ts"],"sourcesContent":["import { BitError } from '@teambit/bit-error';\nimport chalk from 'chalk';\n\nexport class CommandNotFound extends BitError {\n  commandName: string;\n  suggestion?: string;\n  constructor(commandName: string, suggestion?: string) {\n    super(`command ${commandName} was not found`);\n    this.commandName = commandName;\n    this.suggestion = suggestion;\n  }\n  report() {\n    let output = chalk.yellow(\n      `warning: '${chalk.bold(this.commandName)}' is not a valid command.\nsee 'bit help' for additional information`\n    );\n    if (this.suggestion) {\n      output += `\\nDid you mean ${chalk.bold(this.suggestion)}?`;\n    }\n    return output;\n  }\n}\n"],"mappings":";;;;;;AAAA,SAAAA,UAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,SAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAE,OAAA;EAAA,MAAAF,IAAA,GAAAG,sBAAA,CAAAF,OAAA;EAAAC,MAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAA0B,SAAAG,uBAAAC,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAAA,SAAAG,gBAAAH,CAAA,EAAAI,CAAA,EAAAC,CAAA,YAAAD,CAAA,GAAAE,cAAA,CAAAF,CAAA,MAAAJ,CAAA,GAAAO,MAAA,CAAAC,cAAA,CAAAR,CAAA,EAAAI,CAAA,IAAAK,KAAA,EAAAJ,CAAA,EAAAK,UAAA,MAAAC,YAAA,MAAAC,QAAA,UAAAZ,CAAA,CAAAI,CAAA,IAAAC,CAAA,EAAAL,CAAA;AAAA,SAAAM,eAAAD,CAAA,QAAAQ,CAAA,GAAAC,YAAA,CAAAT,CAAA,uCAAAQ,CAAA,GAAAA,CAAA,GAAAA,CAAA;AAAA,SAAAC,aAAAT,CAAA,EAAAD,CAAA,2BAAAC,CAAA,KAAAA,CAAA,SAAAA,CAAA,MAAAL,CAAA,GAAAK,CAAA,CAAAU,MAAA,CAAAC,WAAA,kBAAAhB,CAAA,QAAAa,CAAA,GAAAb,CAAA,CAAAiB,IAAA,CAAAZ,CAAA,EAAAD,CAAA,uCAAAS,CAAA,SAAAA,CAAA,YAAAK,SAAA,yEAAAd,CAAA,GAAAe,MAAA,GAAAC,MAAA,EAAAf,CAAA;AAEnB,MAAMgB,eAAe,SAASC,oBAAQ,CAAC;EAG5CC,WAAWA,CAACC,WAAmB,EAAEC,UAAmB,EAAE;IACpD,KAAK,CAAC,WAAWD,WAAW,gBAAgB,CAAC;IAACrB,eAAA;IAAAA,eAAA;IAC9C,IAAI,CAACqB,WAAW,GAAGA,WAAW;IAC9B,IAAI,CAACC,UAAU,GAAGA,UAAU;EAC9B;EACAC,MAAMA,CAAA,EAAG;IACP,IAAIC,MAAM,GAAGC,gBAAK,CAACC,MAAM,CACvB,aAAaD,gBAAK,CAACE,IAAI,CAAC,IAAI,CAACN,WAAW,CAAC;AAC/C,0CACI,CAAC;IACD,IAAI,IAAI,CAACC,UAAU,EAAE;MACnBE,MAAM,IAAI,kBAAkBC,gBAAK,CAACE,IAAI,CAAC,IAAI,CAACL,UAAU,CAAC,GAAG;IAC5D;IACA,OAAOE,MAAM;EACf;AACF;AAACI,OAAA,CAAAV,eAAA,GAAAA,eAAA","ignoreList":[]}

package/dist/exceptions/index.d.ts

@@ -0,0 +1,2 @@
+export { AlreadyExistsError } from './already-exists';
+export { YargsExitWorkaround } from './yargs-exit-workaround';

package/dist/exceptions/index.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "AlreadyExistsError", {
+  enumerable: true,
+  get: function () {
+    return _alreadyExists().AlreadyExistsError;
+  }
+});
+Object.defineProperty(exports, "YargsExitWorkaround", {
+  enumerable: true,
+  get: function () {
+    return _yargsExitWorkaround().YargsExitWorkaround;
+  }
+});
+function _alreadyExists() {
+  const data = require("./already-exists");
+  _alreadyExists = function () {
+    return data;
+  };
+  return data;
+}
+function _yargsExitWorkaround() {
+  const data = require("./yargs-exit-workaround");
+  _yargsExitWorkaround = function () {
+    return data;
+  };
+  return data;
+}
+
+//# sourceMappingURL=index.js.map

package/dist/exceptions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_alreadyExists","data","require","_yargsExitWorkaround"],"sources":["index.ts"],"sourcesContent":["export { AlreadyExistsError } from './already-exists';\nexport { YargsExitWorkaround } from './yargs-exit-workaround';\n"],"mappings":";;;;;;;;;;;;;;;;;AAAA,SAAAA,eAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,cAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAE,qBAAA;EAAA,MAAAF,IAAA,GAAAC,OAAA;EAAAC,oBAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA","ignoreList":[]}

package/dist/exceptions/yargs-exit-workaround.d.ts

@@ -0,0 +1,6 @@
+import { BitError } from '@teambit/bit-error';
+export declare class YargsExitWorkaround extends BitError {
+    exitCode: number;
+    helpMsg: string;
+    constructor(exitCode: number, helpMsg: string);
+}

package/dist/exceptions/yargs-exit-workaround.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.YargsExitWorkaround = void 0;
+function _bitError() {
+  const data = require("@teambit/bit-error");
+  _bitError = function () {
+    return data;
+  };
+  return data;
+}
+class YargsExitWorkaround extends _bitError().BitError {
+  constructor(exitCode, helpMsg) {
+    super('Workaround for yargs exit issue');
+    this.exitCode = exitCode;
+    this.helpMsg = helpMsg;
+  }
+}
+exports.YargsExitWorkaround = YargsExitWorkaround;
+
+//# sourceMappingURL=yargs-exit-workaround.js.map

package/dist/exceptions/yargs-exit-workaround.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_bitError","data","require","YargsExitWorkaround","BitError","constructor","exitCode","helpMsg","exports"],"sources":["yargs-exit-workaround.ts"],"sourcesContent":["import { BitError } from '@teambit/bit-error';\n\nexport class YargsExitWorkaround extends BitError {\n  constructor(\n    public exitCode: number,\n    public helpMsg: string\n  ) {\n    super('Workaround for yargs exit issue');\n  }\n}\n"],"mappings":";;;;;;AAAA,SAAAA,UAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,SAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAEO,MAAME,mBAAmB,SAASC,oBAAQ,CAAC;EAChDC,WAAWA,CACFC,QAAgB,EAChBC,OAAe,EACtB;IACA,KAAK,CAAC,iCAAiC,CAAC;IAAC,KAHlCD,QAAgB,GAAhBA,QAAgB;IAAA,KAChBC,OAAe,GAAfA,OAAe;EAGxB;AACF;AAACC,OAAA,CAAAL,mBAAA,GAAAA,mBAAA","ignoreList":[]}

package/dist/generate-doc-md.d.ts

@@ -0,0 +1,25 @@
+import { Command } from './command';
+export type GenerateOpts = {
+    metadata?: Record<string, string>;
+};
+type CommandObject = ReturnType<typeof oneCommandToObject> & {
+    commands?: any;
+};
+export declare class GenerateCommandsDoc {
+    private commands;
+    private options;
+    constructor(commands: Command[], options: GenerateOpts);
+    generate(): string;
+    generateJson(): CommandObject[];
+    private commandsToObjects;
+    private getFrontmatter;
+    private getAllPublicCommandsSorted;
+    private generateCommand;
+    private generateSubCommands;
+    private generateArguments;
+    private generateOptions;
+    private formatStringToMD;
+    private formatDescription;
+}
+declare function oneCommandToObject(command: Command): Partial<Command>;
+export {};

package/dist/generate-doc-md.js

@@ -0,0 +1,151 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.GenerateCommandsDoc = void 0;
+function _lodash() {
+  const data = require("lodash");
+  _lodash = function () {
+    return data;
+  };
+  return data;
+}
+function _getCommandId() {
+  const data = require("./get-command-id");
+  _getCommandId = function () {
+    return data;
+  };
+  return data;
+}
+class GenerateCommandsDoc {
+  constructor(commands, options) {
+    this.commands = commands;
+    this.options = options;
+  }
+  generate() {
+    const commands = this.getAllPublicCommandsSorted();
+    let output = `${this.getFrontmatter()}
+# CLI Reference
+
+Run the following to list all available Bit commands (alternatively, use the \`-h\` alias, instead of \`--help\`):
+
+\`\`\`sh
+bit --help
+\`\`\`
+
+Run the following to get help on a specific command:
+
+\`\`\`sh
+bit COMMAND --help
+\`\`\`
+
+Run the following to get help on a specific sub-command:
+
+\`\`\`sh
+bit COMMAND SUB_COMMAND --help
+\`\`\`
+`;
+    output += commands.map(cmd => this.generateCommand(cmd)).join('\n');
+    return output;
+  }
+  generateJson() {
+    return this.commandsToObjects();
+  }
+  commandsToObjects(commands = this.commands) {
+    return commands.map(command => {
+      const cmdObject = oneCommandToObject(command);
+      if (command.commands?.length) {
+        cmdObject.commands = this.commandsToObjects(command.commands);
+      }
+      return cmdObject;
+    });
+  }
+  getFrontmatter() {
+    const metadata = this.options.metadata;
+    if (!metadata) {
+      return '';
+    }
+    const metadataStr = Object.keys(metadata).map(key => `${key}: ${metadata[key]}`).join('\n');
+    return `---
+    ${metadataStr}
+    ---
+`;
+  }
+  getAllPublicCommandsSorted() {
+    const publicCommands = this.commands.filter(cmd => !cmd.private);
+    return publicCommands.sort((a, b) => a.name.localeCompare(b.name));
+  }
+  generateCommand(cmd) {
+    const commandName = (0, _getCommandId().getCommandId)(cmd.name);
+    let result = `## ${commandName}  \n\n`;
+    if (cmd.alias && cmd.alias.length > 0) {
+      result += `**Alias**: \`${cmd.alias}\`  \n`;
+    }
+    result += `**Description**: ${this.formatDescription(cmd)}`;
+    result += `\`bit ${cmd.name}\`  \n\n`;
+    if (cmd.commands && cmd.commands.length > 0) {
+      result += this.generateSubCommands(cmd.commands, cmd);
+    }
+    result += this.generateArguments(cmd.arguments);
+    result += this.generateOptions(cmd.options);
+    result += `---  \n`;
+    return result;
+  }
+  generateSubCommands(subCommands, command) {
+    let ret = '';
+    subCommands.forEach(subCommand => {
+      const commandName = (0, _getCommandId().getCommandId)(command.name);
+      const subcommandName = (0, _getCommandId().getCommandId)(subCommand.name);
+      const usage = `${commandName} ${subCommand.name}`;
+      ret += `### ${commandName} ${subcommandName} \n`;
+      ret += `**Usage**: \`${usage}\`  \n\n`;
+      ret += `**Description**: ${this.formatDescription(subCommand)}`;
+      ret += '\n';
+      ret += this.generateArguments(subCommand.arguments);
+      ret += this.generateOptions(subCommand.options);
+    });
+    return ret;
+  }
+  generateArguments(args) {
+    if (!args || !args.length) return '';
+    let output = `| **Arg** | **Description** |  \n`;
+    output += `|---|:-----:|\n`;
+    args.forEach(arg => {
+      const {
+        name,
+        description
+      } = arg;
+      output += `|\`${name}\`|${(description || '').replaceAll('\n', ' ')}|\n`;
+    });
+    output += `\n`;
+    return output;
+  }
+  generateOptions(options) {
+    if (!options || options.length <= 0) return '';
+    let output = `| **Option** | **Option alias** | **Description**|  \n`;
+    output += `|---|:-----:|---|\n`;
+    options.forEach(opt => {
+      const [alias, flag, description] = opt;
+      const aliasFormatted = alias ? `\`-${alias}\`` : '   ';
+      const flagFormatted = `--${flag}`;
+      output += `|\`${flagFormatted}\`|${aliasFormatted}|${description.replaceAll('\n', ' ')}|\n`;
+    });
+    output += `\n`;
+    return output;
+  }
+  formatStringToMD(str) {
+    return str.split('\n').join('  \n');
+  }
+  formatDescription(command) {
+    const extendedDescription = command.extendedDescription ? `  \n${this.formatStringToMD(command.extendedDescription)}` : '';
+    const description = this.formatStringToMD(command.description);
+    return `${description}${extendedDescription}  \n\n`;
+  }
+}
+exports.GenerateCommandsDoc = GenerateCommandsDoc;
+function oneCommandToObject(command) {
+  return (0, _lodash().pick)(command, ['name', 'alias', 'options', 'description', 'extendedDescription', 'group', 'private', 'internal', 'remoteOp', 'skipWorkspace', 'arguments', 'examples']);
+}
+
+//# sourceMappingURL=generate-doc-md.js.map

package/dist/generate-doc-md.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_lodash","data","require","_getCommandId","GenerateCommandsDoc","constructor","commands","options","generate","getAllPublicCommandsSorted","output","getFrontmatter","map","cmd","generateCommand","join","generateJson","commandsToObjects","command","cmdObject","oneCommandToObject","length","metadata","metadataStr","Object","keys","key","publicCommands","filter","private","sort","a","b","name","localeCompare","commandName","getCommandId","result","alias","formatDescription","generateSubCommands","generateArguments","arguments","generateOptions","subCommands","ret","forEach","subCommand","subcommandName","usage","args","arg","description","replaceAll","opt","flag","aliasFormatted","flagFormatted","formatStringToMD","str","split","extendedDescription","exports","pick"],"sources":["generate-doc-md.ts"],"sourcesContent":["import { CommandOptions, Command, CommandArg } from './command';\nimport { pick } from 'lodash';\nimport { getCommandId } from './get-command-id';\n\nexport type GenerateOpts = {\n  metadata?: Record<string, string>;\n};\n\ntype CommandObject = ReturnType<typeof oneCommandToObject> & { commands?: any };\n\nexport class GenerateCommandsDoc {\n  constructor(\n    private commands: Command[],\n    private options: GenerateOpts\n  ) {}\n\n  generate(): string {\n    const commands = this.getAllPublicCommandsSorted();\n    let output = `${this.getFrontmatter()}\n# CLI Reference\n\nRun the following to list all available Bit commands (alternatively, use the \\`-h\\` alias, instead of \\`--help\\`):\n\n\\`\\`\\`sh\nbit --help\n\\`\\`\\`\n\nRun the following to get help on a specific command:\n\n\\`\\`\\`sh\nbit COMMAND --help\n\\`\\`\\`\n\nRun the following to get help on a specific sub-command:\n\n\\`\\`\\`sh\nbit COMMAND SUB_COMMAND --help\n\\`\\`\\`\n`;\n    output += commands.map((cmd) => this.generateCommand(cmd)).join('\\n');\n\n    return output;\n  }\n\n  generateJson() {\n    return this.commandsToObjects();\n  }\n\n  private commandsToObjects(commands: Command[] = this.commands): CommandObject[] {\n    return commands.map((command) => {\n      const cmdObject: CommandObject = oneCommandToObject(command);\n      if (command.commands?.length) {\n        cmdObject.commands = this.commandsToObjects(command.commands);\n      }\n      return cmdObject;\n    });\n  }\n\n  private getFrontmatter() {\n    const metadata = this.options.metadata;\n    if (!metadata) {\n      return '';\n    }\n    const metadataStr = Object.keys(metadata)\n      .map((key) => `${key}: ${metadata[key]}`)\n      .join('\\n');\n\n    return `---\n    ${metadataStr}\n    ---\n`;\n  }\n\n  private getAllPublicCommandsSorted() {\n    const publicCommands = this.commands.filter((cmd) => !cmd.private);\n    return publicCommands.sort((a, b) => a.name.localeCompare(b.name));\n  }\n\n  private generateCommand(cmd: Command) {\n    const commandName = getCommandId(cmd.name);\n    let result = `## ${commandName}  \\n\\n`;\n    if (cmd.alias && cmd.alias.length > 0) {\n      result += `**Alias**: \\`${cmd.alias}\\`  \\n`;\n    }\n    result += `**Description**: ${this.formatDescription(cmd)}`;\n    result += `\\`bit ${cmd.name}\\`  \\n\\n`;\n\n    if (cmd.commands && cmd.commands.length > 0) {\n      result += this.generateSubCommands(cmd.commands, cmd);\n    }\n    result += this.generateArguments(cmd.arguments);\n    result += this.generateOptions(cmd.options);\n    result += `---  \\n`;\n\n    return result;\n  }\n\n  private generateSubCommands(subCommands: Command[], command: Command) {\n    let ret = '';\n    subCommands.forEach((subCommand) => {\n      const commandName = getCommandId(command.name);\n      const subcommandName = getCommandId(subCommand.name);\n      const usage = `${commandName} ${subCommand.name}`;\n      ret += `### ${commandName} ${subcommandName} \\n`;\n      ret += `**Usage**: \\`${usage}\\`  \\n\\n`;\n      ret += `**Description**: ${this.formatDescription(subCommand)}`;\n\n      ret += '\\n';\n      ret += this.generateArguments(subCommand.arguments);\n      ret += this.generateOptions(subCommand.options);\n    });\n    return ret;\n  }\n\n  private generateArguments(args?: CommandArg[]): string {\n    if (!args || !args.length) return '';\n    let output = `| **Arg** | **Description** |  \\n`;\n    output += `|---|:-----:|\\n`;\n    args.forEach((arg) => {\n      const { name, description } = arg;\n      output += `|\\`${name}\\`|${(description || '').replaceAll('\\n', ' ')}|\\n`;\n    });\n    output += `\\n`;\n    return output;\n  }\n\n  private generateOptions(options: CommandOptions): string {\n    if (!options || options.length <= 0) return '';\n    let output = `| **Option** | **Option alias** | **Description**|  \\n`;\n    output += `|---|:-----:|---|\\n`;\n    options.forEach((opt) => {\n      const [alias, flag, description] = opt;\n      const aliasFormatted = alias ? `\\`-${alias}\\`` : '   ';\n      const flagFormatted = `--${flag}`;\n      output += `|\\`${flagFormatted}\\`|${aliasFormatted}|${description.replaceAll('\\n', ' ')}|\\n`;\n    });\n    output += `\\n`;\n    return output;\n  }\n\n  private formatStringToMD(str: string): string {\n    return str.split('\\n').join('  \\n');\n  }\n\n  private formatDescription(command: Command): string {\n    const extendedDescription = command.extendedDescription\n      ? `  \\n${this.formatStringToMD(command.extendedDescription)}`\n      : '';\n    const description = this.formatStringToMD(command.description as string);\n    return `${description}${extendedDescription}  \\n\\n`;\n  }\n}\n\nfunction oneCommandToObject(command: Command) {\n  return pick(command, [\n    'name',\n    'alias',\n    'options',\n    'description',\n    'extendedDescription',\n    'group',\n    'private',\n    'internal',\n    'remoteOp',\n    'skipWorkspace',\n    'arguments',\n    'examples',\n  ]);\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/get-command-id.d.ts

@@ -0,0 +1 @@
+export declare function getCommandId(cmdName: string): string;

package/dist/get-command-id.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getCommandId = getCommandId;
+function getCommandId(cmdName) {
+  return cmdName.split(' ')[0].trim();
+}
+
+//# sourceMappingURL=get-command-id.js.map

package/dist/get-command-id.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["getCommandId","cmdName","split","trim"],"sources":["get-command-id.ts"],"sourcesContent":["export function getCommandId(cmdName: string) {\n  return cmdName.split(' ')[0].trim();\n}\n"],"mappings":";;;;;;AAAO,SAASA,YAAYA,CAACC,OAAe,EAAE;EAC5C,OAAOA,OAAO,CAACC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAACC,IAAI,CAAC,CAAC;AACrC","ignoreList":[]}

package/dist/global-flags.d.ts

@@ -0,0 +1,7 @@
+declare class GlobalFlags {
+    private _token?;
+    get token(): string | undefined;
+    set token(token: string | undefined);
+}
+declare const globalFlags: GlobalFlags;
+export default globalFlags;

package/dist/global-flags.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+class GlobalFlags {
+  constructor() {
+    _defineProperty(this, "_token", void 0);
+  }
+  get token() {
+    return this._token;
+  }
+  set token(token) {
+    this._token = token;
+  }
+}
+const globalFlags = new GlobalFlags();
+var _default = exports.default = globalFlags;
+
+//# sourceMappingURL=global-flags.js.map

package/dist/global-flags.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["GlobalFlags","constructor","_defineProperty","token","_token","globalFlags","_default","exports","default"],"sources":["global-flags.ts"],"sourcesContent":["class GlobalFlags {\n  private _token?: string;\n  get token(): string | undefined {\n    return this._token;\n  }\n\n  set token(token: string | undefined) {\n    this._token = token;\n  }\n}\n\nconst globalFlags = new GlobalFlags();\n\nexport default globalFlags;\n"],"mappings":";;;;;;;;;AAAA,MAAMA,WAAW,CAAC;EAAAC,YAAA;IAAAC,eAAA;EAAA;EAEhB,IAAIC,KAAKA,CAAA,EAAuB;IAC9B,OAAO,IAAI,CAACC,MAAM;EACpB;EAEA,IAAID,KAAKA,CAACA,KAAyB,EAAE;IACnC,IAAI,CAACC,MAAM,GAAGD,KAAK;EACrB;AACF;AAEA,MAAME,WAAW,GAAG,IAAIL,WAAW,CAAC,CAAC;AAAC,IAAAM,QAAA,GAAAC,OAAA,CAAAC,OAAA,GAEvBH,WAAW","ignoreList":[]}

package/dist/handle-errors.d.ts

@@ -0,0 +1,3 @@
+export declare function setExitOnUnhandledRejection(exit: boolean): void;
+export declare function handleErrorAndExit(err: Error, commandName: string): Promise<void>;
+export declare function handleUnhandledRejection(err: Error | null | undefined | {}): Promise<void>;

package/dist/handle-errors.js

@@ -0,0 +1,78 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.handleErrorAndExit = handleErrorAndExit;
+exports.handleUnhandledRejection = handleUnhandledRejection;
+exports.setExitOnUnhandledRejection = setExitOnUnhandledRejection;
+function _legacy() {
+  const data = require("@teambit/legacy.logger");
+  _legacy = function () {
+    return data;
+  };
+  return data;
+}
+function _defaultErrorHandler() {
+  const data = _interopRequireDefault(require("./default-error-handler"));
+  _defaultErrorHandler = function () {
+    return data;
+  };
+  return data;
+}
+function _legacy2() {
+  const data = require("@teambit/legacy.loader");
+  _legacy2 = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+let exitOnUnhandled = true;
+
+// This provide a way to not exit when an unhandled rejection is found
+// This is main required when we load plugins which are esm modules and they require cjs modules
+// and there is as an error in the cjs module
+// in such case the regular catch will not catch the error and the process will exit
+// we don't want to exit in such case (of plugins load) so we provide a way to not exit
+function setExitOnUnhandledRejection(exit) {
+  exitOnUnhandled = exit;
+}
+async function handleErrorAndExit(err, commandName) {
+  try {
+    _legacy2().loader.off();
+    _legacy().logger.error(`got an error from command ${commandName}: ${err}`, err);
+    const {
+      message
+    } = (0, _defaultErrorHandler().default)(err);
+    await logErrAndExit(message, commandName, err);
+  } catch (e) {
+    // eslint-disable-next-line no-console
+    console.error('failed to log the error properly, failure error', e);
+    // eslint-disable-next-line no-console
+    console.error('failed to log the error properly, original error', err);
+    process.exit(1);
+  }
+}
+async function handleUnhandledRejection(err) {
+  // eslint-disable-next-line no-console
+  console.error('** unhandled rejection found, please make sure the promise is resolved/rejected correctly! **', err);
+  if (!exitOnUnhandled) {
+    _legacy().logger.error(`ignoring unhandled rejection error:`, err);
+    return;
+  }
+  if (err instanceof Error) {
+    return handleErrorAndExit(err, process.argv[2]);
+  }
+  console.error(err); // eslint-disable-line
+  return handleErrorAndExit(new Error(`unhandledRejections found. err ${err}`), process.argv[2]);
+}
+async function logErrAndExit(errMsg, commandName, errObj) {
+  if (!errMsg) throw new Error(`logErrAndExit expects to get either an Error or a string, got nothing`);
+  console.error(errMsg); // eslint-disable-line
+  // for CI, print the entire error with the stacktrace
+  if (process.env.CI) console.error(errObj); // eslint-disable-line
+  await _legacy().logger.exitAfterFlush(1, commandName, errMsg.toString());
+}
+
+//# sourceMappingURL=handle-errors.js.map

package/dist/handle-errors.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_legacy","data","require","_defaultErrorHandler","_interopRequireDefault","_legacy2","e","__esModule","default","exitOnUnhandled","setExitOnUnhandledRejection","exit","handleErrorAndExit","err","commandName","loader","off","logger","error","message","defaultHandleError","logErrAndExit","console","process","handleUnhandledRejection","Error","argv","errMsg","errObj","env","CI","exitAfterFlush","toString"],"sources":["handle-errors.ts"],"sourcesContent":["import { logger } from '@teambit/legacy.logger';\nimport defaultHandleError from './default-error-handler';\nimport { loader } from '@teambit/legacy.loader';\n\nlet exitOnUnhandled = true;\n\n// This provide a way to not exit when an unhandled rejection is found\n// This is main required when we load plugins which are esm modules and they require cjs modules\n// and there is as an error in the cjs module\n// in such case the regular catch will not catch the error and the process will exit\n// we don't want to exit in such case (of plugins load) so we provide a way to not exit\nexport function setExitOnUnhandledRejection(exit: boolean) {\n  exitOnUnhandled = exit;\n}\n\nexport async function handleErrorAndExit(err: Error, commandName: string): Promise<void> {\n  try {\n    loader.off();\n    logger.error(`got an error from command ${commandName}: ${err}`, err);\n    const { message } = defaultHandleError(err);\n    await logErrAndExit(message, commandName, err);\n  } catch (e: any) {\n    // eslint-disable-next-line no-console\n    console.error('failed to log the error properly, failure error', e);\n    // eslint-disable-next-line no-console\n    console.error('failed to log the error properly, original error', err);\n    process.exit(1);\n  }\n}\n\nexport async function handleUnhandledRejection(err: Error | null | undefined | {}) {\n  // eslint-disable-next-line no-console\n  console.error('** unhandled rejection found, please make sure the promise is resolved/rejected correctly! **', err);\n  if (!exitOnUnhandled) {\n    logger.error(`ignoring unhandled rejection error:`, err);\n    return;\n  }\n  if (err instanceof Error) {\n    return handleErrorAndExit(err, process.argv[2]);\n  }\n  console.error(err); // eslint-disable-line\n  return handleErrorAndExit(new Error(`unhandledRejections found. err ${err}`), process.argv[2]);\n}\n\nasync function logErrAndExit(errMsg: Error | string, commandName: string, errObj: Error) {\n  if (!errMsg) throw new Error(`logErrAndExit expects to get either an Error or a string, got nothing`);\n  console.error(errMsg); // eslint-disable-line\n  // for CI, print the entire error with the stacktrace\n  if (process.env.CI) console.error(errObj); // eslint-disable-line\n  await logger.exitAfterFlush(1, commandName, errMsg.toString());\n}\n"],"mappings":";;;;;;;;AAAA,SAAAA,QAAA;EAAA,MAAAC,IAAA,GAAAC,OAAA;EAAAF,OAAA,YAAAA,CAAA;IAAA,OAAAC,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAE,qBAAA;EAAA,MAAAF,IAAA,GAAAG,sBAAA,CAAAF,OAAA;EAAAC,oBAAA,YAAAA,CAAA;IAAA,OAAAF,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AACA,SAAAI,SAAA;EAAA,MAAAJ,IAAA,GAAAC,OAAA;EAAAG,QAAA,YAAAA,CAAA;IAAA,OAAAJ,IAAA;EAAA;EAAA,OAAAA,IAAA;AAAA;AAAgD,SAAAG,uBAAAE,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAEhD,IAAIG,eAAe,GAAG,IAAI;;AAE1B;AACA;AACA;AACA;AACA;AACO,SAASC,2BAA2BA,CAACC,IAAa,EAAE;EACzDF,eAAe,GAAGE,IAAI;AACxB;AAEO,eAAeC,kBAAkBA,CAACC,GAAU,EAAEC,WAAmB,EAAiB;EACvF,IAAI;IACFC,iBAAM,CAACC,GAAG,CAAC,CAAC;IACZC,gBAAM,CAACC,KAAK,CAAC,6BAA6BJ,WAAW,KAAKD,GAAG,EAAE,EAAEA,GAAG,CAAC;IACrE,MAAM;MAAEM;IAAQ,CAAC,GAAG,IAAAC,8BAAkB,EAACP,GAAG,CAAC;IAC3C,MAAMQ,aAAa,CAACF,OAAO,EAAEL,WAAW,EAAED,GAAG,CAAC;EAChD,CAAC,CAAC,OAAOP,CAAM,EAAE;IACf;IACAgB,OAAO,CAACJ,KAAK,CAAC,iDAAiD,EAAEZ,CAAC,CAAC;IACnE;IACAgB,OAAO,CAACJ,KAAK,CAAC,kDAAkD,EAAEL,GAAG,CAAC;IACtEU,OAAO,CAACZ,IAAI,CAAC,CAAC,CAAC;EACjB;AACF;AAEO,eAAea,wBAAwBA,CAACX,GAAkC,EAAE;EACjF;EACAS,OAAO,CAACJ,KAAK,CAAC,+FAA+F,EAAEL,GAAG,CAAC;EACnH,IAAI,CAACJ,eAAe,EAAE;IACpBQ,gBAAM,CAACC,KAAK,CAAC,qCAAqC,EAAEL,GAAG,CAAC;IACxD;EACF;EACA,IAAIA,GAAG,YAAYY,KAAK,EAAE;IACxB,OAAOb,kBAAkB,CAACC,GAAG,EAAEU,OAAO,CAACG,IAAI,CAAC,CAAC,CAAC,CAAC;EACjD;EACAJ,OAAO,CAACJ,KAAK,CAACL,GAAG,CAAC,CAAC,CAAC;EACpB,OAAOD,kBAAkB,CAAC,IAAIa,KAAK,CAAC,kCAAkCZ,GAAG,EAAE,CAAC,EAAEU,OAAO,CAACG,IAAI,CAAC,CAAC,CAAC,CAAC;AAChG;AAEA,eAAeL,aAAaA,CAACM,MAAsB,EAAEb,WAAmB,EAAEc,MAAa,EAAE;EACvF,IAAI,CAACD,MAAM,EAAE,MAAM,IAAIF,KAAK,CAAC,uEAAuE,CAAC;EACrGH,OAAO,CAACJ,KAAK,CAACS,MAAM,CAAC,CAAC,CAAC;EACvB;EACA,IAAIJ,OAAO,CAACM,GAAG,CAACC,EAAE,EAAER,OAAO,CAACJ,KAAK,CAACU,MAAM,CAAC,CAAC,CAAC;EAC3C,MAAMX,gBAAM,CAACc,cAAc,CAAC,CAAC,EAAEjB,WAAW,EAAEa,MAAM,CAACK,QAAQ,CAAC,CAAC,CAAC;AAChE","ignoreList":[]}