@tsed/cli-core 3.20.16 → 3.21.0-rc.2

package/lib/index.modern.js

@@ -1,3832 +0,0 @@
-import Inquirer from 'inquirer';
-export { default as Inquirer } from 'inquirer';
-import { useDecorators, StoreSet, StoreMerge, isString, isArray, getValue, setValue, isFunction, Store, isClass, classOf, cleanObject, isNumber, isObject } from '@tsed/core';
-export * from '@tsed/core';
-import { Logger } from '@tsed/logger';
-export * from '@tsed/logger';
-import { GlobalProviders, Provider, Injectable, DIConfiguration, Inject, Configuration, InjectorService, Constant, registerProvider, Value, Opts, Module, createContainer } from '@tsed/di';
-export { Configuration, Constant, Container, DITest, Inject, Injectable, InjectorService, LocalsContainer, Module, Opts, OverrideProvider, UseOpts, Value, registerProvider } from '@tsed/di';
-import { __decorate, __metadata, __param } from 'tslib';
-import { Command as Command$1, Argument } from 'commander';
-import { Listr, Logger as Logger$1, figures } from 'listr2';
-import { join, dirname, relative, resolve } from 'path';
-import { EMPTY, throwError, Observable } from 'rxjs';
-import { merge, filter, catchError } from 'rxjs/operators';
-import semver$1 from 'semver';
-import execa from 'execa';
-import Fs, { existsSync } from 'fs-extra';
-import readPkgUp from 'read-pkg-up';
-import axios from 'axios';
-import querystring, { stringify } from 'querystring';
-import tunnel from 'tunnel';
-import { camelCase, snakeCase } from 'change-case';
-import parse from 'url-parse';
-import chalk from 'chalk';
-import url from 'url';
-import Consolidate from 'consolidate';
-import globby from 'globby';
-import handlebars from 'handlebars';
-import JsYaml from 'js-yaml';
-import updateNotifier from 'update-notifier';
-
-var PackageManager;
-
-(function (PackageManager) {
-  PackageManager["YARN"] = "yarn";
-  PackageManager["NPM"] = "npm";
-  PackageManager["PNPM"] = "pnpm";
-})(PackageManager || (PackageManager = {}));
-
-var CommandStoreKeys;
-
-(function (CommandStoreKeys) {
-  CommandStoreKeys["COMMAND"] = "command";
-  CommandStoreKeys["ADD"] = "$onAdd";
-  CommandStoreKeys["EXEC_HOOKS"] = "$onExec";
-  CommandStoreKeys["POST_INSTALL_HOOKS"] = "$onPostInstall";
-  CommandStoreKeys["PROMPT_HOOKS"] = "$onPrompt";
-})(CommandStoreKeys || (CommandStoreKeys = {}));
-
-const PROVIDER_TYPE_COMMAND = "command";
-/**
- *
- * @type {Registry<Provider<any>, IProvider<any>>}
- */
-// tslint:disable-next-line: variable-name
-
-GlobalProviders.createRegistry(PROVIDER_TYPE_COMMAND, Provider);
-const registerCommand = GlobalProviders.createRegisterFn(PROVIDER_TYPE_COMMAND);
-
-function Command(options) {
-  return useDecorators(registerCommand, StoreSet(CommandStoreKeys.COMMAND, options));
-}
-
-function On(hookName, name) {
-  return (target, propertyKey) => {
-    StoreMerge(hookName, {
-      [name]: [propertyKey]
-    })(target);
-  };
-}
-
-function OnAdd(cliPlugin) {
-  return On(CommandStoreKeys.ADD, cliPlugin);
-}
-
-function OnExec(cmdName) {
-  return On(CommandStoreKeys.EXEC_HOOKS, cmdName);
-}
-
-function OnPostInstall(cmdName) {
-  return On(CommandStoreKeys.POST_INSTALL_HOOKS, cmdName);
-}
-
-function OnPrompt(cmdName) {
-  return On(CommandStoreKeys.PROMPT_HOOKS, cmdName);
-}
-
-let CliConfiguration = class CliConfiguration extends DIConfiguration {
-  constructor() {
-    super({
-      project: {
-        root: process.cwd(),
-        srcDir: "src"
-      }
-    });
-  }
-
-};
-CliConfiguration = __decorate([Injectable(), __metadata("design:paramtypes", [])], CliConfiguration);
-
-function _extends() {
-  _extends = Object.assign || function (target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i];
-
-      for (var key in source) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-          target[key] = source[key];
-        }
-      }
-    }
-
-    return target;
-  };
-
-  return _extends.apply(this, arguments);
-}
-
-function _objectWithoutPropertiesLoose(source, excluded) {
-  if (source == null) return {};
-  var target = {};
-  var sourceKeys = Object.keys(source);
-  var key, i;
-
-  for (i = 0; i < sourceKeys.length; i++) {
-    key = sourceKeys[i];
-    if (excluded.indexOf(key) >= 0) continue;
-    target[key] = source[key];
-  }
-
-  return target;
-}
-
-require("any-observable/register/rxjs-all");
-
-const streamToObservable = require("@samverschueren/stream-to-observable");
-
-const split = require("split");
-
-let CliExeca = class CliExeca {
-  constructor() {
-    this.raw = execa;
-  }
-
-  /**
-   *
-   * @param cmd
-   * @param args
-   * @param opts
-   */
-  run(cmd, args, opts) {
-    const cp = this.raw(cmd, args, opts);
-    const stdout = streamToObservable(cp.stdout.pipe(split()), {
-      await: cp
-    });
-    const stderr = streamToObservable(cp.stderr.pipe(split()), {
-      await: cp
-    });
-    return stdout.pipe(merge(stderr)).pipe(filter(Boolean));
-  }
-
-  runSync(cmd, args, opts) {
-    return this.raw.sync(cmd, args, opts);
-  }
-
-  async getAsync(cmd, args, opts) {
-    return (await this.raw(cmd, args, opts)).stdout;
-  }
-
-  get(cmd, args, opts) {
-    return this.raw.sync(cmd, args, opts).stdout;
-  }
-
-};
-CliExeca = __decorate([Injectable()], CliExeca);
-
-const fixPath = require("normalize-path");
-
-function normalizePath$1(item, ...paths) {
-  if (isString(item)) {
-    const path = join(item, ...paths);
-    return fixPath(path);
-  }
-
-  if (isArray(item)) {
-    return item.map(item => normalizePath$1(item));
-  }
-
-  return item;
-}
-
-let CliFs = class CliFs {
-  constructor() {
-    this.raw = Fs;
-  }
-
-  exists(path) {
-    return this.raw.existsSync(path);
-  }
-
-  join(...args) {
-    return normalizePath$1(join(...args));
-  }
-
-  async readFile(file, encoding) {
-    return this.raw.readFile(file, encoding);
-  }
-
-  writeFileSync(path, data, options) {
-    return this.raw.writeFileSync(path, data, options);
-  }
-
-  writeFile(file, data, options) {
-    return this.raw.writeFile(file, data, options);
-  }
-
-  ensureDir(path, options) {
-    return this.raw.ensureDir(path, options);
-  }
-
-  ensureDirSync(path, options) {
-    return this.raw.ensureDirSync(path, options);
-  }
-
-  findUpFile(root, file) {
-    return [join(root, file), join(root, "..", file), join(root, "..", "..", file), join(root, "..", "..", "..", file)].find(path => this.exists(path));
-  }
-
-  async importModule(mod, root = process.cwd()) {
-    try {
-      if (process.env.NODE_ENV === "development") {
-        return await import(mod);
-      }
-    } catch (er) {}
-
-    const path = this.findUpFile(root, join("node_modules", mod));
-
-    if (path) {
-      return import(path);
-    }
-
-    return import(mod);
-  }
-
-};
-CliFs = __decorate([Injectable()], CliFs);
-
-function isValidVersion(version) {
-  version = version.replace(/[~>=<]/gi, "");
-  return !!semver$1.valid(version);
-}
-
-function useReadPkgUp(configuration) {
-  var _configuration$projec;
-
-  return !(process.argv.includes("init") && !Fs.existsSync(join(String((_configuration$projec = configuration.project) == null ? void 0 : _configuration$projec.rootDir), "package.json")));
-}
-
-function getEmptyPackageJson(configuration) {
-  return {
-    name: configuration.name,
-    version: "1.0.0",
-    description: "",
-    scripts: {},
-    dependencies: {},
-    devDependencies: {}
-  };
-}
-
-function getPackageJson(configuration) {
-  if (useReadPkgUp(configuration)) {
-    var _configuration$projec2;
-
-    const result = readPkgUp.sync({
-      cwd: (_configuration$projec2 = configuration.project) == null ? void 0 : _configuration$projec2.rootDir
-    });
-
-    if (result && result.path) {
-      const pkgPath = dirname(result.path);
-      configuration.set("project.root", pkgPath);
-      const pkg = Fs.readJsonSync(result.path, {
-        encoding: "utf8"
-      });
-      return _extends({}, getEmptyPackageJson(configuration), pkg);
-    }
-  }
-
-  return getEmptyPackageJson(configuration);
-}
-
-function mapPackagesWithInvalidVersion(deps) {
-  const toString = info => {
-    return info[1] === "latest" ? info[0] : info.join("@");
-  };
-
-  return Object.entries(deps).filter(([, version]) => !semver$1.valid(version)).map(toString);
-}
-
-function sortKeys(obj) {
-  return Object.entries(obj).sort((k1, k2) => {
-    return k1[0] < k2[0] ? -1 : 1;
-  }).reduce((obj, [key, value]) => {
-    return _extends({}, obj, {
-      [key]: value
-    });
-  }, {});
-}
-
-function mapPackagesWithValidVersion(deps) {
-  return Object.entries(deps).reduce((deps, [key, version]) => {
-    if (isValidVersion(version)) {
-      return _extends({}, deps, {
-        [key]: version
-      });
-    }
-
-    return deps;
-  }, {});
-}
-
-function defaultPreferences(pkg) {
-  let packageManager = PackageManager.YARN;
-
-  if (getValue(pkg, "scripts.build", "").includes("pnpm ")) {
-    packageManager = PackageManager.PNPM;
-  } else if (getValue(pkg, "scripts.build", "").includes("npm ")) {
-    packageManager = PackageManager.NPM;
-  }
-
-  return {
-    packageManager
-  };
-}
-
-let ProjectPackageJson = class ProjectPackageJson {
-  constructor(configuration) {
-    this.configuration = void 0;
-    this.rewrite = false;
-    this.reinstall = false;
-    this.cliExeca = void 0;
-    this.fs = void 0;
-    this.GH_TOKEN = void 0;
-    this.raw = void 0;
-    this.configuration = configuration;
-    this.setRaw({
-      name: "",
-      version: "1.0.0",
-      description: "",
-      scripts: {},
-      dependencies: {},
-      devDependencies: {}
-    });
-    this.read();
-  }
-
-  get path() {
-    return join(this.dir, "package.json");
-  }
-
-  get dir() {
-    var _this$configuration$p;
-
-    return String((_this$configuration$p = this.configuration.project) == null ? void 0 : _this$configuration$p.rootDir);
-  }
-
-  set dir(dir) {
-    this.configuration.project.rootDir = dir;
-    this.read();
-  }
-
-  get name() {
-    return this.raw.name;
-  }
-
-  set name(name) {
-    this.raw.name = name;
-    this.rewrite = true;
-  }
-
-  get version() {
-    return this.raw.version;
-  }
-
-  get description() {
-    return this.raw.description;
-  }
-
-  get scripts() {
-    return this.raw.scripts;
-  }
-
-  get dependencies() {
-    return this.raw.dependencies;
-  }
-
-  get devDependencies() {
-    return this.raw.devDependencies;
-  }
-
-  get allDependencies() {
-    return _extends({}, this.dependencies || {}, this.devDependencies || {});
-  }
-
-  get preferences() {
-    return this.raw[this.configuration.name];
-  }
-
-  toJSON() {
-    return this.raw;
-  }
-
-  read() {
-    const pkg = this.getPackageJson();
-    this.setRaw(pkg);
-    return this;
-  }
-
-  setRaw(pkg) {
-    const projectPreferences = this.configuration.defaultProjectPreferences;
-    const preferences = getValue(pkg, this.configuration.name);
-    this.raw = _extends({}, pkg, {
-      [this.configuration.name]: _extends({}, defaultPreferences(pkg), projectPreferences && projectPreferences(pkg), preferences)
-    });
-  }
-
-  getRunCmd() {
-    switch (this.preferences.packageManager) {
-      case "npm":
-        return "npm run";
-
-      case "pnpm":
-        return "pnpm run";
-
-      default:
-        return "yarn run";
-    }
-  }
-
-  addDevDependency(pkg, version) {
-    this.devDependencies[pkg] = version;
-    this.reinstall = true;
-    this.rewrite = true;
-    return this;
-  }
-
-  addDevDependencies(modules, scope = {}) {
-    const replacer = (match, key) => getValue(key, scope);
-
-    Object.entries(modules).forEach(([pkg, version]) => {
-      this.addDevDependency(pkg, (version || "").replace(/{{([\w.]+)}}/gi, replacer));
-    });
-    return this;
-  }
-
-  addDependency(pkg, version) {
-    this.dependencies[pkg] = version;
-    this.reinstall = true;
-    this.rewrite = true;
-    return this;
-  }
-
-  addDependencies(modules, ctx = {}) {
-    const replacer = (match, key) => getValue(key, ctx);
-
-    Object.entries(modules).forEach(([pkg, version]) => {
-      this.addDependency(pkg, (version || "").replace("{{tsedVersion}}", ctx.tsedVersion).replace(/{{([\w.]+)}}/gi, replacer));
-    });
-    return this;
-  }
-
-  addScript(task, cmd) {
-    this.scripts[task] = cmd;
-    this.rewrite = true;
-    return this;
-  }
-
-  addScripts(scripts) {
-    Object.entries(scripts).forEach(([task, cmd]) => {
-      this.addScript(task, cmd);
-    });
-    return this;
-  }
-
-  add(key, data) {
-    this.raw[key] = data;
-    this.rewrite = true;
-    return this;
-  }
-
-  setPreference(key, value) {
-    setValue(this.raw, `${this.configuration.name}.${key}`, value);
-    this.rewrite = true;
-    return;
-  }
-
-  set(key, value) {
-    this.raw[key] = value;
-    this.rewrite = true;
-
-    if (["dependencies", "devDependencies", "peerDependencies"].includes(key)) {
-      this.reinstall = true;
-    }
-  }
-
-  get(key) {
-    return this.raw[key];
-  }
-
-  write() {
-    const originalPkg = this.getPackageJson();
-    this.rewrite = false;
-    this.raw = _extends({}, originalPkg, this.raw, {
-      scripts: _extends({}, originalPkg.scripts || {}, this.raw.scripts || {}),
-      dependencies: sortKeys(_extends({}, originalPkg.dependencies, mapPackagesWithValidVersion(this.raw.dependencies))),
-      devDependencies: sortKeys(_extends({}, originalPkg.devDependencies, mapPackagesWithValidVersion(this.raw.devDependencies))),
-      readme: undefined,
-      _id: undefined
-    });
-    this.fs.writeFileSync(this.path, JSON.stringify(this.raw, null, 2), {
-      encoding: "utf8"
-    });
-    return this;
-  }
-
-  hasYarn() {
-    try {
-      this.cliExeca.runSync(PackageManager.YARN, ["--version"]);
-      return true;
-    } catch (er) {
-      return false;
-    }
-  }
-
-  install(options = {}) {
-    const packageManager = this.getPackageManager(options.packageManager);
-    let tasks;
-
-    switch (packageManager) {
-      case "pnpm":
-        tasks = this.installWithPnpm(options);
-        break;
-
-      case "npm":
-        tasks = this.installWithNpm(options);
-        break;
-
-      default:
-        tasks = this.installWithYarn(options);
-    }
-
-    return [{
-      title: "Write package.json",
-      enabled: () => this.rewrite,
-      task: () => {
-        this.write();
-      }
-    }, ...tasks, {
-      title: "Clean",
-      task: () => {
-        this.reinstall = false;
-        this.rewrite = false;
-        this.read();
-      }
-    }];
-  }
-  /**
-   * Import a module from the project workspace
-   * @param mod
-   */
-
-
-  async importModule(mod) {
-    return this.fs.importModule(mod, this.dir);
-  }
-
-  runScript(npmTask, ignoreError = false) {
-    const options = {
-      cwd: this.dir
-    };
-
-    const errorPipe = () => catchError(error => {
-      if (ignoreError) {
-        return EMPTY;
-      }
-
-      return throwError(error);
-    });
-
-    return this.cliExeca.run(this.getPackageManager(), ["run", npmTask], options).pipe(errorPipe());
-  }
-
-  getPackageManager(packageManager) {
-    if (this.preferences.packageManager) {
-      packageManager = this.preferences.packageManager;
-    }
-
-    packageManager = packageManager || PackageManager.YARN;
-
-    if (packageManager === PackageManager.YARN && !this.hasYarn()) {
-      packageManager = PackageManager.NPM;
-    }
-
-    return packageManager;
-  }
-
-  setGhToken(GH_TOKEN) {
-    this.GH_TOKEN = GH_TOKEN;
-  }
-
-  installWithYarn({
-    verbose
-  }) {
-    const devDeps = mapPackagesWithInvalidVersion(this.devDependencies);
-    const deps = mapPackagesWithInvalidVersion(this.dependencies);
-    const options = {
-      cwd: this.dir,
-      env: _extends({}, process.env, {
-        GH_TOKEN: this.GH_TOKEN
-      })
-    };
-
-    const errorPipe = () => catchError(error => {
-      if (error.stderr.startsWith("error Your lockfile needs to be updated")) {
-        return throwError(new Error("yarn.lock file is outdated. Run yarn, commit the updated lockfile and try again."));
-      }
-
-      return throwError(error);
-    });
-
-    return [{
-      title: "Installing dependencies using Yarn",
-      skip: () => !this.reinstall,
-      task: () => this.cliExeca.run(PackageManager.YARN, ["install", "--production=false", verbose && "--verbose", "--ignore-engines"].filter(Boolean), options).pipe(errorPipe())
-    }, {
-      title: "Add dependencies using Yarn",
-      skip: () => !deps.length,
-      task: () => this.cliExeca.run(PackageManager.YARN, ["add", verbose && "--verbose", "--ignore-engines", ...deps].filter(Boolean), options).pipe(errorPipe())
-    }, {
-      title: "Add devDependencies using Yarn",
-      skip: () => !devDeps.length,
-      task: () => this.cliExeca.run(PackageManager.YARN, ["add", "-D", verbose && "--verbose", "--ignore-engines", ...devDeps].filter(Boolean), options).pipe(errorPipe())
-    }];
-  }
-
-  installWithNpm({
-    verbose
-  }) {
-    const devDeps = mapPackagesWithInvalidVersion(this.devDependencies);
-    const deps = mapPackagesWithInvalidVersion(this.dependencies);
-    const options = {
-      cwd: this.dir,
-      env: _extends({}, process.env, {
-        GH_TOKEN: this.GH_TOKEN
-      })
-    };
-    return [{
-      title: "Installing dependencies using npm",
-      skip: () => {
-        return !this.reinstall;
-      },
-      task: () => {
-        return this.cliExeca.run(PackageManager.NPM, ["install", "--no-production", "--legacy-peer-deps", verbose && "--verbose"].filter(Boolean), options);
-      }
-    }, {
-      title: "Add dependencies using npm",
-      skip: () => !deps.length,
-      task: () => this.cliExeca.run(PackageManager.NPM, ["install", "--save", "--legacy-peer-deps", verbose && "--verbose", ...deps].filter(Boolean), options)
-    }, {
-      title: "Add devDependencies using npm",
-      skip: () => !devDeps.length,
-      task: () => this.cliExeca.run(PackageManager.NPM, ["install", "--save-dev", "--legacy-peer-deps", verbose && "--verbose", ...devDeps].filter(Boolean), options)
-    }];
-  }
-
-  installWithPnpm({
-    verbose
-  }) {
-    const devDeps = mapPackagesWithInvalidVersion(this.devDependencies);
-    const deps = mapPackagesWithInvalidVersion(this.dependencies);
-    const options = {
-      cwd: this.dir,
-      env: _extends({}, process.env, {
-        GH_TOKEN: this.GH_TOKEN
-      })
-    };
-    return [{
-      title: "Installing dependencies using pnpm",
-      skip: () => {
-        return !this.reinstall;
-      },
-      task: () => this.cliExeca.run(PackageManager.PNPM, ["install", "--dev", verbose && "--verbose"].filter(Boolean), options)
-    }, {
-      title: "Add dependencies using pnpm",
-      skip: () => !deps.length,
-      task: () => this.cliExeca.run(PackageManager.PNPM, ["add", "--save-prod", verbose && "--verbose", ...deps].filter(Boolean), options)
-    }, {
-      title: "Add devDependencies using pnpm",
-      skip: () => !devDeps.length,
-      task: () => this.cliExeca.run(PackageManager.PNPM, ["add", "--save-dev", verbose && "--verbose", ...devDeps].filter(Boolean), options)
-    }];
-  }
-
-  getPackageJson() {
-    return getPackageJson(this.configuration);
-  }
-
-};
-
-__decorate([Inject(CliExeca), __metadata("design:type", CliExeca)], ProjectPackageJson.prototype, "cliExeca", void 0);
-
-__decorate([Inject(CliFs), __metadata("design:type", CliFs)], ProjectPackageJson.prototype, "fs", void 0);
-
-ProjectPackageJson = __decorate([Injectable(), __param(0, Configuration()), __metadata("design:paramtypes", [Object])], ProjectPackageJson);
-
-let logger;
-function getLogger() {
-  return logger;
-}
-
-function createConfiguration(injector) {
-  injector.addProvider(CliConfiguration);
-  return injector.invoke(CliConfiguration);
-}
-
-function createInjector(settings = {}) {
-  const injector = new InjectorService();
-  injector.settings = createConfiguration(injector);
-  logger = injector.logger = new Logger(settings.name || "CLI");
-  injector.addProvider(ProjectPackageJson);
-  injector.settings.set(settings);
-  /* istanbul ignore next */
-
-  if (injector.settings.env === "test") {
-    injector.logger.stop();
-  } else {
-    var _injector$settings$lo;
-
-    /* istanbul ignore next */
-    injector.logger.level = ((_injector$settings$lo = injector.settings.logger) == null ? void 0 : _injector$settings$lo.level) || "error";
-  }
-
-  return injector;
-}
-
-class CustomLogger extends Logger$1 {
-  fail(message) {
-    var _getLogger;
-
-    (_getLogger = getLogger()) == null ? void 0 : _getLogger.error("[FAIL]", message);
-  }
-
-  skip(message) {
-    var _getLogger2;
-
-    (_getLogger2 = getLogger()) == null ? void 0 : _getLogger2.info("[SKIP]", message);
-  }
-
-  success(message) {
-    var _getLogger3;
-
-    (_getLogger3 = getLogger()) == null ? void 0 : _getLogger3.info("[SUCCESS]", message);
-  }
-
-  data(message) {
-    var _getLogger4;
-
-    (_getLogger4 = getLogger()) == null ? void 0 : _getLogger4.info("[DATA]", message);
-  }
-
-  start(message) {
-    var _getLogger5;
-
-    (_getLogger5 = getLogger()) == null ? void 0 : _getLogger5.info("[START]", message);
-  }
-
-  title(message) {
-    var _getLogger6;
-
-    (_getLogger6 = getLogger()) == null ? void 0 : _getLogger6.info("[TITLE]", message);
-  }
-
-  retry(message) {
-    var _getLogger7;
-
-    (_getLogger7 = getLogger()) == null ? void 0 : _getLogger7.info("[RETRY]", message);
-  }
-
-  rollback(message) {
-    var _getLogger8;
-
-    (_getLogger8 = getLogger()) == null ? void 0 : _getLogger8.info("[ROLLBACK]", message);
-  }
-
-}
-
-function getOptions(ctx) {
-  const useRawRenderer = !(!ctx.verbose && !process.env.CI);
-  const rendererOptions = useRawRenderer ? {
-    logger: CustomLogger
-  } : {};
-  return _extends({}, ctx, {
-    rendererSilent: process.env.NODE_ENV === "test",
-    rendererFallback: useRawRenderer,
-    renderer: useRawRenderer ? "verbose" : "default",
-    nonTTYRendererOptions: rendererOptions,
-    rendererOptions
-  });
-}
-
-function createTasks(tasks, ctx) {
-  return new Listr(tasks, getOptions(ctx));
-}
-function createSubTasks(tasks, opts) {
-  opts = getOptions(opts);
-  return async (ctx, task) => {
-    if (isFunction(tasks)) {
-      tasks = await tasks(ctx, task);
-    }
-
-    return task.newListr(tasks, opts);
-  };
-}
-function createTasksRunner(tasks, ctx) {
-  return createTasks(tasks, ctx).run(ctx);
-}
-
-function getCommandMetadata(token) {
-  var _Store$from;
-
-  const {
-    name,
-    alias,
-    args = {},
-    allowUnknownOption,
-    description,
-    options = {}
-  } = (_Store$from = Store.from(token)) == null ? void 0 : _Store$from.get(CommandStoreKeys.COMMAND);
-  return {
-    name,
-    alias,
-    args,
-    description,
-    options,
-    allowUnknownOption: !!allowUnknownOption
-  };
-}
-
-function mapValue(value, {
-  type,
-  itemType
-}) {
-  if (!value) {
-    return value;
-  }
-
-  switch (type) {
-    case String:
-      value = String(value);
-      break;
-
-    case Number:
-      value = parseFloat(value);
-      break;
-
-    case Boolean:
-      value = value === "true";
-      break;
-
-    case Array:
-      value = String(value).split(",").map(value => mapValue(value, {
-        type: itemType
-      }));
-      break;
-  }
-
-  return value;
-}
-
-function mapCommanderArgs(args, commandArgs) {
-  commandArgs = commandArgs.filter(arg => !isClass(arg)).filter(arg => !isArray(arg));
-  let index = 0;
-  return Object.entries(args).reduce((options, [arg, {
-    defaultValue,
-    type,
-    itemType
-  }]) => {
-    const value = commandArgs[index] || defaultValue;
-    index++;
-    return _extends({}, options, {
-      [arg]: mapValue(value, {
-        type,
-        itemType
-      })
-    });
-  }, {});
-}
-
-function mapCommanderOptions(commands) {
-  const options = {};
-  commands.forEach(command => {
-    Object.entries(command.opts()).filter(([key]) => !key.startsWith("_") && !["commands", "options", "parent", "rawArgs", "args"].includes(key)).forEach(([key, value]) => {
-      options[key] = value;
-    });
-  });
-  return options;
-}
-
-function parseOption(value, options) {
-  const {
-    type,
-    itemType,
-    customParser
-  } = options;
-
-  if (type) {
-    switch (type) {
-      case String:
-        value = String(value);
-        break;
-
-      case Boolean:
-        // the flag is added
-        return true;
-
-      case Number:
-        value = +value;
-        break;
-
-      case Array:
-        value = value.split(",").map(value => parseOption(value, {
-          type: itemType,
-          customParser
-        }));
-        break;
-    }
-  }
-
-  if (options.customParser) {
-    value = options.customParser(value);
-  }
-
-  return value;
-}
-
-let CliHooks = class CliHooks {
-  constructor() {
-    this.injector = void 0;
-  }
-
-  async emit(hookName, cmd, ...args) {
-    const providers = this.injector.getProviders();
-    let results = [];
-
-    for (const provider of providers) {
-      if (provider.useClass) {
-        const instance = this.injector.get(provider.token);
-
-        if (provider.store.has(hookName)) {
-          const props = provider.store.get(hookName)[cmd];
-
-          if (props) {
-            for (const propertyKey of props) {
-              results = results.concat(await instance[propertyKey](...args));
-            }
-          }
-        }
-      }
-    }
-
-    return results.filter(o => o !== undefined);
-  }
-
-};
-
-__decorate([Inject(), __metadata("design:type", InjectorService)], CliHooks.prototype, "injector", void 0);
-
-CliHooks = __decorate([Injectable()], CliHooks);
-
-const _excluded$2 = ["description", "required", "customParser", "defaultValue"];
-Inquirer.registerPrompt("autocomplete", require("inquirer-autocomplete-prompt"));
-let CliService = class CliService {
-  constructor() {
-    this.program = new Command$1();
-    this.reinstallAfterRun = false;
-    this.pkg = void 0;
-    this.injector = void 0;
-    this.hooks = void 0;
-    this.projectPkg = void 0;
-    this.commands = new Map();
-  }
-
-  $onInit() {
-    if (this.injector.logger.level !== "off") {
-      this.injector.logger.appenders.set("stdout", {
-        type: "stdout",
-        layout: {
-          type: "pattern",
-          pattern: "[%d{hh:mm:ss}] %m"
-        },
-        levels: ["info", "debug"]
-      }).set("stderr", {
-        type: "stderr",
-        layout: {
-          type: "pattern",
-          pattern: "[%d{hh:mm:ss}][%p] %m"
-        },
-        levels: ["trace", "fatal", "error", "warn"]
-      });
-    }
-  }
-  /**
-   * Parse process.argv and runLifecycle action
-   * @param argv
-   */
-
-
-  async parseArgs(argv) {
-    const {
-      program
-    } = this;
-    program.version(this.pkg.version);
-    this.load();
-    await program.parseAsync(argv);
-  }
-  /**
-   * Run lifecycle
-   * @param cmdName
-   * @param data
-   */
-
-
-  async runLifecycle(cmdName, data = {}) {
-    data = await this.beforePrompt(cmdName, data);
-    data = await this.prompt(cmdName, data);
-
-    try {
-      await this.exec(cmdName, data);
-    } catch (er) {
-      await this.injector.emit("$onFinish", er);
-      await this.injector.destroy();
-      throw er;
-    }
-
-    await this.injector.emit("$onFinish");
-    await this.injector.destroy();
-  }
-
-  async exec(cmdName, ctx) {
-    const initialTasks = await this.getTasks(cmdName, ctx);
-
-    if (initialTasks.length) {
-      const tasks = [...initialTasks, {
-        title: "Install dependencies",
-        enabled: () => this.reinstallAfterRun && (this.projectPkg.rewrite || this.projectPkg.reinstall),
-        task: createSubTasks(() => this.projectPkg.install(ctx), _extends({}, ctx, {
-          concurrent: false
-        }))
-      }, ...(await this.getPostInstallTasks(cmdName, ctx))];
-      return createTasksRunner(tasks, this.mapContext(cmdName, ctx));
-    }
-  }
-  /**
-   * Run prompt for a given command
-   * @param cmdName
-   * @param ctx Initial data
-   */
-
-
-  async beforePrompt(cmdName, ctx = {}) {
-    const provider = this.commands.get(cmdName);
-    const instance = this.injector.get(provider.useClass);
-    const verbose = ctx.verbose;
-
-    if (instance.$beforePrompt) {
-      ctx = await instance.$beforePrompt(JSON.parse(JSON.stringify(ctx)));
-      ctx.verbose = verbose;
-    }
-
-    return ctx;
-  }
-  /**
-   * Run prompt for a given command
-   * @param cmdName
-   * @param ctx Initial data
-   */
-
-
-  async prompt(cmdName, ctx = {}) {
-    const provider = this.commands.get(cmdName);
-    const instance = this.injector.get(provider.useClass);
-
-    if (instance.$prompt) {
-      const questions = [...(await instance.$prompt(ctx)), ...(await this.hooks.emit(CommandStoreKeys.PROMPT_HOOKS, cmdName, ctx))];
-
-      if (questions.length) {
-        ctx = _extends({}, ctx, await Inquirer.prompt(questions));
-      }
-    }
-
-    return ctx;
-  }
-  /**
-   * Run lifecycle
-   * @param cmdName
-   * @param ctx
-   */
-
-
-  async getTasks(cmdName, ctx) {
-    const provider = this.commands.get(cmdName);
-    const instance = this.injector.get(provider.token);
-    ctx = this.mapContext(cmdName, ctx);
-
-    if (instance.$beforeExec) {
-      await instance.$beforeExec(ctx);
-    }
-
-    return [...(await instance.$exec(ctx)), ...(await this.hooks.emit(CommandStoreKeys.EXEC_HOOKS, cmdName, ctx))];
-  }
-
-  async getPostInstallTasks(cmdName, ctx) {
-    const provider = this.commands.get(cmdName);
-    const instance = this.injector.get(provider.useClass);
-    ctx = this.mapContext(cmdName, ctx);
-    return [...(instance.$postInstall ? await instance.$postInstall(ctx) : []), ...(await this.hooks.emit(CommandStoreKeys.POST_INSTALL_HOOKS, cmdName, ctx))];
-  }
-
-  createCommand(metadata) {
-    const {
-      args,
-      name,
-      options,
-      description,
-      alias,
-      allowUnknownOption
-    } = metadata;
-
-    if (this.commands.has(name)) {
-      return this.commands.get(name).command;
-    }
-
-    let cmd = this.program.command(name);
-
-    const onAction = (...commanderArgs) => {
-      const [, ...rawArgs] = cmd.args;
-
-      const data = _extends({
-        verbose: !!this.program.opts().verbose
-      }, mapCommanderArgs(args, commanderArgs), mapCommanderOptions(this.program.commands), {
-        rawArgs
-      });
-
-      return this.runLifecycle(name, data);
-    };
-
-    if (alias) {
-      cmd = cmd.alias(alias);
-    }
-
-    cmd = cmd.description(description);
-    cmd = this.buildArguments(cmd, args);
-    cmd = cmd.action(onAction);
-
-    if (options) {
-      cmd = this.buildOption(cmd, options, !!allowUnknownOption);
-    }
-
-    return cmd;
-  }
-
-  load() {
-    this.injector.getProviders(PROVIDER_TYPE_COMMAND).forEach(provider => this.build(provider));
-  }
-
-  mapContext(cmdName, ctx) {
-    const provider = this.commands.get(cmdName);
-    const instance = this.injector.get(provider.useClass);
-    const verbose = ctx.verbose;
-
-    if (instance.$mapContext) {
-      ctx = instance.$mapContext(JSON.parse(JSON.stringify(ctx)));
-      ctx.verbose = verbose;
-    }
-
-    if (ctx.verbose) {
-      this.injector.logger.level = "debug";
-    } else {
-      this.injector.logger.level = "info";
-    }
-
-    return ctx;
-  }
-  /**
-   * Build command and sub-commands
-   * @param provider
-   */
-
-
-  build(provider) {
-    const metadata = getCommandMetadata(provider.useClass);
-
-    if (metadata.name) {
-      if (this.commands.has(metadata.name)) {
-        throw Error(`The ${metadata.name} command is already registered. Change your command name used by the class ${classOf(provider.useClass)}`);
-      }
-
-      provider.command = this.createCommand(metadata);
-      this.commands.set(metadata.name, provider);
-    }
-  }
-  /**
-   * Build sub-command options
-   * @param subCommand
-   * @param options
-   * @param allowUnknownOptions
-   */
-
-
-  buildOption(subCommand, options, allowUnknownOptions) {
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    Object.entries(options).reduce((subCommand, [flags, _ref]) => {
-      let {
-        description,
-        required,
-        defaultValue
-      } = _ref,
-          options = _objectWithoutPropertiesLoose(_ref, _excluded$2);
-
-      const fn = v => parseOption(v, options);
-
-      if (options.type === Boolean) {
-        defaultValue = false;
-      }
-
-      return required ? subCommand.requiredOption(flags, description, fn, defaultValue) : subCommand.option(flags, description, fn, defaultValue);
-    }, subCommand);
-    subCommand.option("-r, --root-dir <path>", "Project root directory");
-    subCommand.option("--verbose", "Verbose mode", () => true);
-
-    if (allowUnknownOptions) {
-      subCommand.allowUnknownOption(true);
-    }
-
-    return subCommand;
-  }
-
-  buildArguments(cmd, args) {
-    return Object.entries(args).reduce((cmd, [key, {
-      description,
-      required,
-      defaultValue
-    }]) => {
-      const argument = new Argument(required ? `<${key}>` : `[${key}]`, description);
-
-      if (defaultValue !== undefined) {
-        argument.default(defaultValue);
-      }
-
-      return cmd.addArgument(argument);
-    }, cmd);
-  }
-
-};
-
-__decorate([Constant("project.reinstallAfterRun", false), __metadata("design:type", Object)], CliService.prototype, "reinstallAfterRun", void 0);
-
-__decorate([Constant("pkg", {
-  version: "1.0.0"
-}), __metadata("design:type", Object)], CliService.prototype, "pkg", void 0);
-
-__decorate([Inject(), __metadata("design:type", InjectorService)], CliService.prototype, "injector", void 0);
-
-__decorate([Inject(), __metadata("design:type", CliHooks)], CliService.prototype, "hooks", void 0);
-
-__decorate([Inject(), __metadata("design:type", ProjectPackageJson)], CliService.prototype, "projectPkg", void 0);
-
-CliService = __decorate([Injectable()], CliService);
-
-function CliPackageJson() {
-  return Inject(CliPackageJson);
-}
-registerProvider({
-  provide: CliPackageJson,
-  deps: [Configuration],
-
-  useFactory(configuration) {
-    return configuration.pkg || {};
-  }
-
-});
-
-function cast(value) {
-  if (["undefined"].includes(value)) {
-    return undefined;
-  }
-
-  if (["null"].includes(value)) {
-    return null;
-  }
-
-  if (["false"].includes(value)) {
-    return false;
-  }
-
-  if (["true"].includes(value)) {
-    return false;
-  }
-
-  return value;
-}
-
-let CliProxyAgent = class CliProxyAgent {
-  constructor() {
-    this.proxySettings = void 0;
-    this.cliExeca = void 0;
-  }
-
-  hasProxy() {
-    return !!this.proxySettings.url;
-  }
-
-  get(type) {
-    if (this.hasProxy()) {
-      const {
-        strictSsl = true
-      } = this.proxySettings;
-      const url = new URL(this.proxySettings.url);
-      const protocol = url.protocol.replace(":", "");
-      const options = {
-        proxy: {
-          host: url.hostname,
-          port: url.port ? +url.port : undefined,
-          proxyAuth: url.username && url.password ? `${url.username}:${url.password}` : undefined,
-          rejectUnauthorized: strictSsl
-        }
-      };
-      const method = camelCase([type, "over", protocol].join(" "));
-
-      if (tunnel[method]) {
-        return tunnel[method](options);
-      }
-    }
-
-    return null;
-  }
-
-  async resolveProxySettings() {
-    if (this.hasProxy()) {
-      return;
-    }
-
-    const result = await Promise.all([this.cliExeca.getAsync("npm", ["config", "get", "proxy"]), this.cliExeca.getAsync("npm", ["config", "get", "http-proxy"]), this.cliExeca.getAsync("npm", ["config", "get", "https-proxy"]), this.cliExeca.getAsync("npm", ["config", "get", "strict-ssl"])]);
-    const [proxy, httpProxy, httpsProxy, strictSsl] = result.map(cast);
-    const url = httpsProxy || httpProxy || proxy;
-
-    if (url) {
-      this.proxySettings = {
-        url,
-        strictSsl: cast(strictSsl) !== false
-      };
-    }
-  }
-
-};
-
-__decorate([Value("proxy", {}), __metadata("design:type", Object)], CliProxyAgent.prototype, "proxySettings", void 0);
-
-__decorate([Inject(), __metadata("design:type", CliExeca)], CliProxyAgent.prototype, "cliExeca", void 0);
-
-CliProxyAgent = __decorate([Injectable(), Configuration({
-  proxy: {
-    url: process.env.HTTPS_PROXY || process.env.HTTP_PROXY,
-    strictSsl: process.env.NODE_TLS_REJECT_UNAUTHORIZED !== undefined ? process.env.NODE_TLS_REJECT_UNAUTHORIZED !== "0" : true
-  }
-})], CliProxyAgent);
-
-function logToCurl({
-  url,
-  method,
-  params,
-  query,
-  data,
-  headers = {}
-}) {
-  const request = parse(url, true);
-
-  if (params) {
-    request.set("query", Object.assign(params, query));
-  }
-
-  let curl = `curl -X ${method.toUpperCase()} '${request.toString()}'`;
-
-  if (data) {
-    curl += ` -d '${JSON.stringify(data)}'`;
-  }
-
-  curl += Object.entries(headers).reduce((curlHeaders, [key, value]) => `${curlHeaders} -H '${key}: ${value}'`, "");
-  return curl;
-}
-
-let CliHttpLogClient = class CliHttpLogClient {
-  constructor(options = {}) {
-    this.callee = void 0;
-    this.logger = void 0;
-    this.callee = options.callee || "http";
-  }
-
-  onSuccess(options) {
-    return this.logger.debug(_extends({}, this.formatLog(options), {
-      status: "OK"
-    }));
-  }
-
-  onError(error, options) {
-    const origin = this.errorMapper(error);
-    this.logger.warn(_extends({}, this.formatLog(options), {
-      status: "KO",
-      callee_code: origin.code,
-      callee_error: origin.message,
-      callee_request_qs: options.params && querystring.stringify(options.params),
-      callee_request_headers: options.headers,
-      callee_request_body: options.data && JSON.stringify(options.data),
-      callee_response_headers: origin.headers,
-      callee_response_body: origin.body && JSON.stringify(origin.body),
-      callee_response_request_id: origin.x_request_id,
-      curl: this.logToCurl(options)
-    }));
-  }
-
-  logToCurl(options) {
-    return logToCurl(options);
-  }
-
-  getStatusCodeFromError(error) {
-    return getValue(error, "response.status", getValue(error, "response.statusCode", getValue(error, "status")));
-  }
-
-  getHeadersFromError(error) {
-    return getValue(error, "response.headers", getValue(error, "headers"));
-  }
-
-  getResponseBodyFromError(error) {
-    return getValue(error, "response.data", getValue(error, "data"));
-  }
-
-  formatLog(options) {
-    const {
-      startTime,
-      url,
-      method
-    } = options;
-    const {
-      callee
-    } = this;
-    const duration = new Date().getTime() - startTime;
-    return {
-      callee,
-      url,
-      method,
-      callee_qs: options.params && querystring.stringify(options.params),
-      duration: isNaN(duration) ? undefined : duration
-    };
-  }
-
-  errorMapper(error) {
-    const statusCode = this.getStatusCodeFromError(error);
-    const headers = this.getHeadersFromError(error);
-    const body = this.getResponseBodyFromError(error);
-    return {
-      message: error.message || statusCode,
-      code: statusCode,
-      headers,
-      body,
-      x_request_id: getValue(error, "response.headers.x-request-id", getValue(error, "headers.x-request-id"))
-    };
-  }
-
-};
-
-__decorate([Inject(), __metadata("design:type", Logger)], CliHttpLogClient.prototype, "logger", void 0);
-
-CliHttpLogClient = __decorate([__param(0, Opts), __metadata("design:paramtypes", [Object])], CliHttpLogClient);
-
-var CliHttpClient_1;
-let CliHttpClient = CliHttpClient_1 = class CliHttpClient extends CliHttpLogClient {
-  constructor(...args) {
-    super(...args);
-    this.cliProxyAgent = void 0;
-    this.host = void 0;
-  }
-
-  static getParamsSerializer(params) {
-    return stringify(cleanObject(params));
-  }
-
-  async $onInit() {
-    await this.cliProxyAgent.resolveProxySettings();
-  }
-
-  async head(endpoint, options = {}) {
-    const {
-      headers
-    } = await axios(this.getRequestParameters("HEAD", endpoint, options));
-    return headers;
-  }
-
-  async get(endpoint, options = {}) {
-    const result = await this.send(this.getRequestParameters("GET", endpoint, options));
-    return this.mapResponse(result, options);
-  }
-
-  async post(endpoint, options = {}) {
-    const result = await this.send(this.getRequestParameters("POST", endpoint, options));
-    return this.mapResponse(result, options);
-  }
-
-  async put(endpoint, options = {}) {
-    const result = await this.send(this.getRequestParameters("PUT", endpoint, options));
-    return this.mapResponse(result, options);
-  }
-
-  async patch(endpoint, options = {}) {
-    const result = await this.send(this.getRequestParameters("PATCH", endpoint, options));
-    return this.mapResponse(result, options);
-  }
-
-  async delete(endpoint, options = {}) {
-    const result = await this.send(this.getRequestParameters("DELETE", endpoint, options));
-    return this.mapResponse(result, options);
-  }
-
-  getRequestParameters(method, endpoint, options) {
-    options = _extends({
-      method,
-      url: (this.host || "") + endpoint.replace(this.host || "", "")
-    }, options, {
-      params: options.params || options.qs,
-      data: options.data,
-      headers: _extends({
-        "Content-Type": "application/json",
-        Accept: "application/json"
-      }, options.headers || {})
-    });
-    this.configureProxy(endpoint, options);
-    return options;
-  }
-
-  configureProxy(endpoint, options) {
-    const url = new URL(endpoint);
-
-    if (this.cliProxyAgent.hasProxy()) {
-      const protocol = url.protocol.replace(":", "");
-
-      switch (protocol) {
-        case "https":
-          options.httpsAgent = this.cliProxyAgent.get(protocol);
-          options.proxy = false;
-          break;
-
-        case "http":
-          options.httpAgent = this.cliProxyAgent.get(protocol);
-          options.proxy = false;
-          break;
-      }
-    }
-  }
-
-  async send(options) {
-    const startTime = new Date().getTime();
-
-    try {
-      const response = await axios(_extends({
-        paramsSerializer: CliHttpClient_1.getParamsSerializer
-      }, options));
-      this.onSuccess(_extends({
-        startTime
-      }, options));
-      return response;
-    } catch (error) {
-      this.onError(error, _extends({
-        startTime
-      }, options));
-      throw error;
-    }
-  }
-
-  mapResponse(result, options) {
-    const {
-      withHeaders
-    } = options;
-    const data = !withHeaders ? result == null ? void 0 : result.data : result;
-    return withHeaders ? {
-      data,
-      headers: result == null ? void 0 : result.headers
-    } : data;
-  }
-
-};
-
-__decorate([Inject(), __metadata("design:type", CliProxyAgent)], CliHttpClient.prototype, "cliProxyAgent", void 0);
-
-CliHttpClient = CliHttpClient_1 = __decorate([Injectable()], CliHttpClient);
-
-const all = promises => Promise.all(promises);
-
-async function loadPlugins(injector) {
-  const name = injector.settings.get("name");
-  const rootDir = injector.settings.get("project.rootDir");
-  const projectPackageJson = injector.invoke(ProjectPackageJson);
-  const fs = injector.invoke(CliFs);
-  const promises = Object.keys(projectPackageJson.allDependencies).filter(mod => mod.startsWith(`@${name}/cli-plugin`) || mod.includes(`${name}-cli-plugin`)).map(async mod => {
-    try {
-      const {
-        default: plugin
-      } = await fs.importModule(mod, rootDir);
-
-      if (!injector.has(plugin)) {
-        var _GlobalProviders$get;
-
-        const provider = (_GlobalProviders$get = GlobalProviders.get(plugin)) == null ? void 0 : _GlobalProviders$get.clone();
-
-        if (provider != null && provider.imports.length) {
-          await all(provider.imports.map(async token => {
-            var _GlobalProviders$get2;
-
-            injector.add(token, (_GlobalProviders$get2 = GlobalProviders.get(token)) == null ? void 0 : _GlobalProviders$get2.clone());
-
-            if (injector.settings.get("loaded")) {
-              await injector.invoke(token);
-            }
-          }));
-        }
-
-        injector.add(plugin, provider);
-
-        if (injector.settings.get("loaded")) {
-          await injector.invoke(plugin);
-        }
-      }
-
-      injector.logger.info(chalk.green(figures.tick), mod, "module loaded");
-    } catch (er) {
-      injector.logger.warn(chalk.red(figures.cross), "Fail to load plugin", mod);
-    }
-  });
-  await all(promises);
-}
-
-var NpmRegistryClient_1;
-
-const HOST = require("registry-url")();
-
-const REGEX_REGISTRY_ENFORCED_HTTPS = /^https?:\/\/([^\/]+\.)?(yarnpkg\.com|npmjs\.(org|com))(\/|$)/;
-const REGEX_REGISTRY_PREFIX = /^(https?:)?\/\//i;
-function addSuffix(pattern, suffix) {
-  if (!pattern.endsWith(suffix)) {
-    return pattern + suffix;
-  }
-
-  return pattern;
-}
-const SCOPE_SEPARATOR = "%2f";
-let NpmRegistryClient = NpmRegistryClient_1 = class NpmRegistryClient {
-  constructor() {
-    this.httpClient = void 0;
-  }
-
-  static escapeName(name) {
-    // scoped packages contain slashes and the npm registry expects them to be escaped
-    return name.replace("/", SCOPE_SEPARATOR);
-  }
-
-  async request(pathname, opts = {}) {
-    const registry = opts.registry || HOST;
-    const requestUrl = this.getRequestUrl(registry, pathname);
-
-    const headers = _extends({
-      Accept: opts.unfiltered ? "application/json" : "application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*"
-    }, opts.headers);
-
-    try {
-      return await this.httpClient.get(requestUrl, _extends({}, opts, {
-        headers
-      }));
-    } catch (error) {
-      if (opts.retry) {
-        await new Promise(resolve => setTimeout(resolve, 200));
-        opts.retry -= 1;
-        opts.unfiltered = true;
-        return this.request(NpmRegistryClient_1.escapeName(pathname), opts);
-      }
-
-      throw error;
-    }
-  }
-
-  getRequestUrl(registry, pathname) {
-    let resolved = pathname;
-
-    if (!REGEX_REGISTRY_PREFIX.test(pathname)) {
-      resolved = url.resolve(addSuffix(registry, "/"), pathname);
-    }
-
-    if (REGEX_REGISTRY_ENFORCED_HTTPS.test(resolved)) {
-      resolved = resolved.replace(/^http:\/\//, "https://");
-    }
-
-    return resolved;
-  }
-  /**
-   * Search a module on npm registry
-   * @param text
-   * @param options
-   */
-
-
-  async search(text, options = {}) {
-    const {
-      objects: result
-    } = await this.request(`-/v1/search`, {
-      headers: {
-        "Accept-Encoding": "gzip"
-      },
-      qs: _extends({
-        text,
-        size: 100,
-        from: 0,
-        quality: 0.65,
-        popularity: 0.98,
-        maintenance: 0.5
-      }, options)
-    });
-    return result;
-  }
-
-  async info(packageName, retry = 0) {
-    try {
-      return await this.request(packageName, {
-        headers: {
-          "Accept-Encoding": "gzip"
-        },
-        unfiltered: false,
-        retry
-      });
-    } catch (er) {
-      return retry == 0 ? this.fallback(packageName) : null;
-    }
-  }
-
-  async fallback(packageName) {
-    const [{
-      package: pkg
-    }] = await this.search(packageName);
-    return _extends({}, pkg, {
-      "dist-tags": {
-        latest: pkg.version
-      },
-      versions: {
-        [pkg.version]: {
-          name: packageName,
-          version: pkg.version,
-          dependencies: {},
-          devDependencies: {}
-        }
-      }
-    });
-  }
-
-};
-
-__decorate([Inject(CliHttpClient), __metadata("design:type", CliHttpClient)], NpmRegistryClient.prototype, "httpClient", void 0);
-
-NpmRegistryClient = NpmRegistryClient_1 = __decorate([Injectable()], NpmRegistryClient);
-
-const _excluded$1 = ["name", "description"];
-
-function mapPlugins(_ref) {
-  let {
-    package: {
-      name,
-      description = ""
-    }
-  } = _ref,
-      otherProps = _objectWithoutPropertiesLoose(_ref.package, _excluded$1);
-
-  return _extends({
-    name: `${name} ${description}`.trim(),
-    value: name
-  }, otherProps);
-}
-
-let CliPlugins = class CliPlugins {
-  constructor() {
-    this.name = void 0;
-    this.npmRegistryClient = void 0;
-    this.injector = void 0;
-    this.cliHooks = void 0;
-    this.packageJson = void 0;
-  }
-
-  async searchPlugins(keyword = "", options = {}) {
-    const result = await this.npmRegistryClient.search(this.getKeyword(keyword), options);
-    return result.filter(({
-      package: {
-        name
-      }
-    }) => this.isPlugin(name)).map(mapPlugins);
-  }
-
-  async loadPlugins() {
-    return loadPlugins(this.injector);
-  }
-
-  addPluginsDependencies(ctx) {
-    const plugins = Object.keys(this.packageJson.devDependencies).filter(name => this.isPlugin(name));
-    const tasks = plugins.map(plugin => {
-      return {
-        title: `Run plugin '${chalk.cyan(plugin)}'`,
-        task: () => this.cliHooks.emit(CommandStoreKeys.ADD, plugin, ctx)
-      };
-    });
-    return [...tasks, {
-      title: "Install",
-      task: createSubTasks(() => this.packageJson.install(ctx), _extends({}, ctx, {
-        concurrent: false
-      }))
-    }];
-  }
-
-  getKeyword(keyword) {
-    return `@${this.name}/cli-plugin-${this.cleanKeyword(keyword)}`;
-  }
-
-  cleanKeyword(keyword) {
-    return keyword.replace(this.name, "").replace("@", "").replace("/", "").replace("cli-plugin-", "");
-  }
-
-  isPlugin(name) {
-    return name.startsWith(`@${this.name}/cli-plugin`) || name.includes(`${this.name}-cli-plugin`);
-  }
-
-};
-
-__decorate([Constant("name"), __metadata("design:type", String)], CliPlugins.prototype, "name", void 0);
-
-__decorate([Inject(), __metadata("design:type", NpmRegistryClient)], CliPlugins.prototype, "npmRegistryClient", void 0);
-
-__decorate([Inject(), __metadata("design:type", InjectorService)], CliPlugins.prototype, "injector", void 0);
-
-__decorate([Inject(), __metadata("design:type", CliHooks)], CliPlugins.prototype, "cliHooks", void 0);
-
-__decorate([Inject(), __metadata("design:type", ProjectPackageJson)], CliPlugins.prototype, "packageJson", void 0);
-
-CliPlugins = __decorate([Injectable()], CliPlugins);
-
-const runScript = require("@npmcli/run-script");
-
-let CliRunScript = class CliRunScript {
-  constructor() {
-    this.projectPackageJson = void 0;
-  }
-
-  run(cmd, args, options = {}) {
-    return runScript(_extends({
-      event: "run"
-    }, options, {
-      cmd: `${cmd} ${args.join(" ")}`,
-      path: options.cwd || this.projectPackageJson.dir,
-      env: options.env || {},
-      stdio: options.stdio || "inherit",
-      banner: false
-    }));
-  }
-
-};
-
-__decorate([Inject(), __metadata("design:type", ProjectPackageJson)], CliRunScript.prototype, "projectPackageJson", void 0);
-
-CliRunScript = __decorate([Injectable()], CliRunScript);
-
-const util$3 = require("handlebars-utils");
-
-const helpers$4 = {};
-
-const contains = (val, obj, start) => {
-  if (val == null || obj == null || !isNumber(val.length)) {
-    return false;
-  }
-
-  return val.indexOf(obj, start) !== -1;
-};
-/**
- * Helper that renders the block if **both** of the given values
- * are truthy. If an inverse block is specified it will be rendered
- * when falsy. Works as a block helper, inline helper or
- * subexpression.
- *
- * ```handlebars
- * <!-- {great: true, magnificent: true} -->
- * {{#and great magnificent}}A{{else}}B{{/and}}
- * <!-- results in: 'A' -->
- * ```
- * @param {any} `a`
- * @param {any} `b`
- * @param {Object} `options` Handlebars provided options object
- * @return {String}
- * @block
- * @api public
- */
-
-
-helpers$4.and = (...args) => {
-  const len = args.length - 1;
-  const options = args[len];
-  let val = true;
-
-  for (let i = 0; i < len; i++) {
-    if (!args[i]) {
-      val = false;
-      break;
-    }
-  }
-
-  return util$3.value(val, undefined, options);
-};
-/**
- * Render a block when a comparison of the first and third
- * arguments returns true. The second argument is
- * the [arithemetic operator][operators] to use. You may also
- * optionally specify an inverse block to render when falsy.
- *
- * @param `a`
- * @param `operator` The operator to use. Operators must be enclosed in quotes: `">"`, `"="`, `"<="`, and so on.
- * @param `b`
- * @param {Object} `options` Handlebars provided options object
- * @return {String} Block, or if specified the inverse block is rendered if falsey.
- * @block
- * @api public
- */
-
-
-helpers$4.compare = function (a, operator, b, options) {
-  /*eslint eqeqeq: 0*/
-  if (arguments.length < 4) {
-    throw new Error("handlebars Helper {{compare}} expects 4 arguments");
-  }
-
-  let result;
-
-  switch (operator) {
-    case "==":
-      result = a == b;
-      break;
-
-    case "===":
-      result = a === b;
-      break;
-
-    case "!=":
-      result = a != b;
-      break;
-
-    case "!==":
-      result = a !== b;
-      break;
-
-    case "<":
-      result = a < b;
-      break;
-
-    case ">":
-      result = a > b;
-      break;
-
-    case "<=":
-      result = a <= b;
-      break;
-
-    case ">=":
-      result = a >= b;
-      break;
-
-    case "typeof":
-      result = typeof a === b;
-      break;
-
-    default:
-      {
-        throw new Error("helper {{compare}}: invalid operator: `" + operator + "`");
-      }
-  }
-
-  return util$3.value(result, this, options);
-};
-/**
- * Block helper that renders the block if `collection` has the
- * given `value`, using strict equality (`===`) for comparison,
- * otherwise the inverse block is rendered (if specified). If a
- * `startIndex` is specified and is negative, it is used as the
- * offset from the end of the collection.
- *
- * ```handlebars
- * <!-- array = ['a', 'b', 'c'] -->
- * {{#contains array "d"}}
- *   This will not be rendered.
- * {{else}}
- *   This will be rendered.
- * {{/contains}}
- * ```
- * @param {Array|Object|String} `collection` The collection to iterate over.
- * @param {any} `value` The value to check for.
- * @param {Number} `[startIndex=0]` Optionally define the starting index.
- * @param {Object} `options` Handlebars provided options object.
- * @block
- * @api public
- */
-
-
-helpers$4.contains = function (collection, value, startIndex, options) {
-  if (typeof startIndex === "object") {
-    options = startIndex;
-    startIndex = undefined;
-  }
-
-  const val = contains(collection, value, startIndex);
-  return util$3.value(val, this, options);
-};
-/**
- * Returns the first value that is not undefined, otherwise the "default" value is returned.
- *
- * @param {any} `value`
- * @param {any} `defaultValue`
- * @return {String}
- * @alias .or
- * @api public
- */
-
-
-helpers$4.default = (...args) => {
-  for (let i = 0; i < args.length - 1; i++) {
-    if (args[i] != null) return args[i];
-  }
-
-  return "";
-};
-/**
- * Block helper that renders a block if `a` is **equal to** `b`.
- * If an inverse block is specified it will be rendered when falsy.
- * You may optionally use the `compare=""` hash argument for the
- * second value.
- *
- * @param {String} `a`
- * @param {String} `b`
- * @param {Object} `options` Handlebars provided options object
- * @return {String} Block, or inverse block if specified and falsey.
- * @alias is
- * @block
- * @api public
- */
-
-
-helpers$4.eq = function (a, b, options) {
-  if (arguments.length === 2) {
-    options = b;
-    b = options.hash.compare;
-  }
-
-  return util$3.value(a === b, this, options);
-};
-/**
- * Block helper that renders a block if `a` is **greater than** `b`.
- *
- * If an inverse block is specified it will be rendered when falsy.
- * You may optionally use the `compare=""` hash argument for the
- * second value.
- *
- * @param {String} `a`
- * @param {String} `b`
- * @param {Object} `options` Handlebars provided options object
- * @return {String} Block, or inverse block if specified and falsey.
- * @block
- * @api public
- */
-
-
-helpers$4.gt = function (a, b, options) {
-  if (arguments.length === 2) {
-    options = b;
-    b = options.hash.compare;
-  }
-
-  return util$3.value(a > b, this, options);
-};
-/**
- * Block helper that renders a block if `a` is **greater than or
- * equal to** `b`.
- *
- * If an inverse block is specified it will be rendered when falsy.
- * You may optionally use the `compare=""` hash argument for the
- * second value.
- *
- * @param {String} `a`
- * @param {String} `b`
- * @param {Object} `options` Handlebars provided options object
- * @return {String} Block, or inverse block if specified and falsey.
- * @block
- * @api public
- */
-
-
-helpers$4.gte = function (a, b, options) {
-  if (arguments.length === 2) {
-    options = b;
-    b = options.hash.compare;
-  }
-
-  return util$3.value(a >= b, this, options);
-};
-/**
- * Block helper that renders a block if `a` is **equal to** `b`.
- * If an inverse block is specified it will be rendered when falsy.
- * Similar to [eq](#eq) but does not do strict equality.
- *
- * @param {any} `a`
- * @param {any} `b`
- * @param {Object} `options` Handlebars provided options object
- * @return {String}
- * @block
- * @api public
- */
-
-
-helpers$4.is = function (a, b, options) {
-  if (arguments.length === 2) {
-    options = b;
-    b = options.hash.compare;
-  }
-
-  return util$3.value(a == b, this, options);
-};
-/**
- * Block helper that renders a block if `a` is **not equal to** `b`.
- * If an inverse block is specified it will be rendered when falsy.
- * Similar to [unlessEq](#unlesseq) but does not use strict equality for
- * comparisons.
- *
- * @param {String} `a`
- * @param {String} `b`
- * @param {Object} `options` Handlebars provided options object
- * @return {String}
- * @block
- * @api public
- */
-
-
-helpers$4.isnt = function (a, b, options) {
-  if (arguments.length === 2) {
-    options = b;
-    b = options.hash.compare;
-  }
-
-  return util$3.value(a != b, this, options);
-};
-/**
- * Block helper that renders a block if `a` is **less than** `b`.
- *
- * If an inverse block is specified it will be rendered when falsy.
- * You may optionally use the `compare=""` hash argument for the
- * second value.
- *
- * @param {Object} `context`
- * @param {Object} `options` Handlebars provided options object
- * @return {String} Block, or inverse block if specified and falsey.
- * @block
- * @api public
- */
-
-
-helpers$4.lt = function (a, b, options) {
-  if (arguments.length === 2) {
-    options = b;
-    b = options.hash.compare;
-  }
-
-  return util$3.value(a < b, this, options);
-};
-/**
- * Block helper that renders a block if `a` is **less than or
- * equal to** `b`.
- *
- * If an inverse block is specified it will be rendered when falsy.
- * You may optionally use the `compare=""` hash argument for the
- * second value.
- *
- * @param {Sring} `a`
- * @param {Sring} `b`
- * @param {Object} `options` Handlebars provided options object
- * @return {String} Block, or inverse block if specified and falsey.
- * @block
- * @api public
- */
-
-
-helpers$4.lte = function (a, b, options) {
-  if (arguments.length === 2) {
-    options = b;
-    b = options.hash.compare;
-  }
-
-  return util$3.value(a <= b, this, options);
-};
-/**
- * Block helper that renders a block if **neither of** the given values
- * are truthy. If an inverse block is specified it will be rendered
- * when falsy.
- *
- * @param {any} `a`
- * @param {any} `b`
- * @param `options` Handlebars options object
- * @return {String} Block, or inverse block if specified and falsey.
- * @block
- * @api public
- */
-
-
-helpers$4.neither = function (a, b, options) {
-  return util$3.value(!a && !b, this, options);
-};
-/**
- * Returns true if `val` is falsey. Works as a block or inline helper.
- *
- * @param {String} `val`
- * @param {Object} `options` Handlebars provided options object
- * @return {String}
- * @block
- * @api public
- */
-
-
-helpers$4.not = function (val, options) {
-  return util$3.value(!val, this, options);
-};
-/**
- * Block helper that renders a block if **any of** the given values
- * is truthy. If an inverse block is specified it will be rendered
- * when falsy.
- *
- * ```handlebars
- * {{#or a b c}}
- *   If any value is true this will be rendered.
- * {{/or}}
- * ```
- *
- * @param {...any} `arguments` Variable number of arguments
- * @param {Object} `options` Handlebars options object
- * @return {String} Block, or inverse block if specified and falsey.
- * @block
- * @api public
- */
-
-
-helpers$4.or = function (...args) {
-  const len = args.length - 1;
-  const options = args[len];
-  let val = false;
-
-  for (let i = 0; i < len; i++) {
-    if (args[i]) {
-      val = true;
-      break;
-    }
-  }
-
-  return util$3.value(val, this, options);
-};
-/**
- * Block helper that always renders the inverse block **unless `a` is
- * is equal to `b`**.
- *
- * @param {String} `a`
- * @param {String} `b`
- * @param {Object} `options` Handlebars provided options object
- * @return {String} Inverse block by default, or block if falsey.
- * @block
- * @api public
- */
-
-
-helpers$4.unlessEq = function (a, b, options) {
-  if (util$3.isOptions(b)) {
-    options = b;
-    b = options.hash.compare;
-  }
-
-  return util$3.value(a !== b, this, options);
-};
-/**
- * Block helper that always renders the inverse block **unless `a` is
- * is greater than `b`**.
- *
- * @param {Object} `a` The default value
- * @param {Object} `b` The value to compare
- * @param {Object} `options` Handlebars provided options object
- * @return {String} Inverse block by default, or block if falsey.
- * @block
- * @api public
- */
-
-
-helpers$4.unlessGt = function (a, b, options) {
-  if (util$3.isOptions(b)) {
-    options = b;
-    b = options.hash.compare;
-  }
-
-  return util$3.value(a <= b, this, options);
-};
-/**
- * Block helper that always renders the inverse block **unless `a` is
- * is less than `b`**.
- *
- * @param {Object} `a` The default value
- * @param {Object} `b` The value to compare
- * @param {Object} `options` Handlebars provided options object
- * @return {String} Block, or inverse block if specified and falsey.
- * @block
- * @api public
- */
-
-
-helpers$4.unlessLt = function (a, b, options) {
-  if (util$3.isOptions(b)) {
-    options = b;
-    b = options.hash.compare;
-  }
-
-  return util$3.value(a >= b, this, options);
-};
-/**
- * Block helper that always renders the inverse block **unless `a` is
- * is greater than or equal to `b`**.
- *
- * @param {any} `a`
- * @param {any} `b`
- * @param {Object} `options` Handlebars provided options object
- * @return {String} Block, or inverse block if specified and falsey.
- * @block
- * @api public
- */
-
-
-helpers$4.unlessGteq = function (a, b, options) {
-  if (util$3.isOptions(b)) {
-    options = b;
-    b = options.hash.compare;
-  }
-
-  return util$3.value(a < b, this, options);
-};
-/**
- * Block helper that always renders the inverse block **unless `a` is
- * is less than or equal to `b`**.
- *
- * @param {any} `a`
- * @param {any} `b`
- * @param {Object} `options` Handlebars provided options object
- * @return {String} Block, or inverse block if specified and falsey.
- * @block
- * @api public
- */
-
-
-helpers$4.unlessLteq = function (a, b, options) {
-  if (util$3.isOptions(b)) {
-    options = b;
-    b = options.hash.compare;
-  }
-
-  return util$3.value(a > b, this, options);
-};
-
-const createFrame$1 = require("create-frame");
-
-const util$2 = require("handlebars-utils");
-
-const helpers$3 = {};
-/**
- * Returns all of the items in an array after the specified index.
- * Opposite of [before](#before).
- *
- * ```handlebars
- * <!-- array: ['a', 'b', 'c'] -->
- * {{after array 1}}
- * <!-- results in: '["c"]' -->
- * ```
- * @param {Array} `array` Collection
- * @param {Number} `n` Starting index (number of items to exclude)
- * @return {Array} Array exluding `n` items.
- * @api public
- */
-
-helpers$3.after = function (array, n) {
-  if (util$2.isUndefined(array)) return "";
-  return array.slice(n);
-};
-/**
- * Cast the given `value` to an array.
- *
- * ```handlebars
- * {{arrayify "foo"}}
- * <!-- results in: [ "foo" ] -->
- * ```
- * @param {any} `value`
- * @return {Array}
- * @api public
- */
-
-
-helpers$3.arrayify = function (value) {
-  return value ? isArray(value) ? value : [value] : [];
-};
-/**
- * Return all of the items in the collection before the specified
- * count. Opposite of [after](#after).
- *
- * ```handlebars
- * <!-- array: ['a', 'b', 'c'] -->
- * {{before array 2}}
- * <!-- results in: '["a", "b"]' -->
- * ```
- * @param {Array} `array`
- * @param {Number} `n`
- * @return {Array} Array excluding items after the given number.
- * @api public
- */
-
-
-helpers$3.before = function (array, n) {
-  if (util$2.isUndefined(array)) return "";
-  return array.slice(0, -n);
-};
-/**
- * ```handlebars
- * <!-- array: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'] -->
- * {{#eachIndex array}}
- *   {{item}} is {{index}}
- * {{/eachIndex}}
- * ```
- * @param {Array} `array`
- * @param {Object} `options`
- * @return {String}
- * @block
- * @api public
- */
-
-
-helpers$3.eachIndex = function (array, options) {
-  let result = "";
-
-  for (let i = 0; i < array.length; i++) {
-    result += options.fn({
-      item: array[i],
-      index: i
-    });
-  }
-
-  return result;
-};
-/**
- * Block helper that filters the given array and renders the block for values that
- * evaluate to `true`, otherwise the inverse block is returned.
- *
- * ```handlebars
- * <!-- array: ['a', 'b', 'c'] -->
- * {{#filter array "foo"}}AAA{{else}}BBB{{/filter}}
- * <!-- results in: 'BBB' -->
- * ```
- * @param {Array} `array`
- * @param {any} `value`
- * @param {Object} `options`
- * @return {String}
- * @block
- * @api public
- */
-
-
-helpers$3.filter = function (array, value, options) {
-  let content = "";
-  let results = []; // filter on a specific property
-
-  const prop = options.hash && (options.hash.property || options.hash.prop);
-
-  if (prop) {
-    results = array.filter(function (val) {
-      return value === getValue(val, prop);
-    });
-  } else {
-    // filter on a string value
-    results = array.filter(function (v) {
-      return value === v;
-    });
-  }
-
-  if (results && results.length > 0) {
-    for (let i = 0; i < results.length; i++) {
-      content += options.fn(results[i]);
-    }
-
-    return content;
-  }
-
-  return options.inverse(this);
-};
-/**
- * Returns the first item, or first `n` items of an array.
- *
- * ```handlebars
- * {{first "['a', 'b', 'c', 'd', 'e']" 2}}
- * <!-- results in: '["a", "b"]' -->
- * ```
- * @param {Array} `array`
- * @param {Number} `n` Number of items to return, starting at `0`.
- * @return {Array}
- * @api public
- */
-
-
-helpers$3.first = function (array, n) {
-  if (array === undefined) return "";
-
-  if (!isNumber(n)) {
-    return array[0];
-  }
-
-  return array.slice(0, n);
-};
-/**
- * Iterates over each item in an array and exposes the current item
- * in the array as context to the inner block. In addition to
- * the current array item, the helper exposes the following variables
- * to the inner block:
- *
- * - `index`
- * - `total`
- * - `isFirst`
- * - `isLast`
- *
- * Also, `@index` is exposed as a private variable, and additional
- * private variables may be defined as hash arguments.
- *
- * ```handlebars
- * <!-- accounts = [
- *   {'name': 'John', 'email': 'john@example.com'},
- *   {'name': 'Malcolm', 'email': 'malcolm@example.com'},
- *   {'name': 'David', 'email': 'david@example.com'}
- * ] -->
- *
- * {{#forEach accounts}}
- *   <a href="mailto:{{ email }}" title="Send an email to {{ name }}">
- *     {{ name }}
- *   </a>{{#unless isLast}}, {{/unless}}
- * {{/forEach}}
- * ```
- * @source <http://stackoverflow.com/questions/13861007>
- * @param {Array} `array`
- * @return {String}
- * @block
- * @api public
- */
-
-
-helpers$3.forEach = function (array, options) {
-  const data = createFrame$1(options, options.hash);
-  const len = array.length;
-  let buffer = "";
-  let i = -1;
-
-  while (++i < len) {
-    const item = array[i];
-    data.index = i;
-    item.index = i + 1;
-    item.total = len;
-    item.isFirst = i === 0;
-    item.isLast = i === len - 1;
-    buffer += options.fn(item, {
-      data: data
-    });
-  }
-
-  return buffer;
-};
-/**
- * Block helper that renders the block if an array has the
- * given `value`. Optionally specify an inverse block to render
- * when the array does not have the given value.
- *
- * ```handlebars
- * <!-- array: ['a', 'b', 'c'] -->
- * {{#inArray array "d"}}
- *   foo
- * {{else}}
- *   bar
- * {{/inArray}}
- * <!-- results in: 'bar' -->
- * ```
- * @param {Array} `array`
- * @param {any} `value`
- * @param {Object} `options`
- * @return {String}
- * @block
- * @api public
- */
-
-
-helpers$3.inArray = function (array, value, options) {
-  return util$2.value(util$2.indexOf(array, value) > -1, this, options);
-};
-/**
- * Returns true if `value` is an es5 array.
- *
- * ```handlebars
- * {{isArray "abc"}}
- * <!-- results in: false -->
- *
- * <!-- array: [1, 2, 3] -->
- * {{isArray array}}
- * <!-- results in: true -->
- * ```
- * @param {any} `value` The value to test.
- * @return {Boolean}
- * @api public
- */
-
-
-helpers$3.isArray = function (value) {
-  return Array.isArray(value);
-};
-/**
- * Returns the item from `array` at index `idx`.
- *
- * ```handlebars
- * <!-- array: ['a', 'b', 'c'] -->
- * {{itemAt array 1}}
- * <!-- results in: 'b' -->
- * ```
- * @param {Array} `array`
- * @param {Number} `idx`
- * @return {any} `value`
- * @block
- * @api public
- */
-
-
-helpers$3.itemAt = function (array, idx) {
-  array = util$2.result(array);
-
-  if (isArray(array)) {
-    idx = isNumber(idx) ? +idx : 0;
-
-    if (idx < 0) {
-      return array[array.length + idx];
-    }
-
-    if (idx < array.length) {
-      return array[idx];
-    }
-  }
-};
-/**
- * Join all elements of array into a string, optionally using a
- * given separator.
- *
- * ```handlebars
- * <!-- array: ['a', 'b', 'c'] -->
- * {{join array}}
- * <!-- results in: 'a, b, c' -->
- *
- * {{join array '-'}}
- * <!-- results in: 'a-b-c' -->
- * ```
- * @param {Array} `array`
- * @param {String} `separator` The separator to use. Defaults to `, `.
- * @return {String}
- * @api public
- */
-
-
-helpers$3.join = function (array, separator) {
-  if (isString(array)) return array;
-  if (!isArray(array)) return "";
-  separator = util$2.isString(separator) ? separator : ", ";
-  return array.join(separator);
-};
-/**
- * Returns true if the the length of the given `value` is equal
- * to the given `length`. Can be used as a block or inline helper.
- *
- * @param {Array|String} `value`
- * @param {Number} `length`
- * @param {Object} `options`
- * @return {String}
- * @block
- * @api public
- */
-
-
-helpers$3.equalsLength = function (value, length, options) {
-  if (util$2.isOptions(length)) {
-    options = length;
-    length = 0;
-  }
-
-  let len = 0;
-
-  if (typeof value === "string" || Array.isArray(value)) {
-    len = value.length;
-  }
-
-  return util$2.value(len === length, this, options);
-};
-/**
- * Returns the last item, or last `n` items of an array or string.
- * Opposite of [first](#first).
- *
- * ```handlebars
- * <!-- var value = ['a', 'b', 'c', 'd', 'e'] -->
- *
- * {{last value}}
- * <!-- results in: ['e'] -->
- *
- * {{last value 2}}
- * <!-- results in: ['d', 'e'] -->
- *
- * {{last value 3}}
- * <!-- results in: ['c', 'd', 'e'] -->
- * ```
- * @param {Array|String} `value` Array or string.
- * @param {Number} `n` Number of items to return from the end of the array.
- * @return {Array}
- * @api public
- */
-
-
-helpers$3.last = function (value, n) {
-  if (!isArray(value) && typeof value !== "string") {
-    return "";
-  }
-
-  if (!isNumber(n)) {
-    return value[value.length - 1];
-  }
-
-  return value.slice(-Math.abs(n));
-};
-/**
- * Returns the length of the given string or array.
- *
- * ```handlebars
- * {{length '["a", "b", "c"]'}}
- * <!-- results in: 3 -->
- *
- * <!-- results in: myArray = ['a', 'b', 'c', 'd', 'e']; -->
- * {{length myArray}}
- * <!-- results in: 5 -->
- *
- * <!-- results in: myObject = {'a': 'a', 'b': 'b'}; -->
- * {{length myObject}}
- * <!-- results in: 2 -->
- * ```
- * @param {Array|Object|String} `value`
- * @return {Number} The length of the value.
- * @api public
- */
-
-
-helpers$3.length = function (value) {
-  if (isObject(value) && !util$2.isOptions(value)) {
-    value = Object.keys(value);
-  }
-
-  if (typeof value === "string" || Array.isArray(value)) {
-    return value.length;
-  }
-
-  return 0;
-};
-/**
- * Returns a new array, created by calling `function` on each
- * element of the given `array`. For example,
- *
- * ```handlebars
- * <!-- array: ['a', 'b', 'c'], and "double" is a
- * fictitious function that duplicates letters -->
- * {{map array double}}
- * <!-- results in: '["aa", "bb", "cc"]' -->
- * ```
- *
- * @param {Array} `array`
- * @param {Function} `fn`
- * @return {String}
- * @api public
- */
-
-
-helpers$3.map = function (array, iter) {
-  if (!Array.isArray(array)) return "";
-  const len = array.length;
-  const res = new Array(len);
-  let i = -1;
-
-  if (typeof iter !== "function") {
-    return array;
-  }
-
-  while (++i < len) {
-    res[i] = iter(array[i], i, array);
-  }
-
-  return res;
-};
-/**
- * Map over the given object or array or objects and create an array of values
- * from the given `prop`. Dot-notation may be used (as a string) to get
- * nested properties.
- *
- * ```handlebars
- * // {{pluck items "data.title"}}
- * <!-- results in: '["aa", "bb", "cc"]' -->
- * ```
- * @param {Array|Object} `collection`
- * @param {Function} `prop`
- * @return {String}
- * @api public
- */
-
-
-helpers$3.pluck = function (arr, prop) {
-  if (util$2.isUndefined(arr)) return "";
-  const res = [];
-
-  for (let i = 0; i < arr.length; i++) {
-    const val = getValue(arr[i], prop);
-
-    if (typeof val !== "undefined") {
-      res.push(val);
-    }
-  }
-
-  return res;
-};
-/**
- * Reverse the elements in an array, or the characters in a string.
- *
- * ```handlebars
- * <!-- value: 'abcd' -->
- * {{reverse value}}
- * <!-- results in: 'dcba' -->
- * <!-- value: ['a', 'b', 'c', 'd'] -->
- * {{reverse value}}
- * <!-- results in: ['d', 'c', 'b', 'a'] -->
- * ```
- * @param {Array|String} `value`
- * @return {Array|String} Returns the reversed string or array.
- * @api public
- */
-
-
-helpers$3.reverse = function (val) {
-  if (Array.isArray(val)) {
-    val.reverse();
-    return val;
-  }
-
-  if (val && isString(val)) {
-    return val.split("").reverse().join("");
-  }
-};
-/**
- * Block helper that returns the block if the callback returns true
- * for some value in the given array.
- *
- * ```handlebars
- * <!-- array: [1, 'b', 3] -->
- * {{#some array isString}}
- *   Render me if the array has a string.
- * {{else}}
- *   Render me if it doesn't.
- * {{/some}}
- * <!-- results in: 'Render me if the array has a string.' -->
- * ```
- * @param {Array} `array`
- * @param {Function} `iter` Iteratee
- * @param {Options} Handlebars provided options object
- * @return {String}
- * @block
- * @api public
- */
-
-
-helpers$3.some = function (array, iter, options) {
-  if (Array.isArray(array)) {
-    for (let i = 0; i < array.length; i++) {
-      if (iter(array[i], i, array)) {
-        return options.fn(this);
-      }
-    }
-  }
-
-  return options.inverse(this);
-};
-/**
- * Sort the given `array`. If an array of objects is passed,
- * you may optionally pass a `key` to sort on as the second
- * argument. You may alternatively pass a sorting function as
- * the second argument.
- *
- * ```handlebars
- * <!-- array: ['b', 'a', 'c'] -->
- * {{sort array}}
- * <!-- results in: '["a", "b", "c"]' -->
- * ```
- *
- * @param {Array} `array` the array to sort.
- * @param {String|Function} `key` The object key to sort by, or sorting function.
- * @api public
- */
-
-
-helpers$3.sort = function (array, options) {
-  if (!Array.isArray(array)) return "";
-
-  if (getValue(options, "hash.reverse")) {
-    return array.sort().reverse();
-  }
-
-  return array.sort();
-};
-/**
- * Block helper that return an array with all duplicate
- * values removed. Best used along with a [each](#each) helper.
- *
- * ```handlebars
- * <!-- array: ['a', 'a', 'c', 'b', 'e', 'e'] -->
- * {{#each (unique array)}}{{.}}{{/each}}
- * <!-- results in: 'acbe' -->
- * ```
- * @param {Array} `array`
- * @param {Object} `options`
- * @return {Array}
- * @api public
- */
-
-
-helpers$3.unique = function (array) {
-  if (util$2.isUndefined(array)) return "";
-  return array.filter(function (item, index, arr) {
-    return arr.indexOf(item) === index;
-  });
-};
-
-const hasOwn = Object.hasOwnProperty;
-
-const util$1 = require("handlebars-utils");
-
-const createFrame = require("create-frame");
-
-const helpers$2 = {};
-/**
- * Extend the context with the properties of other objects.
- * A shallow merge is performed to avoid mutating the context.
- *
- * @param {Object} `objects` One or more objects to extend.
- * @return {Object}
- * @api public
- */
-
-helpers$2.extend = function ()
-/*objects*/
-{
-  // eslint-disable-next-line prefer-rest-params
-  const args = [].slice.call(arguments);
-  let opts = {};
-
-  if (util$1.isOptions(args[args.length - 1])) {
-    // remove handlebars options object
-    opts = args.pop().hash; // re-add handlebars options.hash object
-
-    args.push(opts);
-  }
-
-  const context = {};
-
-  for (let i = 0; i < args.length; i++) {
-    const obj = args[i];
-
-    if (util$1.isObject(obj)) {
-      const keys = Object.keys(obj);
-
-      for (let j = 0; j < keys.length; j++) {
-        const key = keys[j];
-        context[key] = obj[key];
-      }
-    }
-  }
-
-  return context;
-};
-/**
- * Block helper that iterates over the properties of
- * an object, exposing each key and value on the context.
- *
- * @param {Object} `context`
- * @param {Object} `options`
- * @return {String}
- * @block
- * @api public
- */
-
-
-helpers$2.forIn = function (obj, options) {
-  if (!util$1.isOptions(options)) {
-    return obj.inverse(this);
-  }
-
-  const data = createFrame(options, options.hash);
-  let result = "";
-
-  for (const key in obj) {
-    data.key = key;
-    result += options.fn(obj[key], {
-      data: data
-    });
-  }
-
-  return result;
-};
-/**
- * Block helper that iterates over the **own** properties of
- * an object, exposing each key and value on the context.
- *
- * @param {Object} `obj` The object to iterate over.
- * @param {Object} `options`
- * @return {String}
- * @block
- * @api public
- */
-
-
-helpers$2.forOwn = function (obj, options) {
-  if (!util$1.isOptions(options)) {
-    return obj.inverse(this);
-  }
-
-  const data = createFrame(options, options.hash);
-  let result = "";
-
-  for (const key in obj) {
-    if (obj.hasOwnProperty(key)) {
-      data.key = key;
-      result += options.fn(obj[key], {
-        data: data
-      });
-    }
-  }
-
-  return result;
-};
-/**
- * Take arguments and, if they are string or number, convert them to a dot-delineated object property path.
- *
- * @param {String|Number} `prop` The property segments to assemble (can be multiple).
- * @return {String}
- * @api public
- */
-
-
-helpers$2.toPath = function (...args) {
-  const prop = [];
-
-  for (let i = 0; i < arguments.length; i++) {
-    if (typeof args[i] === "string" || typeof args[i] === "number") {
-      prop.push(args[i]);
-    }
-  }
-
-  return prop.join(".");
-};
-/**
- * Use property paths (`a.b.c`) to get a value or nested value from
- * the context. Works as a regular helper or block helper.
- *
- * @param {String} `prop` The property to get, optionally using dot notation for nested properties.
- * @param {Object} `context` The context object
- * @param {Object} `options` The handlebars options object, if used as a block helper.
- * @return {String}
- * @block
- * @api public
- */
-
-
-helpers$2.get = function (prop, context, options) {
-  const val = getValue(context, prop);
-
-  if (options && options.fn) {
-    return val ? options.fn(val) : options.inverse(context);
-  }
-
-  return val;
-};
-/**
- * Return true if `key` is an own, enumerable property
- * of the given `context` object.
- *
- * ```handlebars
- * {{hasOwn context key}}
- * ```
- *
- * @param {String} `key`
- * @param {Object} `context` The context object.
- * @return {Boolean}
- * @api public
- */
-
-
-helpers$2.hasOwn = function (context, key) {
-  return hasOwn.call(context, key);
-};
-/**
- * Return true if `value` is an object.
- *
- * ```handlebars
- * {{isObject "foo"}}
- * //=> false
- * ```
- * @param {String} `value`
- * @return {Boolean}
- * @api public
- */
-
-
-helpers$2.isObject = isObject;
-/**
- * Parses the given string using `JSON.parse`.
- *
- * ```handlebars
- * <!-- string: '{"foo": "bar"}' -->
- * {{JSONparse string}}
- * <!-- results in: { foo: 'bar' } -->
- * ```
- * @param {String} `string` The string to parse
- * @contributor github.com/keeganstreet
- * @block
- * @api public
- */
-
-helpers$2.JSONparse = function (str) {
-  return JSON.parse(str);
-};
-/**
- * Stringify an object using `JSON.stringify`.
- *
- * ```handlebars
- * <!-- object: { foo: 'bar' } -->
- * {{JSONstringify object}}
- * <!-- results in: '{"foo": "bar"}' -->
- * ```
- * @param {Object} `obj` Object to stringify
- * @return {String}
- * @api public
- */
-
-
-helpers$2.JSONstringify = function (obj, indent) {
-  if (!isNumber(indent)) {
-    indent = 0;
-  }
-
-  return JSON.stringify(obj, null, indent);
-};
-/**
- * Deeply merge the properties of the given `objects` with the
- * context object.
- *
- * @param {Object} `object` The target object. Pass an empty object to shallow clone.
- * @param {Object} `objects`
- * @return {Object}
- * @api public
- */
-
-
-helpers$2.merge = function (...args1) {
-  // eslint-disable-next-line prefer-rest-params
-  const args = [].slice.call(args1);
-  let opts = {};
-
-  if (util$1.isOptions(args[args.length - 1])) {
-    // remove handlebars options object
-    opts = args.pop().hash; // re-add options.hash
-
-    args.push(opts);
-  }
-
-  return Object.assign.apply(null, args);
-};
-/**
- * Alias for parseJSON. this will be
- * deprecated in a future release
- */
-
-
-helpers$2.parseJSON = helpers$2.JSONparse;
-/**
- * Pick properties from the context object.
- *
- * @param {Array|String} `properties` One or more properties to pick.
- * @param {Object} `context`
- * @param {Object} `options` Handlebars options object.
- * @return {Object} Returns an object with the picked values. If used as a block helper, the values are passed as context to the inner block. If no values are found, the context is passed to the inverse block.
- * @block
- * @api public
- */
-
-helpers$2.pick = function (props, context, options) {
-  const keys = helpers$3.arrayify(props);
-  const len = keys.length;
-  let i = -1;
-  let result = {};
-
-  while (++i < len) {
-    result = helpers$2.extend({}, result, getValue(context, keys[i]));
-  }
-
-  if (options.fn) {
-    if (Object.keys(result).length) {
-      return options.fn(result);
-    }
-
-    return options.inverse(context);
-  }
-
-  return result;
-};
-/**
- * Alias for JSONstringify. this will be
- * deprecated in a future release
- */
-
-
-helpers$2.stringify = helpers$2.JSONstringify;
-
-const util = require("handlebars-utils");
-const forEach = helpers$3.forEach;
-const forOwn = helpers$2.forOwn;
-const helpers$1 = {};
-/**
- * Inline, subexpression, or block helper that returns true (or the block)
- * if the given collection is empty, or false (or the inverse block, if
- * supplied) if the colleciton is not empty.
- *
- * ```handlebars
- * <!-- array: [] -->
- * {{#isEmpty array}}AAA{{else}}BBB{{/isEmpty}}
- * <!-- results in: 'AAA' -->
- *
- * <!-- array: [] -->
- * {{isEmpty array}}
- * <!-- results in: true -->
- * ```
- * @param {Object} `collection`
- * @param {Object} `options`
- * @return {String}
- * @block
- * @api public
- */
-
-helpers$1.isEmpty = function (collection, options) {
-  if (!util.isOptions(options)) {
-    options = collection;
-    return util.fn(true, this, options);
-  }
-
-  if (Array.isArray(collection) && !collection.length) {
-    return util.fn(true, this, options);
-  }
-
-  const keys = Object.keys(collection);
-  const isEmpty = typeof collection === "object" && !keys.length;
-  return util.value(isEmpty, this, options);
-};
-/**
- * Block helper that iterates over an array or object. If
- * an array is given, `.forEach` is called, or if an object
- * is given, `.forOwn` is called, otherwise the inverse block
- * is returned.
- *
- * @param {Object|Array} `collection` The collection to iterate over
- * @param {Object} `options`
- * @return {String}
- * @block
- * @api public
- */
-
-
-helpers$1.iterate = function (collection, options) {
-  if (Array.isArray(collection)) {
-    return forEach.apply(null, [collection, options]);
-  }
-
-  if (util.isObject(collection)) {
-    return forOwn.apply(null, [collection, options]);
-  }
-
-  return options.inverse(this);
-};
-
-const helpers = {};
-
-helpers.switch = function (value, options) {
-  this.switch_value = value;
-  return options.fn(this);
-};
-
-helpers.case = function (value, options) {
-  if (value == this.switch_value) {
-    return options.fn(this);
-  }
-};
-
-handlebars.registerHelper(helpers$3);
-handlebars.registerHelper(helpers$2);
-handlebars.registerHelper(helpers$1);
-handlebars.registerHelper(helpers$4);
-handlebars.registerHelper(helpers);
-
-function insertImport(fileContent, content) {
-  const lines = fileContent.split("\n");
-  const index = lines.findIndex(line => {
-    if (line.startsWith("#!")) {
-      return false;
-    }
-
-    return !line.startsWith("import ");
-  });
-  lines[index] = content + "\n" + lines[index];
-  return lines.join("\n");
-}
-
-function insertAfter(fileContent, content, pattern) {
-  const lines = fileContent.split("\n");
-  const index = lines.findIndex(line => {
-    return line.match(pattern);
-  });
-  const indent = lines[index].replace(lines[index].trim(), "");
-  lines[index] = lines[index] + "\n" + indent + content;
-
-  if (!["]", "}"].includes(lines[index + 1].trim()) && lines[index - 1].slice(-1) === ",") {
-    lines[index] += ",";
-  }
-
-  return lines.join("\n");
-}
-
-const _excluded = ["path"];
-
-const normalizePath = require("normalize-path");
-
-class Renderer {
-  constructor() {
-    this.configuration = void 0;
-    this.templateDir = void 0;
-    this.fs = void 0;
-  }
-
-  async render(path, data, options = {}) {
-    const {
-      output,
-      templateDir,
-      rootDir
-    } = this.mapOptions(path, options);
-    let content = "";
-    const file = normalizePath(join(templateDir, path));
-
-    if (path.endsWith(".hbs")) {
-      content = await Consolidate.handlebars(file, data);
-    } else {
-      content = await this.fs.readFile(file, {
-        encoding: "utf8"
-      });
-    }
-
-    return this.write(content, {
-      output,
-      rootDir
-    });
-  }
-
-  async renderAll(paths, data, options = {}) {
-    var _this = this;
-
-    let count = 0;
-
-    const mapOptions = opts => {
-      if (isString(opts)) {
-        return _extends({}, options, {
-          path: opts
-        });
-      }
-
-      return _extends({}, options, opts);
-    };
-
-    return new Observable(observer => {
-      observer.next(`[${count}/${paths.length}] Rendering files...`);
-      const promises = paths.filter(Boolean).map(mapOptions).map(async function (_ref) {
-        let {
-          path
-        } = _ref,
-            opts = _objectWithoutPropertiesLoose(_ref, _excluded);
-
-        await _this.render(path, data, opts);
-        count++;
-        observer.next(`[${count}/${paths.length}] Rendering files...`);
-      });
-      Promise.all(promises).then(() => {
-        observer.next(`[${count}/${paths.length}] Rendering files...`);
-        observer.complete();
-      }).catch(err => {
-        observer.error(err);
-      });
-    });
-  }
-
-  async write(content, options) {
-    const {
-      output,
-      rootDir = this.rootDir
-    } = options;
-    const outputFile = join(...[rootDir, output].filter(Boolean));
-    await this.fs.ensureDir(dirname(outputFile));
-    return this.fs.writeFile(outputFile, content, {
-      encoding: "utf8"
-    });
-  }
-
-  templateExists(path, options = {}) {
-    const {
-      templateDir
-    } = this.mapOptions(path, options);
-    return existsSync(join(templateDir, path));
-  }
-
-  scan(pattern, options = {}) {
-    return globby(pattern.map(s => normalizePath(s)), _extends({}, options, {
-      cwd: this.rootDir
-    }));
-  }
-
-  relativeFrom(path) {
-    return relative(dirname(join(this.rootDir, path)), this.rootDir);
-  }
-
-  async update(path, actions) {
-    path = join(this.rootDir, path);
-
-    if (!this.fs.exists(path)) {
-      return;
-    }
-
-    const content = actions.reduce((fileContent, action) => {
-      switch (action.type) {
-        case "import":
-          return insertImport(fileContent, action.content);
-
-        case "insert-after":
-          return insertAfter(fileContent, action.content, action.pattern);
-      }
-
-      return fileContent;
-    }, await this.fs.readFile(path, {
-      encoding: "utf8"
-    }));
-    return this.fs.writeFile(path, content, {
-      encoding: "utf8"
-    });
-  }
-
-  mapOptions(path, options) {
-    const {
-      templateDir = this.templateDir,
-      rootDir = this.rootDir
-    } = options;
-    let {
-      output = path
-    } = options;
-
-    if (options.baseDir) {
-      output = normalizePath(join("/", relative(options.baseDir, path)));
-    }
-
-    if (options.basename) {
-      output = normalizePath(join(dirname(output), options.basename));
-    }
-
-    output = output.replace(/\.hbs$/, "");
-    return {
-      output,
-      templateDir,
-      rootDir
-    };
-  }
-
-}
-
-__decorate([Configuration(), __metadata("design:type", Object)], Renderer.prototype, "configuration", void 0);
-
-__decorate([Constant("templateDir"), __metadata("design:type", String)], Renderer.prototype, "templateDir", void 0);
-
-__decorate([Inject(), __metadata("design:type", CliFs)], Renderer.prototype, "fs", void 0);
-
-let RootRendererService = class RootRendererService extends Renderer {
-  get rootDir() {
-    var _this$configuration$p;
-
-    return (_this$configuration$p = this.configuration.project) == null ? void 0 : _this$configuration$p.rootDir;
-  }
-
-};
-RootRendererService = __decorate([Injectable()], RootRendererService);
-let SrcRendererService = class SrcRendererService extends Renderer {
-  get rootDir() {
-    var _this$configuration$p2, _this$configuration$p3;
-
-    return join(...[(_this$configuration$p2 = this.configuration.project) == null ? void 0 : _this$configuration$p2.rootDir, (_this$configuration$p3 = this.configuration.project) == null ? void 0 : _this$configuration$p3.srcDir].filter(Boolean));
-  }
-
-};
-SrcRendererService = __decorate([Injectable()], SrcRendererService);
-let ScriptsRendererService = class ScriptsRendererService extends Renderer {
-  get rootDir() {
-    var _this$configuration$p4, _this$configuration$p5;
-
-    return join(...[(_this$configuration$p4 = this.configuration.project) == null ? void 0 : _this$configuration$p4.rootDir, (_this$configuration$p5 = this.configuration.project) == null ? void 0 : _this$configuration$p5.scriptsDir].filter(Boolean));
-  }
-
-};
-ScriptsRendererService = __decorate([Injectable()], ScriptsRendererService);
-
-let CliYaml = class CliYaml {
-  constructor() {
-    this.projectPackageJson = void 0;
-    this.fs = void 0;
-  }
-
-  async read(path) {
-    const file = !this.fs.exists(path) ? this.fs.findUpFile(this.projectPackageJson.dir, path) : path;
-
-    if (file) {
-      const content = await this.fs.readFile(file, {
-        encoding: "utf8"
-      });
-      return JsYaml.load(content);
-    }
-
-    return {};
-  }
-
-  async write(path, obj) {
-    const content = JsYaml.dump(obj);
-    const file = this.fs.findUpFile(this.projectPackageJson.dir, path) || join(this.projectPackageJson.dir, path);
-    return this.fs.writeFile(file, content, {
-      encoding: "utf8"
-    });
-  }
-
-};
-
-__decorate([Inject(), __metadata("design:type", ProjectPackageJson)], CliYaml.prototype, "projectPackageJson", void 0);
-
-__decorate([Inject(), __metadata("design:type", CliFs)], CliYaml.prototype, "fs", void 0);
-
-CliYaml = __decorate([Injectable()], CliYaml);
-
-let CliDockerComposeYaml = class CliDockerComposeYaml {
-  constructor() {
-    this.cliYaml = void 0;
-  }
-
-  async read() {
-    return this.cliYaml.read("docker-compose.yml");
-  }
-
-  async write(obj) {
-    return this.cliYaml.write("docker-compose.yml", obj);
-  }
-
-  async addDatabaseService(name, database) {
-    const dockerCompose = await this.read();
-
-    if (dockerCompose) {
-      let value;
-
-      switch (database) {
-        case "mysql":
-        case "mariadb":
-          value = {
-            image: database === "mysql" ? "mysql:8.0.28-oracle" : "mariadb:10.7.3",
-            ports: ["3306:3306"],
-            environment: {
-              MYSQL_ROOT_PASSWORD: "admin",
-              MYSQL_USER: "test",
-              MYSQL_PASSWORD: "test",
-              MYSQL_DATABASE: "test"
-            }
-          };
-          break;
-
-        case "postgres":
-          value = {
-            image: "postgres:9.6.1",
-            ports: ["5432:5432"],
-            environment: {
-              POSTGRES_USER: "test",
-              POSTGRES_PASSWORD: "test",
-              POSTGRES_DB: "test"
-            }
-          };
-          break;
-
-        case "cockroachdb":
-          value = {
-            image: "cockroachdb/cockroach:v2.1.4",
-            command: "start --insecure",
-            ports: ["26257:26257"]
-          };
-          break;
-
-        case "mssql":
-          value = {
-            image: "mcr.microsoft.com/mssql/server:2017-latest",
-            command: "start --insecure",
-            ports: ["1433:1433"],
-            environment: {
-              SA_PASSWORD: "Admin12345",
-              ACCEPT_EULA: "Y"
-            }
-          };
-          break;
-
-        case "mongodb":
-          value = {
-            image: "mongo:4.1",
-            ports: ["27017:27017"]
-          };
-          break;
-      }
-
-      setValue(dockerCompose, `services.${snakeCase(name)}`, value);
-      await this.write(dockerCompose);
-    }
-  }
-
-};
-
-__decorate([Inject(), __metadata("design:type", CliYaml)], CliDockerComposeYaml.prototype, "cliYaml", void 0);
-
-CliDockerComposeYaml = __decorate([Injectable()], CliDockerComposeYaml);
-
-class CliError extends Error {
-  constructor({
-    cli,
-    origin
-  }) {
-    super(origin.message);
-    this.name = "CLI_ERROR";
-    this.cli = void 0;
-    this.origin = void 0;
-    this.cli = cli;
-    this.origin = origin;
-    this.stack = origin.stack;
-  }
-
-}
-
-var CliCore_1;
-
-const semver = require("semver");
-
-function isHelpManual(argv) {
-  return argv.includes("-h") || argv.includes("--help");
-}
-
-let CliCore = CliCore_1 = class CliCore {
-  constructor() {
-    this.injector = void 0;
-    this.cliService = void 0;
-  }
-
-  static checkNodeVersion(wanted, id) {
-    if (!semver.satisfies(process.version, wanted)) {
-      console.log(chalk.red("You are using Node " + process.version + ", but this version of " + id + " requires Node " + wanted + ".\nPlease upgrade your Node version."));
-      process.exit(1);
-    }
-
-    return this;
-  }
-
-  static async bootstrap(settings, module = CliCore_1) {
-    const injector = this.createInjector(settings);
-    settings.plugins && (await loadPlugins(injector));
-    await this.loadInjector(injector, module);
-    await injector.emit("$onReady");
-    const cli = injector.get(CliCore_1);
-
-    try {
-      await cli.cliService.parseArgs(injector.settings.get("argv"));
-    } catch (er) {
-      throw new CliError({
-        origin: er,
-        cli
-      });
-    }
-
-    return cli;
-  }
-
-  static async loadInjector(injector, module = CliCore_1) {
-    await injector.emit("$beforeInit");
-    const container = createContainer();
-    await injector.load(container, module);
-    await injector.emit("$afterInit");
-    injector.settings.set("loaded", true);
-  }
-
-  static updateNotifier(pkg) {
-    updateNotifier({
-      pkg,
-      updateCheckInterval: 0
-    }).notify();
-    return this;
-  }
-
-  static createInjector(settings) {
-    const argv = settings.argv || process.argv;
-    return createInjector(_extends({}, settings, {
-      name: settings.name || "tsed",
-      argv,
-      project: _extends({
-        rootDir: this.getProjectRoot(argv),
-        srcDir: "src",
-        scriptsDir: "scripts"
-      }, settings.project || {})
-    }));
-  }
-
-  static getProjectRoot(argv) {
-    if (!isHelpManual(argv)) {
-      const projectRoot = new Command$1().option("-r, --root-dir <path>", "Project root directory").allowUnknownOption(true).parse(argv).opts().rootDir || "";
-      return resolve(join(process.cwd(), projectRoot));
-    }
-
-    return process.cwd();
-  }
-
-};
-
-__decorate([Inject(), __metadata("design:type", InjectorService)], CliCore.prototype, "injector", void 0);
-
-__decorate([Inject(), __metadata("design:type", CliService)], CliCore.prototype, "cliService", void 0);
-
-CliCore = CliCore_1 = __decorate([Module({
-  imports: [CliPackageJson, ProjectPackageJson, CliService, CliConfiguration]
-})], CliCore);
-
-function at(n) {
-  // ToInteger() abstract op
-  n = Math.trunc(n) || 0; // Allow negative indexing from the end
-
-  if (n < 0) n += this.length; // OOB access is guaranteed to return undefined
-
-  if (n < 0 || n >= this.length) return undefined; // Otherwise, this is just normal property access
-
-  return this[n];
-}
-
-const TypedArray = Reflect.getPrototypeOf(Int8Array);
-
-for (const C of [Array, String, TypedArray]) {
-  if (C) {
-    Object.defineProperty(C.prototype, "at", {
-      value: at,
-      writable: true,
-      enumerable: false,
-      configurable: true
-    });
-  }
-}
-
-const helpInformation = Command$1.prototype.helpInformation;
-
-function colorizeSection(str, section) {
-  // eslint-disable-next-line prefer-const
-  let [before, after] = str.split(section);
-  after = after.split("\n").map(line => {
-    if (!line.match(/(\w+):$/)) {
-      const [cmd, ...rest] = line.trim().split(" ");
-
-      if (!cmd.startsWith("-")) {
-        return [" ", chalk.bold(chalk.blue(cmd)), ...rest].join(" ");
-      }
-    }
-
-    return line;
-  }).join("\n");
-  return [before, after].join(chalk.green(section));
-}
-
-Command$1.prototype.helpInformation = function help() {
-  let str = helpInformation.call(this);
-
-  if (str.includes("Commands:")) {
-    str = colorizeSection(str, "Commands:");
-  }
-
-  if (str.includes("Arguments:")) {
-    str = colorizeSection(str, "Arguments:");
-  }
-
-  return "\n" + str.replace("Usage:", chalk.green("Usage:")).replace("Options:", chalk.green("Options:")).replace(/<(\w+)>/gi, `<${chalk.yellow("$1")}>`).replace(/\[(\w+)]/gi, `[${chalk.cyan("$1")}]`) + "\n";
-};
-
-export { CliConfiguration, CliCore, CliDockerComposeYaml, CliExeca, CliFs, CliHttpClient, CliPackageJson, CliPlugins, CliRunScript, CliService, CliYaml, Command, NpmRegistryClient, OnAdd, OnExec, OnPostInstall, OnPrompt, PackageManager, ProjectPackageJson, Renderer, RootRendererService, SCOPE_SEPARATOR, ScriptsRendererService, SrcRendererService, addSuffix, createInjector, createSubTasks, createTasks, createTasksRunner, getCommandMetadata, getLogger, getPackageJson, loadPlugins, logToCurl, mapCommanderArgs, mapCommanderOptions, normalizePath$1 as normalizePath, parseOption };
-//# sourceMappingURL=index.modern.js.map