keycloakify 10.0.0-rc.118 → 10.0.0-rc.119

package/bin/932.index.js

@@ -14,7 +14,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var path__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(71017);
 /* harmony import */ var path__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_1__);
 /* harmony import */ var _tools_transformCodebase__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(60332);
-/* harmony import */ var _shared_promptKeycloakVersion__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(95781);
+/* harmony import */ var _shared_promptKeycloakVersion__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(82635);
 /* harmony import */ var _shared_buildContext__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(56031);
 /* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(57147);
 /* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(fs__WEBPACK_IMPORTED_MODULE_5__);
@@ -58,13 +58,13 @@ async function command(params) {
 
 /***/ }),
 
-/***/ 95781:
+/***/ 97189:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
-  "s": () => (/* binding */ promptKeycloakVersion)
+  "_": () => (/* binding */ getLatestsSemVersionedTag)
 });
 
 ;// CONCATENATED MODULE: ./dist/bin/tools/octokit-addons/listTags.js
@@ -134,7 +134,7 @@ function getLatestsSemVersionedTagFactory(params) {
     const { octokit } = params;
     async function getLatestsSemVersionedTag(params) {
         var _a, e_1, _b, _c;
-        const { owner, repo, count } = params;
+        const { owner, repo, count, doIgnoreReleaseCandidates } = params;
         const semVersionedTags = [];
         const { listTags } = listTagsFactory({ octokit });
         try {
@@ -150,7 +150,7 @@ function getLatestsSemVersionedTagFactory(params) {
                     catch (_g) {
                         continue;
                     }
-                    if (version.rc !== undefined) {
+                    if (doIgnoreReleaseCandidates && version.rc !== undefined) {
                         continue;
                     }
                     semVersionedTags.push({ tag, version });
@@ -176,16 +176,30 @@ function getLatestsSemVersionedTagFactory(params) {
 //# sourceMappingURL=getLatestsSemVersionedTag.js.map
 // EXTERNAL MODULE: ./node_modules/@octokit/rest/dist-node/index.js
 var dist_node = __webpack_require__(55375);
-// EXTERNAL MODULE: ./node_modules/cli-select/dist/index.js
-var dist = __webpack_require__(99398);
-var dist_default = /*#__PURE__*/__webpack_require__.n(dist);
 // EXTERNAL MODULE: external "path"
 var external_path_ = __webpack_require__(71017);
 // EXTERNAL MODULE: external "fs"
 var external_fs_ = __webpack_require__(57147);
+// EXTERNAL MODULE: ./node_modules/zod/lib/index.mjs
+var lib = __webpack_require__(52300);
+// EXTERNAL MODULE: ./node_modules/tsafe/assert.js
+var assert = __webpack_require__(88078);
 // EXTERNAL MODULE: ./node_modules/tsafe/id.js
 var id = __webpack_require__(43047);
-;// CONCATENATED MODULE: ./dist/bin/shared/promptKeycloakVersion.js
+// EXTERNAL MODULE: ./node_modules/evt/tools/inDepth/same.js
+var same = __webpack_require__(33805);
+;// CONCATENATED MODULE: ./dist/bin/shared/getLatestsSemVersionedTag.js
+var __rest = (undefined && undefined.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 
 
 
@@ -193,50 +207,144 @@ var id = __webpack_require__(43047);
 
 
 
-async function promptKeycloakVersion(params) {
-    const { startingFromMajor, excludeMajorVersions, cacheDirPath } = params;
-    const { getLatestsSemVersionedTag } = (() => {
-        const { octokit } = (() => {
+
+let getLatestsSemVersionedTag_stateless = undefined;
+const CACHE_VERSION = 1;
+async function getLatestsSemVersionedTag(_a) {
+    var { cacheDirPath } = _a, params = __rest(_a, ["cacheDirPath"]);
+    const cacheFilePath = (0,external_path_.join)(cacheDirPath, "latest-sem-versioned-tags.json");
+    const cacheLookupResult = (() => {
+        const getResult_currentCache = (currentCacheEntries) => ({
+            hasCachedResult: false,
+            currentCache: {
+                version: CACHE_VERSION,
+                entries: currentCacheEntries
+            }
+        });
+        if (!external_fs_.existsSync(cacheFilePath)) {
+            return getResult_currentCache([]);
+        }
+        let cache_json;
+        try {
+            cache_json = external_fs_.readFileSync(cacheFilePath).toString("utf8");
+        }
+        catch (_a) {
+            return getResult_currentCache([]);
+        }
+        let cache_json_parsed;
+        try {
+            cache_json_parsed = JSON.parse(cache_json);
+        }
+        catch (_b) {
+            return getResult_currentCache([]);
+        }
+        const zSemVer = (() => {
+            const zTargetType = lib.z.object({
+                major: lib.z.number(),
+                minor: lib.z.number(),
+                patch: lib.z.number(),
+                rc: lib.z.number().optional(),
+                parsedFrom: lib.z.string()
+            });
+            (0,assert.assert)();
+            return (0,id.id)(zTargetType);
+        })();
+        const zCache = (() => {
+            const zTargetType = lib.z.object({
+                version: lib.z.literal(CACHE_VERSION),
+                entries: lib.z.array(lib.z.object({
+                    time: lib.z.number(),
+                    params: lib.z.object({
+                        owner: lib.z.string(),
+                        repo: lib.z.string(),
+                        count: lib.z.number(),
+                        doIgnoreReleaseCandidates: lib.z.boolean()
+                    }),
+                    result: lib.z.array(lib.z.object({
+                        tag: lib.z.string(),
+                        version: zSemVer
+                    }))
+                }))
+            });
+            (0,assert.assert)();
+            return (0,id.id)(zTargetType);
+        })();
+        let cache;
+        try {
+            cache = zCache.parse(cache_json_parsed);
+        }
+        catch (_c) {
+            return getResult_currentCache([]);
+        }
+        const cacheEntry = cache.entries.find(e => (0,same.same)(e.params, params));
+        if (cacheEntry === undefined) {
+            return getResult_currentCache(cache.entries);
+        }
+        if (Date.now() - cacheEntry.time > 3600000) {
+            return getResult_currentCache(cache.entries.filter(e => e !== cacheEntry));
+        }
+        return {
+            hasCachedResult: true,
+            cachedResult: cacheEntry.result
+        };
+    })();
+    if (cacheLookupResult.hasCachedResult) {
+        return cacheLookupResult.cachedResult;
+    }
+    const { currentCache } = cacheLookupResult;
+    getLatestsSemVersionedTag_stateless !== null && getLatestsSemVersionedTag_stateless !== void 0 ? getLatestsSemVersionedTag_stateless : (getLatestsSemVersionedTag_stateless = (() => {
+        const octokit = (() => {
             const githubToken = process.env.GITHUB_TOKEN;
             const octokit = new dist_node.Octokit(githubToken === undefined ? undefined : { auth: githubToken });
-            return { octokit };
+            return octokit;
         })();
         const { getLatestsSemVersionedTag } = getLatestsSemVersionedTagFactory({
             octokit
         });
-        return { getLatestsSemVersionedTag };
-    })();
-    const semVersionedTagByMajor = new Map();
-    const semVersionedTags = await (async () => {
-        const cacheFilePath = (0,external_path_.join)(cacheDirPath, "keycloak-versions.json");
-        use_cache: {
-            if (!external_fs_.existsSync(cacheFilePath)) {
-                break use_cache;
-            }
-            const cache = JSON.parse(external_fs_.readFileSync(cacheFilePath).toString("utf8"));
-            if (Date.now() - cache.time > 3600000) {
-                external_fs_.unlinkSync(cacheFilePath);
-                break use_cache;
-            }
-            return cache.semVersionedTags;
-        }
-        const semVersionedTags = await getLatestsSemVersionedTag({
-            count: 50,
-            owner: "keycloak",
-            repo: "keycloak"
-        });
-        {
-            const dirPath = (0,external_path_.dirname)(cacheFilePath);
-            if (!external_fs_.existsSync(dirPath)) {
-                external_fs_.mkdirSync(dirPath, { recursive: true });
-            }
+        return getLatestsSemVersionedTag;
+    })());
+    const result = await getLatestsSemVersionedTag_stateless(params);
+    currentCache.entries.push({
+        time: Date.now(),
+        params,
+        result
+    });
+    {
+        const dirPath = (0,external_path_.dirname)(cacheFilePath);
+        if (!external_fs_.existsSync(dirPath)) {
+            external_fs_.mkdirSync(dirPath, { recursive: true });
         }
-        external_fs_.writeFileSync(cacheFilePath, JSON.stringify((0,id.id)({
-            time: Date.now(),
-            semVersionedTags
-        }), null, 2));
-        return semVersionedTags;
-    })();
+    }
+    external_fs_.writeFileSync(cacheFilePath, JSON.stringify(currentCache, null, 2));
+    return result;
+}
+//# sourceMappingURL=getLatestsSemVersionedTag.js.map
+
+/***/ }),
+
+/***/ 82635:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "s": () => (/* binding */ promptKeycloakVersion)
+/* harmony export */ });
+/* harmony import */ var _getLatestsSemVersionedTag__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(97189);
+/* harmony import */ var cli_select__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(99398);
+/* harmony import */ var cli_select__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(cli_select__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _tools_SemVer__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(12171);
+
+
+
+async function promptKeycloakVersion(params) {
+    const { startingFromMajor, excludeMajorVersions, cacheDirPath } = params;
+    const semVersionedTagByMajor = new Map();
+    const semVersionedTags = await (0,_getLatestsSemVersionedTag__WEBPACK_IMPORTED_MODULE_0__/* .getLatestsSemVersionedTag */ ._)({
+        cacheDirPath,
+        count: 50,
+        owner: "keycloak",
+        repo: "keycloak",
+        doIgnoreReleaseCandidates: true
+    });
     semVersionedTags.forEach(semVersionedTag => {
         if (startingFromMajor !== undefined &&
             semVersionedTag.version.major < startingFromMajor) {
@@ -247,13 +355,13 @@ async function promptKeycloakVersion(params) {
         }
         const currentSemVersionedTag = semVersionedTagByMajor.get(semVersionedTag.version.major);
         if (currentSemVersionedTag !== undefined &&
-            SemVer/* SemVer.compare */.h.compare(semVersionedTag.version, currentSemVersionedTag.version) === -1) {
+            _tools_SemVer__WEBPACK_IMPORTED_MODULE_2__/* .SemVer.compare */ .h.compare(semVersionedTag.version, currentSemVersionedTag.version) === -1) {
             return;
         }
         semVersionedTagByMajor.set(semVersionedTag.version.major, semVersionedTag);
     });
     const lastMajorVersions = Array.from(semVersionedTagByMajor.values()).map(({ tag }) => tag);
-    const { value } = await dist_default()({
+    const { value } = await cli_select__WEBPACK_IMPORTED_MODULE_1___default()({
         values: lastMajorVersions
     }).catch(() => {
         process.exit(-1);
@@ -263,6 +371,575 @@ async function promptKeycloakVersion(params) {
 }
 //# sourceMappingURL=promptKeycloakVersion.js.map
 
+/***/ }),
+
+/***/ 18512:
+/***/ ((module) => {
+
+
+const x = module.exports;
+const ESC = '\u001B[';
+const OSC = '\u001B]';
+const BEL = '\u0007';
+const SEP = ';';
+const isTerminalApp = process.env.TERM_PROGRAM === 'Apple_Terminal';
+
+x.cursorTo = (x, y) => {
+	if (typeof x !== 'number') {
+		throw new TypeError('The `x` argument is required');
+	}
+
+	if (typeof y !== 'number') {
+		return ESC + (x + 1) + 'G';
+	}
+
+	return ESC + (y + 1) + ';' + (x + 1) + 'H';
+};
+
+x.cursorMove = (x, y) => {
+	if (typeof x !== 'number') {
+		throw new TypeError('The `x` argument is required');
+	}
+
+	let ret = '';
+
+	if (x < 0) {
+		ret += ESC + (-x) + 'D';
+	} else if (x > 0) {
+		ret += ESC + x + 'C';
+	}
+
+	if (y < 0) {
+		ret += ESC + (-y) + 'A';
+	} else if (y > 0) {
+		ret += ESC + y + 'B';
+	}
+
+	return ret;
+};
+
+x.cursorUp = count => ESC + (typeof count === 'number' ? count : 1) + 'A';
+x.cursorDown = count => ESC + (typeof count === 'number' ? count : 1) + 'B';
+x.cursorForward = count => ESC + (typeof count === 'number' ? count : 1) + 'C';
+x.cursorBackward = count => ESC + (typeof count === 'number' ? count : 1) + 'D';
+
+x.cursorLeft = ESC + 'G';
+x.cursorSavePosition = ESC + (isTerminalApp ? '7' : 's');
+x.cursorRestorePosition = ESC + (isTerminalApp ? '8' : 'u');
+x.cursorGetPosition = ESC + '6n';
+x.cursorNextLine = ESC + 'E';
+x.cursorPrevLine = ESC + 'F';
+x.cursorHide = ESC + '?25l';
+x.cursorShow = ESC + '?25h';
+
+x.eraseLines = count => {
+	let clear = '';
+
+	for (let i = 0; i < count; i++) {
+		clear += x.eraseLine + (i < count - 1 ? x.cursorUp() : '');
+	}
+
+	if (count) {
+		clear += x.cursorLeft;
+	}
+
+	return clear;
+};
+
+x.eraseEndLine = ESC + 'K';
+x.eraseStartLine = ESC + '1K';
+x.eraseLine = ESC + '2K';
+x.eraseDown = ESC + 'J';
+x.eraseUp = ESC + '1J';
+x.eraseScreen = ESC + '2J';
+x.scrollUp = ESC + 'S';
+x.scrollDown = ESC + 'T';
+
+x.clearScreen = '\u001Bc';
+
+x.clearTerminal = process.platform === 'win32' ?
+	`${x.eraseScreen}${ESC}0f` :
+	// 1. Erases the screen (Only done in case `2` is not supported)
+	// 2. Erases the whole screen including scrollback buffer
+	// 3. Moves cursor to the top-left position
+	// More info: https://www.real-world-systems.com/docs/ANSIcode.html
+	`${x.eraseScreen}${ESC}3J${ESC}H`;
+
+x.beep = BEL;
+
+x.link = (text, url) => {
+	return [
+		OSC,
+		'8',
+		SEP,
+		SEP,
+		url,
+		BEL,
+		text,
+		OSC,
+		'8',
+		SEP,
+		SEP,
+		BEL
+	].join('');
+};
+
+x.image = (buf, opts) => {
+	opts = opts || {};
+
+	let ret = OSC + '1337;File=inline=1';
+
+	if (opts.width) {
+		ret += `;width=${opts.width}`;
+	}
+
+	if (opts.height) {
+		ret += `;height=${opts.height}`;
+	}
+
+	if (opts.preserveAspectRatio === false) {
+		ret += ';preserveAspectRatio=0';
+	}
+
+	return ret + ':' + buf.toString('base64') + BEL;
+};
+
+x.iTerm = {};
+
+x.iTerm.setCwd = cwd => OSC + '50;CurrentDir=' + (cwd || process.cwd()) + BEL;
+
+
+/***/ }),
+
+/***/ 39340:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.withPromise = exports.withCallback = void 0;
+
+/**
+ * Open the input with a normal callback function
+ *
+ * @param {Input} input - input object
+ * @param {function} valueMapper - function which maps the resulting id and value back to the expected format
+ * @param {function} callback - callback function
+ */
+const withCallback = (input, valueMapper, callback) => {
+  input.open();
+  input.onSelect((id, value) => callback(valueMapper(id, value)));
+};
+/**
+ * Open the input with a promise
+ *
+ * @param {Input} input - input object
+ * @param {function} valueMapper - function which maps the resulting id and value back to the expected format
+ */
+
+
+exports.withCallback = withCallback;
+
+const withPromise = (input, valueMapper) => {
+  return new Promise((resolve, reject) => {
+    input.open();
+    input.onSelect((id, value) => {
+      if (id === null) {
+        reject();
+      } else {
+        resolve(valueMapper(id, value));
+      }
+    });
+  });
+};
+
+exports.withPromise = withPromise;
+
+/***/ }),
+
+/***/ 99398:
+/***/ ((module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports["default"] = void 0;
+
+var _input = _interopRequireDefault(__webpack_require__(25730));
+
+var _renderer = _interopRequireDefault(__webpack_require__(16059));
+
+var _callbackMappers = __webpack_require__(39340);
+
+var _valueMappers = __webpack_require__(26730);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+/**
+ * Default options
+ */
+const defaultOptions = {
+  outputStream: process.stdout,
+  inputStream: process.stdin,
+  values: [],
+  defaultValue: 0,
+  selected: '(x)',
+  unselected: '( )',
+  indentation: 0,
+  cleanup: true,
+  valueRenderer: value => value
+};
+/**
+ * Create an instance of cli-select with the given options
+ *
+ * @param {object} options - options for cli-select
+ * @param {function} callback - if specified, a callback will be used, otherwise a promise gets returned (optional)
+ */
+
+const creator = (options, callback) => {
+  // merge options with default options
+  options = _objectSpread({}, defaultOptions, options); // create renderer and input instances
+
+  const renderer = new _renderer.default(options, options.outputStream);
+  const input = new _input.default(options.inputStream);
+  input.setDefaultValue(options.defaultValue);
+  input.attachRenderer(renderer); // handle array and object values
+
+  let valueMapper;
+
+  if (Array.isArray(options.values)) {
+    valueMapper = (0, _valueMappers.withArrayValues)(options);
+  } else {
+    valueMapper = (0, _valueMappers.withObjectValues)(options);
+  } // map values
+
+
+  options.values = valueMapper.input;
+  input.setValues(options.values); // handle different callback methods
+
+  if (typeof callback === 'function') {
+    return (0, _callbackMappers.withCallback)(input, valueMapper.output, callback);
+  } else {
+    return (0, _callbackMappers.withPromise)(input, valueMapper.output);
+  }
+};
+
+exports = module.exports = creator;
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+var _default = creator;
+exports["default"] = _default;
+
+/***/ }),
+
+/***/ 25730:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports["default"] = void 0;
+
+var _readline = _interopRequireDefault(__webpack_require__(14521));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Handle cli input
+ */
+class Input {
+  /**
+   * Input constructor
+   *
+   * @param {any} stream - stream to catch (optional)
+   */
+  constructor(stream = process.stdin) {
+    // set default values
+    this.stream = stream;
+    this.values = [];
+    this.selectedValue = 0;
+
+    this.onSelectListener = () => {};
+
+    this.onKeyPress = this.onKeyPress.bind(this);
+  }
+  /**
+   * Set the available values
+   *
+   * @param {array} values - all available values
+   */
+
+
+  setValues(values) {
+    this.values = values;
+
+    if (this.renderer) {
+      this.renderer.setValues(values);
+    }
+  }
+  /**
+   * Set the default value
+   *
+   * @param {number} defaultValue - default value id
+   */
+
+
+  setDefaultValue(defaultValue) {
+    this.selectedValue = defaultValue;
+  }
+  /**
+   * Attach a renderer to the input catcher
+   *
+   * @param {Renderer} renderer - renderer to use for rendering responses
+   */
+
+
+  attachRenderer(renderer) {
+    this.renderer = renderer;
+    this.renderer.setValues(this.values);
+  }
+  /**
+   * Register an on select listener
+   *
+   * @param {function} listener - listener function which receives two parameters: valueId and value
+   */
+
+
+  onSelect(listener) {
+    this.onSelectListener = listener;
+  }
+  /**
+   * Open the stream and listen for input
+   */
+
+
+  open() {
+    // register keypress event
+    _readline.default.emitKeypressEvents(this.stream); // handle keypress
+
+
+    this.stream.on('keypress', this.onKeyPress); // initially render the response
+
+    if (this.renderer) {
+      this.renderer.render(this.selectedValue);
+    } // hide pressed keys and start listening on input
+
+
+    this.stream.setRawMode(true);
+    this.stream.resume();
+  }
+  /**
+   * Close the stream
+   *
+   * @param {boolean} cancelled - true if no value was selected (optional)
+   */
+
+
+  close(cancelled = false) {
+    // reset stream properties
+    this.stream.setRawMode(false);
+    this.stream.pause(); // cleanup the output
+
+    if (this.renderer) {
+      this.renderer.cleanup();
+    } // call the on select listener
+
+
+    if (cancelled) {
+      this.onSelectListener(null);
+    } else {
+      this.onSelectListener(this.selectedValue, this.values[this.selectedValue]);
+    }
+
+    this.stream.removeListener('keypress', this.onKeyPress);
+  }
+  /**
+   * Render the response
+   */
+
+
+  render() {
+    if (!this.renderer) {
+      return;
+    }
+
+    this.renderer.render(this.selectedValue);
+  }
+  /**
+   * Handle key press event
+   *
+   * @param {string} string - input string
+   * @param {object} key - object containing information about the pressed key
+   */
+
+
+  onKeyPress(string, key) {
+    if (key) {
+      if (key.name === 'up' && this.selectedValue > 0) {
+        this.selectedValue--;
+        this.render();
+      } else if (key.name === 'down' && this.selectedValue + 1 < this.values.length) {
+        this.selectedValue++;
+        this.render();
+      } else if (key.name === 'return') {
+        this.close();
+      } else if (key.name === 'escape' || key.name === 'c' && key.ctrl) {
+        this.close(true);
+      }
+    }
+  }
+
+}
+
+exports["default"] = Input;
+
+/***/ }),
+
+/***/ 16059:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports["default"] = void 0;
+
+var _readline = _interopRequireDefault(__webpack_require__(14521));
+
+var _ansiEscapes = __webpack_require__(18512);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Response renderer
+ */
+class Renderer {
+  /**
+   * Renderer constructor
+   *
+   * @param {object} options - renderer options
+   * @param {any} stream - stream to write to (optional)
+   */
+  constructor(options, stream = process.stdout) {
+    this.options = options;
+    this.stream = stream;
+    this.values = [];
+    this.initialRender = true;
+  }
+  /**
+   * Set the available values
+   *
+   * @param {array} values - all available values
+   */
+
+
+  setValues(values) {
+    this.values = values;
+  }
+  /**
+   * Render the values
+   *
+   * @param {number} selectedValue - selected value (optional)
+   */
+
+
+  render(selectedValue = 0) {
+    if (this.initialRender) {
+      // hide the cursor initially
+      this.initialRender = false;
+      this.stream.write(_ansiEscapes.cursorHide);
+    } else {
+      // remove previous lines and values
+      this.stream.write((0, _ansiEscapes.eraseLines)(this.values.length));
+    } // output the current values
+
+
+    this.values.forEach((value, index) => {
+      const symbol = selectedValue === index ? this.options.selected : this.options.unselected;
+      const indentation = ' '.repeat(this.options.indentation);
+      const renderedValue = this.options.valueRenderer(value, selectedValue === index);
+      const end = index !== this.values.length - 1 ? '\n' : '';
+      this.stream.write(indentation + symbol + ' ' + renderedValue + end);
+    });
+  }
+  /**
+   * Cleanup the console at the end
+   */
+
+
+  cleanup() {
+    this.stream.write((0, _ansiEscapes.eraseLines)(this.values.length));
+    this.stream.write(_ansiEscapes.cursorShow);
+  }
+
+}
+
+exports["default"] = Renderer;
+
+/***/ }),
+
+/***/ 26730:
+/***/ ((__unused_webpack_module, exports) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports.withObjectValues = exports.withArrayValues = void 0;
+
+/**
+ * Map incoming and outgoing values if the initial values are an array
+ *
+ * @param {object} options - cli-select options
+ */
+const withArrayValues = options => {
+  return {
+    input: options.values,
+    output: (id, value) => {
+      return {
+        id,
+        value
+      };
+    }
+  };
+};
+/**
+ * Map incoming and outgoing values if the initial values are an object
+ *
+ * @param {object} options - cli-select options
+ */
+
+
+exports.withArrayValues = withArrayValues;
+
+const withObjectValues = options => {
+  const originalValues = options.values;
+  return {
+    input: Object.values(originalValues),
+    output: (id, value) => {
+      return {
+        id: Object.keys(originalValues)[id],
+        value
+      };
+    }
+  };
+};
+
+exports.withObjectValues = withObjectValues;
+
 /***/ })
 
 };