@cenk1cenk2/oclif-common 3.9.8 → 3.9.10

package/dist/index.js

@@ -1,22 +1,1298 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var src_exports = {};
-module.exports = __toCommonJS(src_exports);
-__reExport(src_exports, require("./commands"), module.exports);
-__reExport(src_exports, require("./constants"), module.exports);
-__reExport(src_exports, require("./hooks"), module.exports);
-__reExport(src_exports, require("./interfaces"), module.exports);
-__reExport(src_exports, require("./lib"), module.exports);
-__reExport(src_exports, require("./utils"), module.exports);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw new Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/commands/base.command.ts
+var _core = require('@oclif/core');
+var _listr2 = require('listr2');
+var _readline = require('readline');
+require('reflect-metadata');
+
+// src/constants/file.constants.ts
+var FileConstants = /* @__PURE__ */ ((FileConstants2) => {
+  FileConstants2["CONFIG_SERVICE_DEFAULTS_DIR"] = "config";
+  return FileConstants2;
+})(FileConstants || {});
+
+// src/constants/help-groups.constants.ts
+var HelpGroups = /* @__PURE__ */ ((HelpGroups2) => {
+  HelpGroups2["CLI"] = "CLI";
+  return HelpGroups2;
+})(HelpGroups || {});
+
+// src/interfaces/oclif.interface.ts
+
+
+// src/utils/logger/listr-logger.ts
+
+
+// src/utils/logger/logger.ts
+
+var _os = require('os');
+var _winston = require('winston'); var _winston2 = _interopRequireDefault(_winston);
+
+// src/utils/logger/logger.constants.ts
+var LogLevels = /* @__PURE__ */ ((LogLevels2) => {
+  LogLevels2["SILENT"] = "SILENT";
+  LogLevels2["DIRECT"] = "DIRECT";
+  LogLevels2["FATAL"] = "FATAL";
+  LogLevels2["ERROR"] = "ERROR";
+  LogLevels2["WARN"] = "WARN";
+  LogLevels2["INFO"] = "INFO";
+  LogLevels2["VERBOSE"] = "VERBOSE";
+  LogLevels2["DEBUG"] = "DEBUG";
+  LogLevels2["TRACE"] = "TRACE";
+  return LogLevels2;
+})(LogLevels || {});
+var LogFieldStatus = /* @__PURE__ */ ((LogFieldStatus2) => {
+  LogFieldStatus2["RUN"] = "run";
+  LogFieldStatus2["END"] = "end";
+  LogFieldStatus2["STAGE"] = "stage";
+  LogFieldStatus2["EXIT"] = "exit";
+  LogFieldStatus2["TERMINATE"] = "terminate";
+  return LogFieldStatus2;
+})(LogFieldStatus || {});
+
+// src/lib/config/config.service.ts
+var _objectpathimmutable = require('object-path-immutable'); var _objectpathimmutable2 = _interopRequireDefault(_objectpathimmutable);
+var _path = require('path');
+
+// src/lib/parser/env-parser.service.ts
+
+var _EnvironmentVariableParser = class {
+  constructor() {
+    this.LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
+    if (_EnvironmentVariableParser.instance) {
+      return _EnvironmentVariableParser.instance;
+    }
+    _EnvironmentVariableParser.instance = this;
+    this.logger = new Logger(this.constructor.name);
+    this.logger.trace("Created a new instance.");
+  }
+  parse(data) {
+    try {
+      return data.toString().split(_os.EOL).reduce((o, line) => {
+        const match = this.LINE.exec(line);
+        const key = match[1];
+        const value = _nullishCoalesce(match[2], () => ( ""));
+        return {
+          ...o,
+          [key]: value
+        };
+      }, {});
+    } catch (e) {
+      this.logger.trace("Error during parsing environment file: %s", e.message);
+      throw e;
+    }
+  }
+  stringify(data) {
+    return Object.entries(data).map(([k, v]) => `${k}=${v}`).join(_os.EOL) + _os.EOL;
+  }
+};
+var EnvironmentVariableParser = _EnvironmentVariableParser;
+__name(EnvironmentVariableParser, "EnvironmentVariableParser");
+EnvironmentVariableParser.extensions = ["env"];
+
+// src/lib/parser/json-parser.service.ts
+var _JsonParser = class {
+  constructor() {
+    if (_JsonParser.instance) {
+      return _JsonParser.instance;
+    }
+    _JsonParser.instance = this;
+    this.logger = new Logger(this.constructor.name);
+    this.logger.trace("Created a new instance.");
+  }
+  parse(data) {
+    try {
+      return JSON.parse(data.toString());
+    } catch (e) {
+      this.logger.trace("Error during parsing JSON file: %s", e.message);
+      throw e;
+    }
+  }
+  stringify(data) {
+    return JSON.stringify(data, null, 2);
+  }
+};
+var JsonParser = _JsonParser;
+__name(JsonParser, "JsonParser");
+JsonParser.extensions = ["json"];
+
+// src/lib/parser/yaml-parser.service.ts
+var _yaml = require('yaml');
+var _YamlParser = class {
+  constructor() {
+    if (_YamlParser.instance) {
+      return _YamlParser.instance;
+    }
+    _YamlParser.instance = this;
+    this.logger = new Logger(this.constructor.name);
+    this.logger.trace("Created a new instance.");
+  }
+  parse(data) {
+    try {
+      return _yaml.parse.call(void 0, data.toString());
+    } catch (e) {
+      this.logger.trace("Error during parsing YAML file: %s", e.message);
+      throw e;
+    }
+  }
+  stringify(data) {
+    return _yaml.stringify.call(void 0, data, { prettyErrors: true });
+  }
+};
+var YamlParser = _YamlParser;
+__name(YamlParser, "YamlParser");
+YamlParser.extensions = ["yaml", "yml"];
+
+// src/lib/fs/filesystem.service.ts
+var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
+
+var FileSystemService = class {
+  constructor() {
+    if (FileSystemService.instance) {
+      return FileSystemService.instance;
+    } else {
+      FileSystemService.instance = this;
+      this.logger = new Logger(this.constructor.name);
+      this.logger.trace("Created a new instance.");
+    }
+  }
+  exists(path) {
+    return _fsextra2.default.existsSync(path);
+  }
+  stats(path) {
+    return _fsextra2.default.statSync(path, { throwIfNoEntry: true });
+  }
+  dirname(path) {
+    return _path.dirname.call(void 0, path);
+  }
+  extname(path) {
+    return _path.extname.call(void 0, path);
+  }
+  async read(file) {
+    try {
+      const raw = await _fsextra2.default.readFile(file, "utf-8");
+      return raw;
+    } catch (e) {
+      throw new Error(`Error while reading file from "${file}": ${e.message}`);
+    }
+  }
+  readSync(file) {
+    try {
+      const raw = _fsextra2.default.readFileSync(file, "utf-8");
+      return raw;
+    } catch (e) {
+      throw new Error(`Error while reading file from "${file}": ${e.message}`);
+    }
+  }
+  async write(file, data, options = {}) {
+    try {
+      await _fsextra2.default.writeFile(file, data, { encoding: "utf-8", ...options });
+    } catch (e) {
+      throw new Error(`Error while writing file to "${file}": ${e.message}`);
+    }
+  }
+  writeSync(file, data, options = {}) {
+    try {
+      _fsextra2.default.writeFileSync(file, data, { encoding: "utf-8", ...options });
+    } catch (e) {
+      throw new Error(`Error while writing file to "${file}": ${e.message}`);
+    }
+  }
+  async append(file, data, options) {
+    try {
+      await _fsextra2.default.appendFile(file, data, options);
+    } catch (e) {
+      throw new Error(`Error while appending to file  "${file}": ${e.message}`);
+    }
+  }
+  appendSync(file, data) {
+    try {
+      _fsextra2.default.appendFileSync(file, data);
+    } catch (e) {
+      throw new Error(`Error while appending to file  "${file}": ${e.message}`);
+    }
+  }
+  async remove(file, options) {
+    try {
+      await _fsextra2.default.rm(file, options);
+    } catch (e) {
+      throw new Error(`Error while deleting the file "${file}": ${e.message}`);
+    }
+  }
+  removeSync(file, options) {
+    try {
+      _fsextra2.default.rmSync(file, options);
+    } catch (e) {
+      throw new Error(`Error while deleting the file "${file}": ${e.message}`);
+    }
+  }
+  async emptyDir(directory) {
+    try {
+      await _fsextra2.default.emptyDir(directory);
+    } catch (e) {
+      throw new Error(`Error while emptying the directory "${directory}": ${e.message}`);
+    }
+  }
+  emptyDirSync(directory) {
+    try {
+      _fsextra2.default.emptyDirSync(directory);
+    } catch (e) {
+      throw new Error(`Error while emptying the directory "${directory}": ${e.message}`);
+    }
+  }
+  async removeDir(directory) {
+    try {
+      await _fsextra2.default.rmdir(directory);
+    } catch (e) {
+      throw new Error(`Error while removing the directory "${directory}": ${e.message}`);
+    }
+  }
+  removeDirSync(directory) {
+    try {
+      _fsextra2.default.rmdirSync(directory);
+    } catch (e) {
+      throw new Error(`Error while removing the directory "${directory}": ${e.message}`);
+    }
+  }
+  async mkdir(directory) {
+    try {
+      await _fsextra2.default.mkdirp(directory);
+    } catch (e) {
+      throw new Error(`Error while creating the directory "${directory}": ${e.message}`);
+    }
+  }
+  mkdirSync(directory) {
+    try {
+      _fsextra2.default.mkdirSync(directory);
+    } catch (e) {
+      throw new Error(`Error while creating the directory "${directory}": ${e.message}`);
+    }
+  }
+};
+__name(FileSystemService, "FileSystemService");
+
+// src/lib/parser/parser.service.ts
+var ParserService = class {
+  constructor(parsers) {
+    this.parsers = [YamlParser, JsonParser, EnvironmentVariableParser];
+    if (ParserService.instance) {
+      return ParserService.instance;
+    } else {
+      if (parsers) {
+        this.parsers = parsers;
+      }
+      this.logger = new Logger(this.constructor.name);
+      this.fs = new FileSystemService();
+      ParserService.instance = this;
+      this.logger.trace("Created a new instance.");
+    }
+  }
+  getParser(file) {
+    const ext = (file.includes(".") ? this.fs.extname(file) : file).replace(/^\./, "");
+    const Parser = this.parsers.find((parser) => parser.extensions.includes(ext));
+    if (!Parser) {
+      throw new Error(`Parser for the extension is not configured: ${ext}`);
+    }
+    return new Parser();
+  }
+  setParsers(...parsers) {
+    this.parsers = parsers;
+    this.logger.trace(
+      "Set parsers: %s",
+      this.parsers.map((p) => p.name)
+    );
+  }
+  addParsers(...parsers) {
+    this.parsers.push(...parsers);
+    this.logger.trace(
+      "Added parser, current parsers: %s",
+      this.parsers.map((p) => p.name)
+    );
+  }
+  async read(file) {
+    return this.parse(file, await this.fs.read(file));
+  }
+  async write(file, data) {
+    return this.fs.write(file, await this.stringify(file, data));
+  }
+  parse(file, data) {
+    const parser = this.getParser(file);
+    this.logger.trace("Parsing file: %s -> %s", file, parser.constructor.name);
+    return parser.parse(data);
+  }
+  stringify(file, data) {
+    const parser = this.getParser(file);
+    this.logger.trace("Stringifying file: %s -> %s", file, parser.constructor.name);
+    return parser.stringify(data);
+  }
+};
+__name(ParserService, "ParserService");
+
+// src/utils/color.ts
+var _colorette = require('colorette'); var colorette = _interopRequireWildcard(_colorette);
+var color = colorette.createColors({ useColor: true });
+
+// src/utils/environment.ts
+function isVerbose(logLevel) {
+  return logLevel === "VERBOSE" /* VERBOSE */;
+}
+__name(isVerbose, "isVerbose");
+function isDebug(logLevel) {
+  return ["DEBUG" /* DEBUG */, "TRACE" /* TRACE */].includes(logLevel);
+}
+__name(isDebug, "isDebug");
+function isSilent(logLevel) {
+  return logLevel === "SILENT" /* SILENT */;
+}
+__name(isSilent, "isSilent");
+
+// src/utils/merge.constants.ts
+var MergeStrategy = /* @__PURE__ */ ((MergeStrategy2) => {
+  MergeStrategy2["OVERWRITE"] = "OVERWRITE";
+  MergeStrategy2["EXTEND"] = "EXTEND";
+  return MergeStrategy2;
+})(MergeStrategy || {});
+
+// src/utils/merge.ts
+var _deepmerge = require('deepmerge'); var _deepmerge2 = _interopRequireDefault(_deepmerge);
+function merge(strategy, ...source) {
+  return _deepmerge2.default.all(source, {
+    arrayMerge: strategy === "EXTEND" /* EXTEND */ ? (dest, src) => [...dest, ...src].filter(uniqueFilter) : (_, src) => src
+  });
+}
+__name(merge, "merge");
+function uniqueFilter(value, index, self) {
+  return self.indexOf(value) === index;
+}
+__name(uniqueFilter, "uniqueFilter");
+
+// src/utils/defaults.ts
+function setCtxDefaults(ctx, ...defaults) {
+  _optionalChain([defaults, 'optionalAccess', _2 => _2.forEach, 'call', _3 => _3((i) => {
+    if (typeof i === "object" && !Array.isArray(i)) {
+      Object.assign(ctx, i);
+    }
+  })]);
+}
+__name(setCtxDefaults, "setCtxDefaults");
+function setCtxAssign(ctx, ...assigns) {
+  assigns.forEach((assign) => {
+    _optionalChain([assign, 'optionalAccess', _4 => _4.keys, 'access', _5 => _5.forEach, 'call', _6 => _6((i) => {
+      if (assign.from[i]) {
+        ctx[i] = assign.from[i];
+      }
+    })]);
+  });
+}
+__name(setCtxAssign, "setCtxAssign");
+
+// src/utils/index.ts
+
+
+// src/lib/config/config.service.ts
+var ConfigService = class {
+  constructor(oclif, command, config) {
+    this.oclif = oclif;
+    this.command = command;
+    if (ConfigService.instance) {
+      return ConfigService.instance;
+    }
+    this.root = this.oclif.root;
+    this.defaults = _path.join.call(void 0, this.oclif.root, "config" /* CONFIG_SERVICE_DEFAULTS_DIR */);
+    this.logger = new Logger(this.constructor.name, { level: config.logLevel });
+    Object.assign(this, config);
+    this.recalculate();
+    this.parser = new ParserService();
+    ConfigService.instance = this;
+    this.logger.trace("Created a new instance.");
+  }
+  async read(path) {
+    const config = await this.parser.read(path);
+    this.logger.trace("Read config from: %s", path);
+    return config;
+  }
+  async extend(paths, strategy = "OVERWRITE" /* OVERWRITE */) {
+    this.logger.trace("Will generate config from: %o with %s", paths, strategy);
+    const configs = (await Promise.all(
+      paths.map(async (path) => {
+        try {
+          const config = typeof path === "string" ? await this.parser.read(path) : path;
+          this.logger.trace("Extending config from: %s", path);
+          return config;
+        } catch (e) {
+          this.logger.trace("Failed to extend config from: %s", e.message);
+        }
+      })
+    )).filter(Boolean);
+    return this.merge(configs, strategy);
+  }
+  merge(configs, strategy = "OVERWRITE" /* OVERWRITE */) {
+    if (configs.length === 0) {
+      throw new Error("Nothing to merge, configuration files are empty.");
+    }
+    return merge(strategy, ...configs);
+  }
+  async env(definition, config) {
+    const env = typeof definition === "string" ? await this.parser.read(definition) : definition;
+    this.logger.trace("Environment variable extensions read: %o", definition);
+    const iter = /* @__PURE__ */ __name(async (obj, parent) => {
+      const data = await Promise.all(
+        Object.entries(obj).map(async ([key, value]) => {
+          const location = [..._nullishCoalesce(parent, () => ( [])), key];
+          if (typeof value === "string") {
+            return [{ key: location, env: value }];
+          } else if (typeof value === "object") {
+            let extensions;
+            if ("__element" /* ELEMENT */ in value) {
+              extensions = await iter(value["__element" /* ELEMENT */], [...location, "__element" /* ELEMENT */]);
+              this.logger.trace("Expanding location to elements: %s -> %s", location, extensions.map((extension) => extension.key.join(".")).join(", "));
+            }
+            if ("__name" /* NAME */ in value && "__format" /* PARSER */ in value) {
+              const variable = [
+                {
+                  key: location,
+                  env: value["__name" /* NAME */],
+                  parser: value["__format" /* PARSER */],
+                  extensions
+                }
+              ];
+              return variable;
+            } else {
+              return iter(value, location);
+            }
+          }
+        })
+      );
+      return data.flatMap((d) => d).filter(Boolean);
+    }, "iter");
+    const parsed = await iter(env);
+    const cb = /* @__PURE__ */ __name((config2, variable, data) => {
+      if (variable.parser) {
+        try {
+          data = this.parser.parse(variable.parser, data);
+        } catch (e) {
+          this.logger.trace("Can not parse environment environment variable for config: %s -> %s with %s", variable.key.join("."), variable.env, variable.parser);
+          throw e;
+        }
+      }
+      this.logger.trace("Overwriting config with environment variable: %s -> %s", variable.key.join("."), variable.env);
+      return _objectpathimmutable2.default.set(config2, variable.key, data);
+    }, "cb");
+    parsed.forEach((variable) => {
+      let data;
+      data = process.env[variable.env];
+      if (data) {
+        config = cb(config, variable, data);
+      }
+      if (variable.extensions && variable.extensions.length > 0) {
+        const timeout = 6e4;
+        const startedAt = Date.now();
+        for (let i = 0; i < Infinity; i++) {
+          if (Date.now() - startedAt > timeout) {
+            throw new Error(`Timed-out in ${timeout}ms while looking for element environment variables.`);
+          }
+          const extensions = variable.extensions.map((extension) => {
+            const clone = JSON.parse(JSON.stringify(extension));
+            clone.env = clone.env.replace("${i}" /* ELEMENT_REPLACER */, i.toString());
+            clone.key[clone.key.findIndex((value) => value === "__element" /* ELEMENT */)] = i.toString();
+            data = process.env[clone.env];
+            if (!data) {
+              this.logger.trace("No extension for environment variable: %s -> %s", clone.key.join("."), clone.env);
+              return;
+            }
+            config = cb(config, clone, data);
+            return true;
+          }).filter(Boolean);
+          if (extensions.length === 0) {
+            this.logger.trace("No more extensions for environment variables: %s -> %d", variable.key.join("."), i);
+            break;
+          }
+        }
+      }
+    });
+    return config;
+  }
+  async write(path, data) {
+    return this.parser.write(path, data);
+  }
+  recalculate() {
+    this.isVerbose = isVerbose(this.logLevel);
+    this.isDebug = isDebug(this.logLevel);
+    this.isSilent = isSilent(this.logLevel);
+  }
+};
+__name(ConfigService, "ConfigService");
+
+// src/lib/locker/locker.service.ts
+
+var LockerService = class {
+  constructor(file, parser, root, context) {
+    this.file = file;
+    this.parser = parser;
+    this.root = root;
+    this.toLock = [];
+    this.toUnlock = [];
+    this.fs = new FileSystemService();
+    this.logger = new Logger(_nullishCoalesce(context, () => ( this.constructor.name)));
+    if (!this.parser) {
+      const parser2 = new ParserService();
+      this.parser = parser2.getParser(file);
+    }
+  }
+  hasLock() {
+    return this.toLock.length > 0;
+  }
+  hasUnlock() {
+    return this.toUnlock.length > 0;
+  }
+  addLock(...data) {
+    this.toLock = [...this.toLock, ...data];
+  }
+  addUnlock(...data) {
+    this.toUnlock = [...this.toUnlock, ...data];
+  }
+  async lockAll() {
+    if (this.hasLock()) {
+      await this.lock(...this.toLock);
+      this.toLock = [];
+    }
+  }
+  async unlockAll() {
+    if (this.toUnlock.length > 0) {
+      await this.unlock(...this.toUnlock);
+      this.toUnlock = [];
+    }
+  }
+  async all() {
+    await this.unlockAll();
+    await this.lockAll();
+  }
+  async lock(...data) {
+    let lock = await _asyncNullishCoalesce(await this.tryRead(), async () => ( {}));
+    data.forEach((d) => {
+      if (_optionalChain([d, 'optionalAccess', _7 => _7.enabled]) === false) {
+        return;
+      } else if (!_optionalChain([d, 'optionalAccess', _8 => _8.data]) || Array.isArray(_optionalChain([d, 'optionalAccess', _9 => _9.data])) && d.data.length === 0 || typeof _optionalChain([d, 'optionalAccess', _10 => _10.data]) === "object" && Object.keys(d.data).length === 0) {
+        return;
+      }
+      const path = this.buildPath(d);
+      if (_optionalChain([d, 'optionalAccess', _11 => _11.merge])) {
+        let parsed;
+        if (typeof d.data === "object") {
+          parsed = merge(d.merge, _objectpathimmutable2.default.get(lock, path, Array.isArray(d.data) ? [] : {}), d.data);
+        } else {
+          this.logger.warn('"%s" path with type "%s" is not mergeable.', path, typeof d.data);
+          parsed = d.data;
+        }
+        lock = _objectpathimmutable2.default.set(lock, path, parsed);
+        this.logger.verbose("Merge lock: %s -> %o", path, d.data);
+      } else {
+        lock = _objectpathimmutable2.default.set(lock, path, d.data);
+        this.logger.verbose("Override lock: %s -> %o", path, d.data);
+      }
+    });
+    await this.write(lock);
+  }
+  async unlock(...data) {
+    let lock = await this.tryRead();
+    if (!lock) {
+      this.logger.verbose("Lock file not found. Nothing to unlock.");
+      return;
+    }
+    if (data.length > 0) {
+      data.forEach((d) => {
+        if (_optionalChain([d, 'optionalAccess', _12 => _12.enabled]) === false) {
+          return;
+        }
+        const path = this.buildPath(d);
+        lock = _objectpathimmutable2.default.del(lock, path);
+        this.logger.verbose("Unlocked: %s", path);
+        for (let i = path.length - 1; i >= 0; i--) {
+          const parentPath = path.slice(0, i);
+          const parent = _objectpathimmutable2.default.get(lock, parentPath);
+          if (!parent || Array.isArray(parent) && parent.length === 0 || typeof parent === "object" && Object.keys(parent).length === 0) {
+            this.logger.verbose("Unlocked parent: %s -> %s", path, parentPath);
+            lock = _objectpathimmutable2.default.del(lock, parentPath);
+          } else {
+            break;
+          }
+        }
+      });
+    } else {
+      lock = _objectpathimmutable2.default.del(lock, this.root);
+      this.logger.verbose("Unlocked module: %s", this.root);
+    }
+    await this.write(_nullishCoalesce(lock, () => ( {})));
+  }
+  async read() {
+    return this.parser.parse(await this.fs.read(this.file));
+  }
+  async tryRead() {
+    try {
+      return this.parser.parse(await this.fs.read(this.file));
+    } catch (e2) {
+      this.logger.trace("Can not read lockfile: %s", this.file);
+    }
+  }
+  async write(data) {
+    if (!data || Array.isArray(data) && data.length === 0 || typeof data === "object" && Object.keys(data).length === 0) {
+      this.logger.trace("Trying to write empty lock file, deleting it instead: %s", this.file);
+      return this.fs.remove(this.file);
+    }
+    return this.fs.write(this.file, this.parser.stringify(data));
+  }
+  buildPath(d) {
+    if (_optionalChain([d, 'optionalAccess', _13 => _13.root]) !== true && _optionalChain([this, 'access', _14 => _14.root, 'optionalAccess', _15 => _15.length])) {
+      return [...this.root, ...this.normalizePath(d.path)];
+    }
+    return this.normalizePath(d.path);
+  }
+  normalizePath(path) {
+    if (Array.isArray(path)) {
+      return path.map((p) => p.toString());
+    } else if (typeof path === "string") {
+      return path.split(".");
+    }
+    return [];
+  }
+};
+__name(LockerService, "LockerService");
+
+// src/lib/store/store.service.ts
+var StoreService = class {
+  constructor() {
+    this.store = {};
+    if (StoreService.instance) {
+      return StoreService.instance;
+    } else {
+      StoreService.instance = this;
+    }
+  }
+  has(key) {
+    return !!this.store[key];
+  }
+  get(key) {
+    return this.store[key];
+  }
+  set(key, data) {
+    this.store[key] = data;
+    return data;
+  }
+};
+__name(StoreService, "StoreService");
+
+// src/lib/validator/validator.service.ts
+var _classtransformer = require('class-transformer');
+var _classvalidator = require('class-validator');
+var ValidatorService = class {
+  constructor(options) {
+    this.options = options;
+    if (ValidatorService.instance) {
+      return ValidatorService.instance;
+    }
+    this.options = {
+      validator: {
+        skipMissingProperties: true,
+        whitelist: false,
+        always: true,
+        enableDebugMessages: true
+      },
+      transformer: { enableImplicitConversion: true },
+      ..._nullishCoalesce(options, () => ( {}))
+    };
+    this.logger = new Logger(this.constructor.name);
+    ValidatorService.instance = this;
+    this.logger.trace("Created a new instance.");
+  }
+  async validate(classType, object, options) {
+    const classObject = _classtransformer.plainToClass.call(void 0, classType, object, { ...this.options.transformer, ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _16 => _16.transformer]), () => ( {})) });
+    const errors = await _classvalidator.validate.call(void 0, classObject, { ...this.options.validator, ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _17 => _17.validator]), () => ( {})) });
+    if (errors.length) {
+      errors.forEach((error) => {
+        this.logValidationError(error);
+      });
+      throw new Error("Validation failed.");
+    }
+    return classObject;
+  }
+  validateSync(classType, object, options) {
+    const classObject = _classtransformer.plainToClass.call(void 0, classType, object, { ...this.options.transformer, ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _18 => _18.transformer]), () => ( {})) });
+    const errors = _classvalidator.validateSync.call(void 0, classObject, { ...this.options.validator, ..._nullishCoalesce(_optionalChain([options, 'optionalAccess', _19 => _19.validator]), () => ( {})) });
+    if (errors.length) {
+      errors.forEach((error) => {
+        this.logValidationError(error);
+      });
+      throw new Error("Validation failed.");
+    }
+    return classObject;
+  }
+  logValidationError(err) {
+    this.logger.error('Field "%s" failed validation with value "%s": %o', err.property, err.value, err.constraints);
+  }
+};
+__name(ValidatorService, "ValidatorService");
+
+// src/lib/setup.ts
+function setup() {
+  const inspect = process.argv.indexOf("--inspect");
+  if (inspect !== -1) {
+    __require("inspector").open();
+    process.argv.splice(inspect, 1);
+  }
+  const verbose = process.argv.indexOf("--verbose");
+  if (verbose !== -1) {
+    process.env.LOG_LEVEL = "verbose";
+    process.argv.splice(verbose, 1);
+  }
+  const debug = process.argv.indexOf("--debug");
+  if (debug !== -1) {
+    process.env.LOG_LEVEL = "debug";
+    process.argv.splice(debug, 1);
+  }
+  const trace = process.argv.indexOf("--trace");
+  if (trace !== -1) {
+    process.env.LOG_LEVEL = "trace";
+    process.argv.splice(trace, 1);
+  }
+  const silent = process.argv.indexOf("--silent");
+  if (silent !== -1) {
+    process.env.LOG_LEVEL = "silent";
+    process.argv.splice(silent, 1);
+  }
+  const sourceMaps = process.argv.indexOf("--source-map");
+  if (sourceMaps !== -1) {
+    __require("source-map-support").install();
+    process.argv.splice(sourceMaps, 1);
+  }
+}
+__name(setup, "setup");
+
+// src/utils/logger/logger.ts
+var Logger = class {
+  constructor(context, options) {
+    this.context = context;
+    this.options = options;
+    if (Logger.instance) {
+      this.logger = Logger.instance;
+    } else if (context === ConfigService.name) {
+      const level = Object.values(LogLevels).includes(_optionalChain([options, 'optionalAccess', _20 => _20.level])) ? options.level : "INFO" /* INFO */;
+      this.options = {
+        useIcons: true,
+        ...options,
+        level
+      };
+      this.logger = this.initiateLogger();
+      this.trace("Logger singleton initiated from context: %s", context);
+      Logger.instance = this.logger;
+    } else {
+      throw new Error("Logger can only be initiated inside the config service context!");
+    }
+  }
+  log(level, data, ...args) {
+    return this.parseMessage(level, data, args);
+  }
+  direct(data, ...args) {
+    return this.parseMessage("DIRECT" /* DIRECT */, data, args);
+  }
+  fatal(data, ...args) {
+    return this.parseMessage("FATAL" /* FATAL */, data, args);
+  }
+  error(data, ...args) {
+    return this.parseMessage("ERROR" /* ERROR */, data, args);
+  }
+  warn(data, ...args) {
+    return this.parseMessage("WARN" /* WARN */, data, args);
+  }
+  info(data, ...args) {
+    return this.parseMessage("INFO" /* INFO */, data, args);
+  }
+  debug(data, ...args) {
+    return this.parseMessage("DEBUG" /* DEBUG */, data, args);
+  }
+  verbose(data, ...args) {
+    return this.parseMessage("VERBOSE" /* VERBOSE */, data, args);
+  }
+  trace(data, ...args) {
+    return this.parseMessage("TRACE" /* TRACE */, data, args);
+  }
+  run(data, ...args) {
+    return this.parseMessage("INFO" /* INFO */, data, args, { status: "run" /* RUN */ });
+  }
+  end(data, ...args) {
+    return this.parseMessage("INFO" /* INFO */, data, args, { status: "end" /* END */ });
+  }
+  stage(data, ...args) {
+    return this.parseMessage("TRACE" /* TRACE */, data, args, { status: "stage" /* STAGE */ });
+  }
+  initiateLogger() {
+    const logFormat = _winston.format.printf(({ level, message, context, status }) => {
+      let multiLineMessage;
+      multiLineMessage = message.split(_os.EOL);
+      multiLineMessage = multiLineMessage.filter((msg) => msg.trim() !== "").filter(Boolean);
+      multiLineMessage = multiLineMessage.map((msg) => {
+        return this.logColoring({
+          level,
+          message: msg,
+          context,
+          status
+        });
+      });
+      return multiLineMessage.join(_os.EOL);
+    });
+    const logger = _winston2.default.createLogger({
+      level: this.options.level,
+      format: _winston.format.combine(_winston.format.splat(), _winston.format.json({ space: 2 }), _winston.format.prettyPrint(), logFormat),
+      levels: Object.values(LogLevels).reduce((o, level, i) => {
+        return {
+          ...o,
+          [level]: i
+        };
+      }, {}),
+      silent: this.options.level === "SILENT" /* SILENT */,
+      transports: [
+        new _winston.transports.Console({
+          stderrLevels: ["FATAL" /* FATAL */, "ERROR" /* ERROR */]
+        })
+      ]
+    });
+    logger.log("TRACE" /* TRACE */, "Initiated new logger with level: %s", this.options.level, { context: this.constructor.name });
+    return logger;
+  }
+  parseMessage(level, data, args, format2) {
+    if (!this.logger && !Logger.instance) {
+      return;
+    } else if (Logger.instance) {
+      this.logger = Logger.instance;
+    }
+    this.logger.log(level, data.toString(), ..._nullishCoalesce(args, () => ( [])), { context: this.context, ..._nullishCoalesce(format2, () => ( {})) });
+  }
+  logColoring({ level, message, context, status }) {
+    let icon;
+    let coloring = /* @__PURE__ */ __name((input) => {
+      return input;
+    }, "coloring");
+    let msgColoring = /* @__PURE__ */ __name((input) => {
+      return input;
+    }, "msgColoring");
+    switch (level) {
+      case "DIRECT" /* DIRECT */:
+        return message;
+      case "FATAL" /* FATAL */:
+        coloring = /* @__PURE__ */ __name((input) => color.red(input), "coloring");
+        if (_optionalChain([this, 'access', _21 => _21.options, 'optionalAccess', _22 => _22.useIcons])) {
+          icon = _listr2.figures.checkboxOn;
+        }
+        break;
+      case "ERROR" /* ERROR */:
+        coloring = color.red;
+        if (_optionalChain([this, 'access', _23 => _23.options, 'optionalAccess', _24 => _24.useIcons])) {
+          icon = _listr2.figures.cross;
+        }
+        break;
+      case "WARN" /* WARN */:
+        coloring = color.yellow;
+        if (_optionalChain([this, 'access', _25 => _25.options, 'optionalAccess', _26 => _26.useIcons])) {
+          icon = _listr2.figures.warning;
+        }
+        break;
+      case "INFO" /* INFO */:
+        coloring = color.green;
+        if (_optionalChain([this, 'access', _27 => _27.options, 'optionalAccess', _28 => _28.useIcons])) {
+          icon = _listr2.figures.pointerSmall;
+        }
+        break;
+      case "VERBOSE" /* VERBOSE */:
+        coloring = color.dim;
+        if (_optionalChain([this, 'access', _29 => _29.options, 'optionalAccess', _30 => _30.useIcons])) {
+          icon = "\u2607";
+        }
+        break;
+      case "DEBUG" /* DEBUG */:
+        coloring = color.cyan;
+        msgColoring = color.dim;
+        if (_optionalChain([this, 'access', _31 => _31.options, 'optionalAccess', _32 => _32.useIcons])) {
+          icon = "\uF188";
+        }
+        break;
+      case "TRACE" /* TRACE */:
+        coloring = color.magenta;
+        msgColoring = color.dim;
+        if (_optionalChain([this, 'access', _33 => _33.options, 'optionalAccess', _34 => _34.useIcons])) {
+          icon = "\u26B1";
+        }
+        break;
+    }
+    if (!icon) {
+      icon = `[${level.at(0).toUpperCase()}]`;
+    }
+    return `${coloring(icon)}${context ? " " + coloring(`[${context}]`) : ""}${status ? " " + coloring(`[${status}]`) : ""} ${msgColoring(message)}`;
+  }
+};
+__name(Logger, "Logger");
+
+// src/utils/logger/listr-logger.ts
+var ListrLogger = class extends _listr2.Logger {
+  constructor(context) {
+    super();
+    this.logger = new Logger(context);
+  }
+  fail(message) {
+    this.logger.error(message);
+  }
+  skip(message) {
+    this.logger.warn(message, { status: "skip" });
+  }
+  success(message) {
+    this.logger.info(message, { status: "end" });
+  }
+  data(message) {
+    this.logger.info(message);
+  }
+  start(message) {
+    this.logger.info(message, { status: "run" });
+  }
+  title(message) {
+    this.logger.info(message);
+  }
+  retry(message) {
+    this.logger.warn(message, { status: "retry" });
+  }
+  rollback(message) {
+    this.logger.error(message, { status: "rollback" });
+  }
+};
+__name(ListrLogger, "ListrLogger");
+
+// src/utils/logger/pipe/pipe-process-to-listr.ts
+var _through = require('through'); var _through2 = _interopRequireDefault(_through);
+function pipeProcessThroughListr(task, instance) {
+  const logOut = _through2.default.call(void 0, (chunk) => {
+    task.output = _optionalChain([chunk, 'optionalAccess', _35 => _35.toString, 'call', _36 => _36("utf-8"), 'access', _37 => _37.trim, 'call', _38 => _38()]);
+  });
+  instance.stdout.pipe(logOut);
+  instance.stderr.pipe(logOut);
+  return instance;
+}
+__name(pipeProcessThroughListr, "pipeProcessThroughListr");
+
+// src/utils/logger/pipe/pipe-process-to-logger.ts
+
+function pipeProcessToLogger(logger, instance, options) {
+  options = {
+    start: "INFO" /* INFO */,
+    end: "INFO" /* INFO */,
+    stdout: "INFO" /* INFO */,
+    stderr: "WARN" /* WARN */,
+    ...options
+  };
+  if (options.start) {
+    logger.run(instance.spawnargs.join(" "), { level: options.start, context: options.context });
+  }
+  if (instance.stdout) {
+    instance.stdout.pipe(
+      _through2.default.call(void 0, (chunk) => {
+        logger.log(options.stdout, chunk, { context: options.context });
+      })
+    );
+  }
+  if (instance.stderr) {
+    instance.stderr.pipe(
+      _through2.default.call(void 0, (chunk) => {
+        logger.log(options.stderr, chunk, { context: options.context });
+      })
+    );
+  }
+  void instance.on("exit", (code, signal) => {
+    const message = `Process ended with code ${code}${signal ? ` and signal ${signal}` : ""}.`;
+    logger.debug(message, { context: options.context });
+    if (options.end) {
+      logger.end(instance.spawnargs.join(" "), { level: options.end, context: options.context });
+    }
+    if (_optionalChain([options, 'optionalAccess', _39 => _39.callback])) {
+      options.callback();
+    }
+  });
+  void instance.on("error", (error) => {
+    logger.fatal(error.message, { context: options.context });
+    logger.debug(error.stack, { context: options.context });
+    if (_optionalChain([options, 'optionalAccess', _40 => _40.callback])) {
+      options.callback(error);
+    }
+  });
+  return instance;
+}
+__name(pipeProcessToLogger, "pipeProcessToLogger");
+
+// src/constants/global-flags.constants.ts
+var CLI_FLAGS = {
+  ["log-level"]: _core.Flags.enum({
+    default: "INFO" /* INFO */,
+    env: "LOG_LEVEL",
+    description: "Set the log level of the application.",
+    options: [...Object.values(LogLevels).map((level) => level.toLowerCase())],
+    helpGroup: "CLI" /* CLI */,
+    parse: async (input) => _optionalChain([input, 'optionalAccess', _41 => _41.toUpperCase, 'call', _42 => _42()])
+  }),
+  ci: _core.Flags.boolean({
+    default: false,
+    hidden: true,
+    env: "CI",
+    description: "Instruct whether this is running the CI/CD configuration.",
+    helpGroup: "CLI" /* CLI */
+  }),
+  json: _core.Flags.boolean({
+    default: false,
+    hidden: true,
+    env: "JSON",
+    description: "Put the CLI to respond in JSON.",
+    helpGroup: "CLI" /* CLI */
+  })
+};
+
+// src/commands/base.command.ts
+var Command = class extends _core.Command {
+  constructor() {
+    super(...arguments);
+    this.flags = {};
+    this.args = {};
+  }
+  shouldRunBefore() {
+  }
+  shouldRunAfter(_ctx) {
+  }
+  run() {
+    throw new Error("The command should have a run function to do something!");
+  }
+  async _run() {
+    let result;
+    try {
+      delete process.env[this.config.scopedEnvVarKey("REDIRECTED")];
+      await this.init();
+      result = await this.run();
+      await this.finally();
+    } catch (error) {
+      await this.catch(error, 127);
+    }
+    if (result && this.jsonEnabled()) {
+      _core.CliUx.ux.styledJSON(this.toSuccessJson(result));
+    }
+    return result;
+  }
+  exit(code) {
+    this.logger.trace("Code -> %d", code, { status: "exit" /* EXIT */ });
+    process.exit(_nullishCoalesce(code, () => ( 0)));
+  }
+  runTasks() {
+    return this.tasks.runAll();
+  }
+  prompt(options) {
+    return _listr2.createPrompt.call(void 0, options, {
+      error: true,
+      stdout: process.stdout
+    });
+  }
+  setCtxDefaults(...defaults) {
+    setCtxDefaults(this.tasks.options.ctx, ...defaults);
+    this.logger.trace("Updated context with defaults: %o", this.tasks.options.ctx, { status: "ctx" });
+  }
+  setCtxAssign(...assigns) {
+    setCtxAssign(this.tasks.options.ctx, ...assigns);
+    this.logger.trace("Updated context with assign: %o", this.tasks.options.ctx, { status: "ctx" });
+  }
+  pipeProcessToLogger(instance, options) {
+    return pipeProcessToLogger(this.logger, instance, options);
+  }
+  pipeProcessThroughListr(task, instance) {
+    return pipeProcessThroughListr(task, instance);
+  }
+  async init() {
+    this.constructor.flags = Object.assign({}, CLI_FLAGS, this.constructor.flags);
+    await super.init();
+    let err;
+    try {
+      const { flags, args } = await this.parse();
+      this.flags = flags;
+      this.args = args;
+    } catch (e) {
+      err = e;
+    }
+    this.cs = new ConfigService(this.config, this.ctor, {
+      logLevel: this.flags["log-level"],
+      ci: this.flags.ci,
+      json: this.flags.json
+    });
+    this.context = this.cs.command.id ? this.cs.command.id : this.cs.command.name;
+    this.logger = new Logger(null, { level: this.cs.logLevel });
+    this.store = new StoreService();
+    this.greet();
+    if (err) {
+      throw err;
+    }
+    this.logger.stage("Initiating services.");
+    this.parser = new ParserService();
+    this.fs = new FileSystemService();
+    this.validator = new ValidatorService();
+    this.tasks = new (0, _listr2.Manager)({
+      rendererFallback: this.cs.isDebug,
+      rendererSilent: this.cs.isSilent,
+      nonTTYRendererOptions: {
+        logEmptyTitle: false,
+        logTitleChange: false,
+        logger: ListrLogger
+      },
+      ctx: {}
+    });
+    if (this.cs.oclif.windows) {
+      _readline.createInterface.call(void 0, {
+        input: process.stdin,
+        output: process.stdout
+      }).on("SIGINT", () => {
+        process.kill(process.pid, "SIGINT");
+      });
+    }
+    const terminate = /* @__PURE__ */ __name(() => {
+      this.logger.fatal("Caught terminate signal.", { status: "terminate" /* TERMINATE */ });
+      process.exit(1);
+    }, "terminate");
+    process.on("SIGINT", terminate);
+    process.on("SIGTERM", terminate);
+    this.logger.stage("Running shouldRunBefore.");
+    await this.shouldRunBefore();
+    this.logger.stage("Finished shouldRunBefore.");
+  }
+  async finally() {
+    this.logger.stage("Running tasks.");
+    const ctx = await this.runTasks();
+    this.logger.stage("Finished tasks.");
+    this.logger.stage("Running shouldRunAfter.");
+    await this.shouldRunAfter(ctx);
+    this.logger.stage("Finished shouldRunAfter.");
+    return { ctx };
+  }
+  catch(e, exit) {
+    if (!this.logger) {
+      console.error("Logger has not been initiated yet!");
+      console.error(e.message);
+      console.debug(e.stack);
+    }
+    this.logger.fatal(e.message);
+    this.logger.debug(e.stack, { context: "crash" });
+    if (exit > 0) {
+      this.exit(exit);
+    }
+    return;
+  }
+  greet() {
+    if (this.cs.isSilent || this.cs.json) {
+      return;
+    }
+    const logo = _nullishCoalesce(this.store.get("logo"), () => ( `${this.cs.oclif.name} v${this.cs.oclif.version}`));
+    this.logger.direct(logo);
+    if (!this.store.has("logo")) {
+      this.logger.direct("-".repeat(logo.length));
+    }
+  }
+};
+__name(Command, "Command");
+
+// src/commands/config.command.ts
+var ConfigCommand = class extends Command {
+  constructor() {
+    super(...arguments);
+    this.ux = _core.CliUx.ux;
+  }
+  async run() {
+    this.logger.stage("Setting up config command.");
+    const setup2 = await this.setup();
+    this.choices = setup2.choices;
+    this.locker = setup2.locker;
+    this.logger.stage("User selection for configuration.");
+    const response = await this.select();
+    this.logger.stage("Will run selection: %s", response);
+    return this.choices[response].bind(this)();
+  }
+  setup() {
+    throw new Error("The command should be setup first!");
+  }
+  table(...options) {
+    this.ux.table(...options);
+  }
+  async select() {
+    const response = await this.prompt({
+      type: "Select",
+      message: "Please select what to do with the configuration.",
+      choices: Object.keys(this.choices)
+    });
+    return response;
+  }
+};
+__name(ConfigCommand, "ConfigCommand");
+
+// src/hooks/not-found.hook.ts
+
+var notFoundHook = /* @__PURE__ */ __name(async (opts) => {
+  const logger = new Logger(opts.config.name);
+  logger.fatal("Command not found. Take a look at help. You can also use --[h]elp flag for subcommands.", { custom: opts.config.name });
+  logger.direct("");
+  const help = new (0, _core.Help)(opts.config);
+  await help.showHelp(["--all"]);
+  process.exit(127);
+}, "notFoundHook");
+
+// src/hooks/update-notifier.hook.ts
+var _updatenotifier = require('update-notifier'); var _updatenotifier2 = _interopRequireDefault(_updatenotifier);
+var updateNotifierHook = /* @__PURE__ */ __name(async (opts) => {
+  _updatenotifier2.default.call(void 0, { pkg: { name: opts.config.name, version: opts.config.version } }).notify({ isGlobal: true });
+}, "updateNotifierHook");
+
+// src/hooks/store.hook.ts
+var storeHook = /* @__PURE__ */ __name((cb) => async (opts) => {
+  cb(opts, new StoreService());
+}, "storeHook");
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.CLI_FLAGS = CLI_FLAGS; exports.CliUx = _core.CliUx; exports.Command = Command; exports.ConfigCommand = ConfigCommand; exports.ConfigService = ConfigService; exports.EnvironmentVariableParser = EnvironmentVariableParser; exports.FileConstants = FileConstants; exports.FileSystemService = FileSystemService; exports.Flags = _core.Flags; exports.HelpGroups = HelpGroups; exports.JsonParser = JsonParser; exports.ListrLogger = ListrLogger; exports.LockerService = LockerService; exports.LogFieldStatus = LogFieldStatus; exports.LogLevels = LogLevels; exports.Logger = Logger; exports.MergeStrategy = MergeStrategy; exports.ParserService = ParserService; exports.StoreService = StoreService; exports.ValidatorService = ValidatorService; exports.YamlParser = YamlParser; exports.color = color; exports.fs = _fsextra2.default; exports.isDebug = isDebug; exports.isSilent = isSilent; exports.isVerbose = isVerbose; exports.merge = merge; exports.notFoundHook = notFoundHook; exports.pipeProcessThroughListr = pipeProcessThroughListr; exports.pipeProcessToLogger = pipeProcessToLogger; exports.setCtxAssign = setCtxAssign; exports.setCtxDefaults = setCtxDefaults; exports.setup = setup; exports.storeHook = storeHook; exports.uniqueFilter = uniqueFilter; exports.updateNotifierHook = updateNotifierHook;