@keycloakify/angular 0.0.1-rc.8 → 0.0.1

package/bin/925.index.js

@@ -0,0 +1,1115 @@
+"use strict";
+exports.id = 925;
+exports.ids = [925];
+exports.modules = {
+
+/***/ 925:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  command: () => (/* binding */ command)
+});
+
+// EXTERNAL MODULE: ./dist/bin/tools/getThisCodebaseRootDirPath.js
+var getThisCodebaseRootDirPath = __webpack_require__(427);
+// EXTERNAL MODULE: ./node_modules/cli-select/dist/index.js
+var dist = __webpack_require__(546);
+var dist_default = /*#__PURE__*/__webpack_require__.n(dist);
+// EXTERNAL MODULE: ./node_modules/keycloakify/bin/shared/constants.js
+var constants = __webpack_require__(316);
+// EXTERNAL MODULE: external "fs"
+var external_fs_ = __webpack_require__(896);
+// EXTERNAL MODULE: external "path"
+var external_path_ = __webpack_require__(928);
+// EXTERNAL MODULE: ./node_modules/tsafe/esm/assert.mjs + 1 modules
+var assert = __webpack_require__(966);
+// EXTERNAL MODULE: ./node_modules/chalk/source/index.js + 3 modules
+var source = __webpack_require__(797);
+;// CONCATENATED MODULE: ./dist/bin/tools/crawl.js
+
+
+const crawlRec = (dirPath, filePaths) => {
+    for (const basename of external_fs_.readdirSync(dirPath)) {
+        const fileOrDirPath = (0,external_path_.join)(dirPath, basename);
+        if (external_fs_.lstatSync(fileOrDirPath).isDirectory()) {
+            crawlRec(fileOrDirPath, filePaths);
+            continue;
+        }
+        filePaths.push(fileOrDirPath);
+    }
+};
+/** List all files in a given directory return paths relative to the dir_path */
+function crawl(params) {
+    const { dirPath, returnedPathsType } = params;
+    const filePaths = [];
+    crawlRec(dirPath, filePaths);
+    switch (returnedPathsType) {
+        case 'absolute':
+            return filePaths;
+        case 'relative to dirPath':
+            return filePaths.map(filePath => (0,external_path_.relative)(dirPath, filePath));
+    }
+}
+
+;// CONCATENATED MODULE: ./dist/bin/tools/SemVer.js
+var SemVer;
+(function (SemVer) {
+    const bumpTypes = ['major', 'minor', 'patch', 'rc', 'no bump'];
+    function parse(versionStr) {
+        const match = versionStr.match(/^v?([0-9]+)\.([0-9]+)(?:\.([0-9]+))?(?:-rc.([0-9]+))?$/);
+        if (!match) {
+            throw new Error(`${versionStr} is not a valid semantic version`);
+        }
+        const semVer = Object.assign({ major: parseInt(match[1]), minor: parseInt(match[2]), patch: (() => {
+                const str = match[3];
+                return str === undefined ? 0 : parseInt(str);
+            })() }, (() => {
+            const str = match[4];
+            return str === undefined ? {} : { rc: parseInt(str) };
+        })());
+        const initialStr = stringify(semVer);
+        Object.defineProperty(semVer, 'parsedFrom', {
+            enumerable: true,
+            get: function () {
+                const currentStr = stringify(this);
+                if (currentStr !== initialStr) {
+                    throw new Error(`SemVer.parsedFrom can't be read anymore, the version have been modified from ${initialStr} to ${currentStr}`);
+                }
+                return versionStr;
+            }
+        });
+        return semVer;
+    }
+    SemVer.parse = parse;
+    function stringify(v) {
+        return `${v.major}.${v.minor}.${v.patch}${v.rc === undefined ? '' : `-rc.${v.rc}`}`;
+    }
+    SemVer.stringify = stringify;
+    /**
+     *
+     * v1  <  v2  => -1
+     * v1 === v2  => 0
+     * v1  >  v2  => 1
+     *
+     */
+    function compare(v1, v2) {
+        const sign = (diff) => (diff === 0 ? 0 : diff < 0 ? -1 : 1);
+        const noUndefined = (n) => n !== null && n !== void 0 ? n : Infinity;
+        for (const level of ['major', 'minor', 'patch', 'rc']) {
+            if (noUndefined(v1[level]) !== noUndefined(v2[level])) {
+                return sign(noUndefined(v1[level]) - noUndefined(v2[level]));
+            }
+        }
+        return 0;
+    }
+    SemVer.compare = compare;
+    /*
+    console.log(compare(parse("3.0.0-rc.3"), parse("3.0.0")) === -1 )
+    console.log(compare(parse("3.0.0-rc.3"), parse("3.0.0-rc.4")) === -1 )
+    console.log(compare(parse("3.0.0-rc.3"), parse("4.0.0")) === -1 )
+    */
+    function bumpType(params) {
+        const versionAhead = typeof params.versionAhead === 'string'
+            ? parse(params.versionAhead)
+            : params.versionAhead;
+        const versionBehind = typeof params.versionBehind === 'string'
+            ? parse(params.versionBehind)
+            : params.versionBehind;
+        if (compare(versionBehind, versionAhead) === 1) {
+            throw new Error(`Version regression ${stringify(versionBehind)} -> ${stringify(versionAhead)}`);
+        }
+        for (const level of ['major', 'minor', 'patch', 'rc']) {
+            if (versionBehind[level] !== versionAhead[level]) {
+                return level;
+            }
+        }
+        return 'no bump';
+    }
+    SemVer.bumpType = bumpType;
+})(SemVer || (SemVer = {}));
+
+;// CONCATENATED MODULE: ./dist/bin/tools/fs.rmSync.js
+
+
+
+/**
+ * Polyfill of fs.rmSync(dirPath, { "recursive": true })
+ * For older version of Node
+ */
+function rmSync(dirPath, options) {
+    if (SemVer.compare(SemVer.parse(process.version), SemVer.parse('14.14.0')) > 0) {
+        external_fs_.rmSync(dirPath, options);
+        return;
+    }
+    const { force = true } = options;
+    if (force && !external_fs_.existsSync(dirPath)) {
+        return;
+    }
+    const removeDir_rec = (dirPath) => external_fs_.readdirSync(dirPath).forEach(basename => {
+        const fileOrDirPath = (0,external_path_.join)(dirPath, basename);
+        if (external_fs_.lstatSync(fileOrDirPath).isDirectory()) {
+            removeDir_rec(fileOrDirPath);
+            return;
+        }
+        else {
+            external_fs_.unlinkSync(fileOrDirPath);
+        }
+    });
+    removeDir_rec(dirPath);
+}
+
+;// CONCATENATED MODULE: ./dist/bin/tools/transformCodebase.js
+
+
+
+
+/**
+ * Apply a transformation function to every file of directory
+ * If source and destination are the same this function can be used to apply the transformation in place
+ * like filtering out some files or modifying them.
+ * */
+function transformCodebase(params) {
+    const { srcDirPath, transformSourceCode } = params;
+    const isTargetSameAsSource = external_path_.relative(srcDirPath, params.destDirPath) === '';
+    const destDirPath = isTargetSameAsSource
+        ? external_path_.join(srcDirPath, '..', 'tmp_xOsPdkPsTdzPs34sOkHs')
+        : params.destDirPath;
+    external_fs_.mkdirSync(destDirPath, {
+        recursive: true
+    });
+    for (const fileRelativePath of crawl({
+        dirPath: srcDirPath,
+        returnedPathsType: 'relative to dirPath'
+    })) {
+        const filePath = external_path_.join(srcDirPath, fileRelativePath);
+        const destFilePath = external_path_.join(destDirPath, fileRelativePath);
+        // NOTE: Optimization, if we don't need to transform the file, just copy
+        // it using the lower level implementation.
+        if (transformSourceCode === undefined) {
+            external_fs_.mkdirSync(external_path_.dirname(destFilePath), {
+                recursive: true
+            });
+            external_fs_.copyFileSync(filePath, destFilePath);
+            continue;
+        }
+        const transformSourceCodeResult = transformSourceCode({
+            sourceCode: external_fs_.readFileSync(filePath),
+            filePath,
+            fileRelativePath
+        });
+        if (transformSourceCodeResult === undefined) {
+            continue;
+        }
+        external_fs_.mkdirSync(external_path_.dirname(destFilePath), {
+            recursive: true
+        });
+        const { newFileName, modifiedSourceCode } = transformSourceCodeResult;
+        external_fs_.writeFileSync(external_path_.join(external_path_.dirname(destFilePath), newFileName !== null && newFileName !== void 0 ? newFileName : external_path_.basename(destFilePath)), modifiedSourceCode);
+    }
+    if (isTargetSameAsSource) {
+        rmSync(srcDirPath, { recursive: true });
+        external_fs_.renameSync(destDirPath, srcDirPath);
+    }
+}
+
+;// CONCATENATED MODULE: ./node_modules/tsafe/esm/capitalize.mjs
+/** @see <https://docs.tsafe.dev/capitalize> */
+function capitalize(str) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return (str.charAt(0).toUpperCase() + str.slice(1));
+}
+
+
+//# sourceMappingURL=capitalize.mjs.map
+
+;// CONCATENATED MODULE: ./dist/bin/tools/kebabCaseToSnakeCase.js
+
+function kebabCaseToCamelCase(kebabCaseString) {
+    const [first, ...rest] = kebabCaseString.split('-');
+    return [first, ...rest.map(capitalize)].join('');
+}
+
+;// CONCATENATED MODULE: ./dist/bin/tools/String.prototype.replaceAll.js
+function replaceAll(string, searchValue, replaceValue) {
+    if (string.replaceAll !== undefined) {
+        return string.replaceAll(searchValue, replaceValue);
+    }
+    // If the searchValue is a string
+    if (typeof searchValue === 'string') {
+        // Escape special characters in the string to be used in a regex
+        var escapedSearchValue = searchValue.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        var regex = new RegExp(escapedSearchValue, 'g');
+        return string.replace(regex, replaceValue);
+    }
+    // If the searchValue is a global RegExp, use it directly
+    if (searchValue instanceof RegExp && searchValue.global) {
+        return string.replace(searchValue, replaceValue);
+    }
+    // If the searchValue is a non-global RegExp, throw an error
+    if (searchValue instanceof RegExp) {
+        throw new TypeError('replaceAll must be called with a global RegExp');
+    }
+    // Convert searchValue to string if it's not a string or RegExp
+    var searchString = String(searchValue);
+    var regexFromString = new RegExp(searchString.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g');
+    return string.replace(regexFromString, replaceValue);
+}
+
+// EXTERNAL MODULE: ./node_modules/tsafe/esm/id.mjs
+var id = __webpack_require__(94);
+// EXTERNAL MODULE: ./node_modules/zod/lib/index.mjs
+var lib = __webpack_require__(383);
+// EXTERNAL MODULE: ./node_modules/tsafe/esm/is.mjs
+var is = __webpack_require__(289);
+// EXTERNAL MODULE: external "child_process"
+var external_child_process_ = __webpack_require__(317);
+;// CONCATENATED MODULE: ./dist/bin/eject-page.js
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+async function command(params) {
+    const { buildContext } = params;
+    console.log(source/* default */.Ay.cyan('Theme type:'));
+    const themeType = await (async () => {
+        const values = constants/* THEME_TYPES */.qA.filter(themeType => {
+            switch (themeType) {
+                case 'account':
+                    return buildContext.implementedThemeTypes.account.isImplemented;
+                case 'login':
+                    return buildContext.implementedThemeTypes.login.isImplemented;
+            }
+            (0,assert/* assert */.v)(false);
+        });
+        (0,assert/* assert */.v)(values.length > 0, 'No theme is implemented in this project');
+        if (values.length === 1) {
+            return values[0];
+        }
+        const { value } = await dist_default()({
+            values
+        }).catch(() => {
+            process.exit(-1);
+        });
+        return value;
+    })();
+    console.log(`→ ${themeType}`);
+    console.log(source/* default */.Ay.cyan('Select the page you want to customize:'));
+    const templateValue = 'template.ftl (Layout common to every page)';
+    const userProfileFormFieldsValue = 'user-profile-commons.ftl (Renders the form of the register.ftl, login-update-profile.ftl, update-email.ftl and idp-review-user-profile.ftl)';
+    const { value: pageIdOrComponent } = await dist_default()({
+        values: (() => {
+            switch (themeType) {
+                case 'login':
+                    return [
+                        templateValue,
+                        userProfileFormFieldsValue,
+                        ...constants/* LOGIN_THEME_PAGE_IDS */.hz
+                    ];
+                case 'account':
+                    return [templateValue, ...constants/* ACCOUNT_THEME_PAGE_IDS */.Hp];
+            }
+            (0,assert/* assert */.v)(false);
+        })()
+    }).catch(() => {
+        process.exit(-1);
+    });
+    console.log(`→ ${pageIdOrComponent}`);
+    const componentRelativeDirPath_posix_to_componentRelativeFilePath_posix = (params) => {
+        const { componentRelativeDirPath_posix } = params;
+        return `${componentRelativeDirPath_posix}/${external_path_.posix.basename(componentRelativeDirPath_posix)}.component`;
+    };
+    const componentDirRelativeToThemeTypePath = (() => {
+        if (pageIdOrComponent === templateValue) {
+            return (0,external_path_.join)('containers', 'template');
+        }
+        if (pageIdOrComponent === userProfileFormFieldsValue) {
+            return (0,external_path_.join)('components', 'user-profile-form-fields');
+        }
+        return (0,external_path_.join)('pages', pageIdOrComponent.replace(/\.ftl$/, ''));
+    })();
+    {
+        const componentDirRelativeToThemeTypePaths = [
+            componentDirRelativeToThemeTypePath
+        ];
+        while (componentDirRelativeToThemeTypePaths.length !== 0) {
+            const componentDirRelativeToThemeTypePath_i = componentDirRelativeToThemeTypePaths.pop();
+            (0,assert/* assert */.v)(componentDirRelativeToThemeTypePath_i !== undefined);
+            const destDirPath = (0,external_path_.join)(buildContext.themeSrcDirPath, themeType, componentDirRelativeToThemeTypePath_i);
+            if (external_fs_.existsSync(destDirPath) && external_fs_.readdirSync(destDirPath).length !== 0) {
+                if (componentDirRelativeToThemeTypePath_i ===
+                    componentDirRelativeToThemeTypePath) {
+                    console.log(`${pageIdOrComponent.split('.ftl')[0]} is already ejected, ${(0,external_path_.relative)(process.cwd(), destDirPath)} already exists`);
+                    process.exit(-1);
+                }
+                continue;
+            }
+            const localThemeTypeDirPath = (0,external_path_.join)((0,getThisCodebaseRootDirPath/* getThisCodebaseRootDirPath */.J)(), 'src', themeType);
+            transformCodebase({
+                srcDirPath: (0,external_path_.join)(localThemeTypeDirPath, componentDirRelativeToThemeTypePath_i),
+                destDirPath,
+                transformSourceCode: ({ filePath, sourceCode }) => {
+                    if (!filePath.endsWith('.ts')) {
+                        return { modifiedSourceCode: sourceCode };
+                    }
+                    if (filePath.endsWith('index.ts')) {
+                        return undefined;
+                    }
+                    const fileRelativeToThemeTypePath = (0,external_path_.relative)(localThemeTypeDirPath, filePath);
+                    let modifiedSourceCode_str = sourceCode.toString();
+                    const getPosixPathRelativeToFile = (params) => {
+                        const { pathRelativeToThemeType } = params;
+                        const path = (0,external_path_.relative)((0,external_path_.dirname)(fileRelativeToThemeTypePath), pathRelativeToThemeType)
+                            .split(external_path_.sep)
+                            .join('/');
+                        return path.startsWith('.') ? path : `./${path}`;
+                    };
+                    modifiedSourceCode_str = replaceAll(modifiedSourceCode_str, `@keycloakify/angular/${themeType}/i18n`, getPosixPathRelativeToFile({
+                        pathRelativeToThemeType: 'i18n'
+                    }));
+                    modifiedSourceCode_str = replaceAll(modifiedSourceCode_str, `@keycloakify/angular/${themeType}/KcContext`, getPosixPathRelativeToFile({
+                        pathRelativeToThemeType: 'KcContext'
+                    }));
+                    modifiedSourceCode_str = modifiedSourceCode_str.replace(new RegExp(`@keycloakify/angular/${themeType}/components/([^'"]+)`, 'g'), (...[, componentDirRelativeToComponentsPath]) => {
+                        const componentDirRelativeToThemeTypePath = (0,external_path_.join)('components', componentDirRelativeToComponentsPath);
+                        componentDirRelativeToThemeTypePaths.push(componentDirRelativeToThemeTypePath);
+                        return componentRelativeDirPath_posix_to_componentRelativeFilePath_posix({
+                            componentRelativeDirPath_posix: getPosixPathRelativeToFile({
+                                pathRelativeToThemeType: componentDirRelativeToThemeTypePath
+                            })
+                        });
+                    });
+                    return {
+                        modifiedSourceCode: Buffer.from(modifiedSourceCode_str, 'utf8')
+                    };
+                }
+            });
+            console.log(`${source/* default */.Ay.green('✓')} ${source/* default */.Ay.bold(`.${external_path_.sep}` + (0,external_path_.relative)(process.cwd(), destDirPath))} moved from the @keycloakify/angular to your project`);
+        }
+    }
+    run_format: {
+        const parsedPackageJson = (() => {
+            const zParsedPackageJson = (() => {
+                const zTargetType = lib.z.object({
+                    scripts: lib.z.record(lib.z.string()).optional()
+                });
+                (0,assert/* assert */.v)();
+                return (0,id.id)(zTargetType);
+            })();
+            const parsedPackageJson = JSON.parse(external_fs_.readFileSync(buildContext.packageJsonFilePath).toString('utf8'));
+            zParsedPackageJson.parse(parsedPackageJson);
+            (0,assert/* assert */.v)((0,is.is)(parsedPackageJson));
+            return parsedPackageJson;
+        })();
+        const { scripts } = parsedPackageJson;
+        if (scripts === undefined) {
+            break run_format;
+        }
+        for (const scriptName of ['format', 'lint']) {
+            if (!(scriptName in scripts)) {
+                continue;
+            }
+            const command = `npm run ${scriptName}`;
+            console.log(source/* default */.Ay.grey(`$ ${command}`));
+            try {
+                external_child_process_.execSync(`npm run ${scriptName}`, {
+                    stdio: 'inherit',
+                    cwd: (0,external_path_.dirname)(buildContext.packageJsonFilePath)
+                });
+            }
+            catch (_a) {
+                console.log(source/* default */.Ay.yellow(`\`${command}\` failed, please format your code manually, continuing...`));
+            }
+            break run_format;
+        }
+    }
+    edit_KcPage: {
+        if (pageIdOrComponent !== templateValue &&
+            pageIdOrComponent !== userProfileFormFieldsValue) {
+            break edit_KcPage;
+        }
+        const kcAppTsFilePath = (0,external_path_.join)(buildContext.themeSrcDirPath, themeType, 'KcPage.ts');
+        const kcAppTsCode = external_fs_.readFileSync(kcAppTsFilePath).toString('utf8');
+        const modifiedKcAppTsCode = (() => {
+            const componentRelativeDirPath_posix = componentDirRelativeToThemeTypePath
+                .split(external_path_.sep)
+                .join('/');
+            return kcAppTsCode.replace(`@keycloakify/angular/${themeType}/${componentRelativeDirPath_posix}`, componentRelativeDirPath_posix_to_componentRelativeFilePath_posix({
+                componentRelativeDirPath_posix: `./${componentRelativeDirPath_posix}`
+            }));
+        })();
+        if (modifiedKcAppTsCode === kcAppTsCode) {
+            console.log(source/* default */.Ay.red('Unable to automatically update KcPage.ts, please update it manually'));
+            return;
+        }
+        external_fs_.writeFileSync(kcAppTsFilePath, Buffer.from(modifiedKcAppTsCode, 'utf8'));
+        console.log(`${source/* default */.Ay.green('✓')} ${source/* default */.Ay.bold(`.${external_path_.sep}` + (0,external_path_.relative)(process.cwd(), kcAppTsFilePath))} Updated`);
+        return;
+    }
+    const pageId = pageIdOrComponent;
+    console.log([
+        ``,
+        `You now need to update your page router:`,
+        ``,
+        `${source/* default */.Ay.bold((0,external_path_.join)('.', (0,external_path_.relative)(process.cwd(), buildContext.themeSrcDirPath), themeType, 'KcPage.ts'))}:`,
+        source/* default */.Ay.grey('```'),
+        `// ...`,
+        ``,
+        ...[
+            ` export async function getKcPage(pageId: KcContext['pageId']): Promise<KcPage> {`,
+            `   switch (pageId) {`,
+            `+    case '${pageId}':`,
+            `+      return {`,
+            `+        PageComponent: (await import('${componentRelativeDirPath_posix_to_componentRelativeFilePath_posix({
+                componentRelativeDirPath_posix: `./${componentDirRelativeToThemeTypePath.split(external_path_.sep).join('/')}`
+            })}')).${kebabCaseToCamelCase(capitalize(pageId).replace(/\.ftl$/, ''))}Component,`,
+            `+        TemplateComponent,`,
+            ...(themeType === 'login'
+                ? [`+        UserProfileFormFieldsComponent,`]
+                : []),
+            ...(themeType === 'login' ? [`+        doMakeUserConfirmPassword,`] : []),
+            `+        doUseDefaultCss,`,
+            `+        classes,`,
+            `+      };`,
+            `     //...`,
+            `     default:`,
+            `       return {`,
+            `         PageComponent: await getDefaultPageComponent(pageId),`,
+            `         TemplateComponent,`,
+            ...(themeType === 'login'
+                ? [`         UserProfileFormFieldsComponent,`]
+                : []),
+            ...(themeType === 'login' ? [`         doMakeUserConfirmPassword,`] : []),
+            `         doUseDefaultCss,`,
+            `         classes,`,
+            `       };`,
+            `   }`,
+            ` }`
+        ].map(line => {
+            if (line.startsWith('+')) {
+                return source/* default */.Ay.green(line);
+            }
+            if (line.startsWith('-')) {
+                return source/* default */.Ay.red(line);
+            }
+            return source/* default */.Ay.grey(line);
+        }),
+        source/* default */.Ay.grey('```')
+    ].join('\n'));
+}
+
+
+/***/ }),
+
+/***/ 427:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   J: () => (/* binding */ getThisCodebaseRootDirPath)
+/* harmony export */ });
+/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(896);
+/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(fs__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(928);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_1__);
+
+
+function getThisCodebaseRootDirPath_rec(dirPath) {
+    if (fs__WEBPACK_IMPORTED_MODULE_0__.existsSync(path__WEBPACK_IMPORTED_MODULE_1__.join(dirPath, 'package.json'))) {
+        return dirPath;
+    }
+    return getThisCodebaseRootDirPath_rec(path__WEBPACK_IMPORTED_MODULE_1__.join(dirPath, '..'));
+}
+let result = undefined;
+function getThisCodebaseRootDirPath() {
+    if (result !== undefined) {
+        return result;
+    }
+    return (result = getThisCodebaseRootDirPath_rec(__dirname));
+}
+
+
+/***/ }),
+
+/***/ 672:
+/***/ ((__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;
+
+/***/ }),
+
+/***/ 546:
+/***/ ((module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports["default"] = void 0;
+
+var _input = _interopRequireDefault(__webpack_require__(938));
+
+var _renderer = _interopRequireDefault(__webpack_require__(547));
+
+var _callbackMappers = __webpack_require__(672);
+
+var _valueMappers = __webpack_require__(348);
+
+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;
+
+/***/ }),
+
+/***/ 938:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports["default"] = void 0;
+
+var _readline = _interopRequireDefault(__webpack_require__(785));
+
+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;
+
+/***/ }),
+
+/***/ 547:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+
+
+Object.defineProperty(exports, "__esModule", ({
+  value: true
+}));
+exports["default"] = void 0;
+
+var _readline = _interopRequireDefault(__webpack_require__(785));
+
+var _ansiEscapes = __webpack_require__(719);
+
+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;
+
+/***/ }),
+
+/***/ 348:
+/***/ ((__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;
+
+/***/ }),
+
+/***/ 719:
+/***/ ((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;
+
+
+/***/ })
+
+};
+;