keycloakify 10.0.0-rc.4 → 10.0.0-rc.41

package/bin/98.index.js

@@ -0,0 +1,1234 @@
+"use strict";
+exports.id = 98;
+exports.ids = [98];
+exports.modules = {
+
+/***/ 87751:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "s": () => (/* binding */ getBuildContext)
+});
+
+// EXTERNAL MODULE: external "url"
+var external_url_ = __webpack_require__(57310);
+// EXTERNAL MODULE: external "path"
+var external_path_ = __webpack_require__(71017);
+// EXTERNAL MODULE: ./dist/bin/tools/getAbsoluteAndInOsFormatPath.js
+var getAbsoluteAndInOsFormatPath = __webpack_require__(86644);
+// EXTERNAL MODULE: external "child_process"
+var external_child_process_ = __webpack_require__(32081);
+// EXTERNAL MODULE: ./node_modules/tsafe/assert.js
+var assert = __webpack_require__(88078);
+// EXTERNAL MODULE: external "fs"
+var external_fs_ = __webpack_require__(57147);
+;// CONCATENATED MODULE: ./dist/bin/tools/getNpmWorkspaceRootDirPath.js
+
+
+
+
+function getNpmWorkspaceRootDirPath(params) {
+    const { projectDirPath, dependencyExpected } = params;
+    const npmWorkspaceRootDirPath = (function callee(depth) {
+        const cwd = (0,external_path_.resolve)((0,external_path_.join)(...[projectDirPath, ...Array(depth).fill("..")]));
+        (0,assert.assert)(cwd !== external_path_.sep, "NPM workspace not found");
+        try {
+            external_child_process_.execSync("npm config get", {
+                cwd,
+                stdio: "ignore"
+            });
+        }
+        catch (error) {
+            if (String(error).includes("ENOWORKSPACES")) {
+                return callee(depth + 1);
+            }
+            throw error;
+        }
+        const packageJsonFilePath = (0,external_path_.join)(cwd, "package.json");
+        if (!external_fs_.existsSync(packageJsonFilePath)) {
+            return callee(depth + 1);
+        }
+        (0,assert.assert)(external_fs_.existsSync(packageJsonFilePath));
+        const parsedPackageJson = JSON.parse(external_fs_.readFileSync(packageJsonFilePath).toString("utf8"));
+        let isExpectedDependencyFound = false;
+        for (const dependenciesOrDevDependencies of [
+            "dependencies",
+            "devDependencies"
+        ]) {
+            const dependencies = parsedPackageJson[dependenciesOrDevDependencies];
+            if (dependencies === undefined) {
+                continue;
+            }
+            (0,assert.assert)(dependencies instanceof Object);
+            if (dependencies[dependencyExpected] === undefined) {
+                continue;
+            }
+            isExpectedDependencyFound = true;
+        }
+        if (!isExpectedDependencyFound && parsedPackageJson.name !== dependencyExpected) {
+            return callee(depth + 1);
+        }
+        return cwd;
+    })(0);
+    return { npmWorkspaceRootDirPath };
+}
+//# sourceMappingURL=getNpmWorkspaceRootDirPath.js.map
+// EXTERNAL MODULE: ./node_modules/zod/lib/index.mjs
+var lib = __webpack_require__(52300);
+// EXTERNAL MODULE: ./node_modules/tsafe/index.js
+var tsafe = __webpack_require__(1666);
+// EXTERNAL MODULE: ./dist/bin/shared/constants.js
+var constants = __webpack_require__(173);
+;// CONCATENATED MODULE: ./dist/bin/shared/buildContext.js
+
+
+
+
+
+
+
+
+
+function getBuildContext(params) {
+    var _a, _b, _c, _d, _e, _f;
+    const { cliCommandOptions } = params;
+    const projectDirPath = (() => {
+        if (cliCommandOptions.projectDirPath === undefined) {
+            return process.cwd();
+        }
+        return (0,getAbsoluteAndInOsFormatPath/* getAbsoluteAndInOsFormatPath */.c)({
+            pathIsh: cliCommandOptions.projectDirPath,
+            cwd: process.cwd()
+        });
+    })();
+    const { resolvedViteConfig } = (() => {
+        if (external_fs_.readdirSync(projectDirPath)
+            .find(fileBasename => fileBasename.startsWith("vite.config")) ===
+            undefined) {
+            return { resolvedViteConfig: undefined };
+        }
+        const output = external_child_process_.execSync("npx vite", {
+            cwd: projectDirPath,
+            env: Object.assign(Object.assign({}, process.env), { [constants/* vitePluginSubScriptEnvNames.resolveViteConfig */.fe.resolveViteConfig]: "true" })
+        })
+            .toString("utf8");
+        (0,tsafe.assert)(output.includes(constants/* vitePluginSubScriptEnvNames.resolveViteConfig */.fe.resolveViteConfig), "Seems like the Keycloakify's Vite plugin is not installed.");
+        const resolvedViteConfigStr = output
+            .split(constants/* vitePluginSubScriptEnvNames.resolveViteConfig */.fe.resolveViteConfig)
+            .reverse()[0];
+        const resolvedViteConfig = JSON.parse(resolvedViteConfigStr);
+        return { resolvedViteConfig };
+    })();
+    const parsedPackageJson = (() => {
+        const zParsedPackageJson = lib.z.object({
+            name: lib.z.string(),
+            version: lib.z.string().optional(),
+            homepage: lib.z.string().optional(),
+            keycloakify: lib.z.object({
+                extraThemeProperties: lib.z.array(lib.z.string()).optional(),
+                artifactId: lib.z.string().optional(),
+                groupId: lib.z.string().optional(),
+                loginThemeResourcesFromKeycloakVersion: lib.z.string().optional(),
+                projectBuildDirPath: lib.z.string().optional(),
+                keycloakifyBuildDirPath: lib.z.string().optional(),
+                themeName: lib.z.union([lib.z.string(), lib.z.array(lib.z.string())]).optional()
+            })
+                .optional()
+        });
+        {
+            (0,tsafe.assert)();
+            (0,tsafe.assert)();
+        }
+        return zParsedPackageJson.parse(JSON.parse(external_fs_.readFileSync((0,external_path_.join)(projectDirPath, "package.json")).toString("utf8")));
+    })();
+    const buildOptions = Object.assign(Object.assign({}, parsedPackageJson.keycloakify), resolvedViteConfig === null || resolvedViteConfig === void 0 ? void 0 : resolvedViteConfig.buildOptions);
+    const themeNames = (() => {
+        if (buildOptions.themeName === undefined) {
+            return [
+                parsedPackageJson.name
+                    .replace(/^@(.*)/, "$1")
+                    .split("/")
+                    .join("-")
+            ];
+        }
+        if (typeof buildOptions.themeName === "string") {
+            return [buildOptions.themeName];
+        }
+        return buildOptions.themeName;
+    })();
+    const projectBuildDirPath = (() => {
+        var _a;
+        webpack: {
+            if (resolvedViteConfig !== undefined) {
+                break webpack;
+            }
+            if (((_a = parsedPackageJson.keycloakify) === null || _a === void 0 ? void 0 : _a.projectBuildDirPath) !== undefined) {
+                return (0,getAbsoluteAndInOsFormatPath/* getAbsoluteAndInOsFormatPath */.c)({
+                    pathIsh: parsedPackageJson.keycloakify.projectBuildDirPath,
+                    cwd: projectDirPath
+                });
+            }
+            return (0,external_path_.join)(projectDirPath, "build");
+        }
+        return (0,external_path_.join)(projectDirPath, resolvedViteConfig.buildDir);
+    })();
+    const { npmWorkspaceRootDirPath } = getNpmWorkspaceRootDirPath({
+        projectDirPath,
+        dependencyExpected: "keycloakify"
+    });
+    return {
+        bundler: resolvedViteConfig !== undefined ? "vite" : "webpack",
+        themeVersion: (_b = (_a = process.env.KEYCLOAKIFY_THEME_VERSION) !== null && _a !== void 0 ? _a : parsedPackageJson.version) !== null && _b !== void 0 ? _b : "0.0.0",
+        themeNames,
+        extraThemeProperties: buildOptions.extraThemeProperties,
+        groupId: (() => {
+            var _a, _b, _c, _d, _e;
+            const fallbackGroupId = `${themeNames[0]}.keycloak`;
+            return ((_b = (_a = process.env.KEYCLOAKIFY_GROUP_ID) !== null && _a !== void 0 ? _a : buildOptions.groupId) !== null && _b !== void 0 ? _b : (parsedPackageJson.homepage === undefined
+                ? fallbackGroupId
+                : (_e = (_d = (_c = (0,external_url_.parse)(parsedPackageJson.homepage)
+                    .host) === null || _c === void 0 ? void 0 : _c.replace(/:[0-9]+$/, "")) === null || _d === void 0 ? void 0 : _d.split(".").reverse().join(".")) !== null && _e !== void 0 ? _e : fallbackGroupId) + ".keycloak");
+        })(),
+        artifactId: (_d = (_c = process.env.KEYCLOAKIFY_ARTIFACT_ID) !== null && _c !== void 0 ? _c : buildOptions.artifactId) !== null && _d !== void 0 ? _d : `${themeNames[0]}-keycloak-theme`,
+        loginThemeResourcesFromKeycloakVersion: (_e = buildOptions.loginThemeResourcesFromKeycloakVersion) !== null && _e !== void 0 ? _e : "24.0.4",
+        projectDirPath,
+        projectBuildDirPath,
+        keycloakifyBuildDirPath: (() => {
+            if (buildOptions.keycloakifyBuildDirPath !== undefined) {
+                return (0,getAbsoluteAndInOsFormatPath/* getAbsoluteAndInOsFormatPath */.c)({
+                    pathIsh: buildOptions.keycloakifyBuildDirPath,
+                    cwd: projectDirPath
+                });
+            }
+            return (0,external_path_.join)(projectDirPath, (resolvedViteConfig === null || resolvedViteConfig === void 0 ? void 0 : resolvedViteConfig.buildDir) === undefined
+                ? "build_keycloak"
+                : `${resolvedViteConfig.buildDir}_keycloak`);
+        })(),
+        publicDirPath: (() => {
+            webpack: {
+                if (resolvedViteConfig !== undefined) {
+                    break webpack;
+                }
+                if (process.env.PUBLIC_DIR_PATH !== undefined) {
+                    return (0,getAbsoluteAndInOsFormatPath/* getAbsoluteAndInOsFormatPath */.c)({
+                        pathIsh: process.env.PUBLIC_DIR_PATH,
+                        cwd: projectDirPath
+                    });
+                }
+                return (0,external_path_.join)(projectDirPath, "public");
+            }
+            return (0,external_path_.join)(projectDirPath, resolvedViteConfig.publicDir);
+        })(),
+        cacheDirPath: (() => {
+            const cacheDirPath = (0,external_path_.join)((() => {
+                if (process.env.XDG_CACHE_HOME !== undefined) {
+                    return (0,getAbsoluteAndInOsFormatPath/* getAbsoluteAndInOsFormatPath */.c)({
+                        pathIsh: process.env.XDG_CACHE_HOME,
+                        cwd: process.cwd()
+                    });
+                }
+                return (0,external_path_.join)(npmWorkspaceRootDirPath, "node_modules", ".cache");
+            })(), "keycloakify");
+            return cacheDirPath;
+        })(),
+        urlPathname: (() => {
+            webpack: {
+                if (resolvedViteConfig !== undefined) {
+                    break webpack;
+                }
+                const { homepage } = parsedPackageJson;
+                let url = undefined;
+                if (homepage !== undefined) {
+                    url = new URL(homepage);
+                }
+                if (url === undefined) {
+                    return undefined;
+                }
+                const out = url.pathname.replace(/([^/])$/, "$1/");
+                return out === "/" ? undefined : out;
+            }
+            return resolvedViteConfig.urlPathname;
+        })(),
+        assetsDirPath: (() => {
+            webpack: {
+                if (resolvedViteConfig !== undefined) {
+                    break webpack;
+                }
+                return (0,external_path_.join)(projectBuildDirPath, "static");
+            }
+            return (0,external_path_.join)(projectBuildDirPath, resolvedViteConfig.assetsDir);
+        })(),
+        npmWorkspaceRootDirPath,
+        kcContextExclusionsFtlCode: (() => {
+            if (buildOptions.kcContextExclusionsFtl === undefined) {
+                return undefined;
+            }
+            if (buildOptions.kcContextExclusionsFtl.endsWith(".ftl")) {
+                const kcContextExclusionsFtlPath = (0,getAbsoluteAndInOsFormatPath/* getAbsoluteAndInOsFormatPath */.c)({
+                    pathIsh: buildOptions.kcContextExclusionsFtl,
+                    cwd: projectDirPath
+                });
+                return external_fs_.readFileSync(kcContextExclusionsFtlPath).toString("utf8");
+            }
+            return buildOptions.kcContextExclusionsFtl;
+        })(),
+        environmentVariables: (_f = buildOptions.environmentVariables) !== null && _f !== void 0 ? _f : []
+    };
+}
+//# sourceMappingURL=buildContext.js.map
+
+/***/ }),
+
+/***/ 173:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "M": () => (/* binding */ basenameOfTheKeycloakifyResourcesDir),
+/* harmony export */   "N$": () => (/* binding */ keycloak_resources),
+/* harmony export */   "UX": () => (/* binding */ accountThemePageIds),
+/* harmony export */   "X4": () => (/* binding */ nameOfTheGlobal),
+/* harmony export */   "fe": () => (/* binding */ vitePluginSubScriptEnvNames),
+/* harmony export */   "h6": () => (/* binding */ containerName),
+/* harmony export */   "lg": () => (/* binding */ nameOfTheLocalizationRealmOverridesUserProfileProperty),
+/* harmony export */   "rO": () => (/* binding */ themeTypes),
+/* harmony export */   "sj": () => (/* binding */ loginThemePageIds),
+/* harmony export */   "uo": () => (/* binding */ skipBuildJarsEnvName),
+/* harmony export */   "v$": () => (/* binding */ lastKeycloakVersionWithAccountV1),
+/* harmony export */   "y_": () => (/* binding */ accountV1ThemeName),
+/* harmony export */   "z0": () => (/* binding */ resources_common)
+/* harmony export */ });
+const nameOfTheGlobal = "kcContext";
+const nameOfTheLocalizationRealmOverridesUserProfileProperty = "__localizationRealmOverridesUserProfile";
+const keycloak_resources = "keycloak-resources";
+const resources_common = "resources-common";
+const lastKeycloakVersionWithAccountV1 = "21.1.2";
+const basenameOfTheKeycloakifyResourcesDir = "build";
+const themeTypes = ["login", "account"];
+const accountV1ThemeName = "account-v1";
+const vitePluginSubScriptEnvNames = {
+    runPostBuildScript: "KEYCLOAKIFY_RUN_POST_BUILD_SCRIPT",
+    resolveViteConfig: "KEYCLOAKIFY_RESOLVE_VITE_CONFIG"
+};
+const skipBuildJarsEnvName = "KEYCLOAKIFY_SKIP_BUILD_JAR";
+const loginThemePageIds = [
+    "login.ftl",
+    "login-username.ftl",
+    "login-password.ftl",
+    "webauthn-authenticate.ftl",
+    "webauthn-register.ftl",
+    "register.ftl",
+    "info.ftl",
+    "error.ftl",
+    "login-reset-password.ftl",
+    "login-verify-email.ftl",
+    "terms.ftl",
+    "login-oauth2-device-verify-user-code.ftl",
+    "login-oauth-grant.ftl",
+    "login-otp.ftl",
+    "login-update-profile.ftl",
+    "login-update-password.ftl",
+    "login-idp-link-confirm.ftl",
+    "login-idp-link-email.ftl",
+    "login-page-expired.ftl",
+    "login-config-totp.ftl",
+    "logout-confirm.ftl",
+    "idp-review-user-profile.ftl",
+    "update-email.ftl",
+    "select-authenticator.ftl",
+    "saml-post-form.ftl",
+    "delete-credential.ftl",
+    "code.ftl",
+    "delete-account-confirm.ftl",
+    "frontchannel-logout.ftl",
+    "login-recovery-authn-code-config.ftl",
+    "login-recovery-authn-code-input.ftl",
+    "login-reset-otp.ftl",
+    "login-x509-info.ftl",
+    "webauthn-error.ftl"
+];
+const accountThemePageIds = [
+    "password.ftl",
+    "account.ftl",
+    "sessions.ftl",
+    "totp.ftl",
+    "applications.ftl",
+    "log.ftl",
+    "federatedIdentity.ftl"
+];
+const containerName = "keycloak-keycloakify";
+//# sourceMappingURL=constants.js.map
+
+/***/ }),
+
+/***/ 39216:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "f": () => (/* binding */ getThemeSrcDirPath)
+/* harmony export */ });
+/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(57147);
+/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(fs__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var tsafe__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(1666);
+/* harmony import */ var tsafe__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(tsafe__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _tools_crawl__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(73036);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(71017);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var _constants__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(173);
+
+
+
+
+
+const themeSrcDirBasenames = ["keycloak-theme", "keycloak_theme"];
+/** Can't catch error, if the directory isn't found, this function will just exit the process with an error message. */
+function getThemeSrcDirPath(params) {
+    const { projectDirPath } = params;
+    const srcDirPath = (0,path__WEBPACK_IMPORTED_MODULE_3__.join)(projectDirPath, "src");
+    const themeSrcDirPath = (0,_tools_crawl__WEBPACK_IMPORTED_MODULE_2__/* .crawl */ .J)({
+        dirPath: srcDirPath,
+        returnedPathsType: "relative to dirPath"
+    })
+        .map(fileRelativePath => {
+        for (const themeSrcDirBasename of themeSrcDirBasenames) {
+            const split = fileRelativePath.split(themeSrcDirBasename);
+            if (split.length === 2) {
+                return (0,path__WEBPACK_IMPORTED_MODULE_3__.join)(srcDirPath, split[0] + themeSrcDirBasename);
+            }
+        }
+        return undefined;
+    })
+        .filter((0,tsafe__WEBPACK_IMPORTED_MODULE_1__.exclude)(undefined))[0];
+    if (themeSrcDirPath !== undefined) {
+        return { themeSrcDirPath };
+    }
+    for (const themeType of [..._constants__WEBPACK_IMPORTED_MODULE_4__/* .themeTypes */ .rO, "email"]) {
+        if (!fs__WEBPACK_IMPORTED_MODULE_0__.existsSync((0,path__WEBPACK_IMPORTED_MODULE_3__.join)(srcDirPath, themeType))) {
+            continue;
+        }
+        return { themeSrcDirPath: srcDirPath };
+    }
+    console.error([
+        "Can't locate your theme source directory. It should be either: ",
+        "src/ or src/keycloak-theme or src/keycloak_theme.",
+        "Example in the starter: https://github.com/keycloakify/keycloakify-starter/tree/main/src/keycloak-theme"
+    ].join("\n"));
+    process.exit(-1);
+}
+//# sourceMappingURL=getThemeSrcDirPath.js.map
+
+/***/ }),
+
+/***/ 73036:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "J": () => (/* binding */ crawl)
+/* harmony export */ });
+/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(57147);
+/* 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__(71017);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_1__);
+
+
+const crawlRec = (dirPath, filePaths) => {
+    for (const basename of fs__WEBPACK_IMPORTED_MODULE_0__.readdirSync(dirPath)) {
+        const fileOrDirPath = (0,path__WEBPACK_IMPORTED_MODULE_1__.join)(dirPath, basename);
+        if (fs__WEBPACK_IMPORTED_MODULE_0__.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,path__WEBPACK_IMPORTED_MODULE_1__.relative)(dirPath, filePath));
+    }
+}
+//# sourceMappingURL=crawl.js.map
+
+/***/ }),
+
+/***/ 86644:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "c": () => (/* binding */ getAbsoluteAndInOsFormatPath)
+/* harmony export */ });
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(71017);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var os__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(22037);
+/* harmony import */ var os__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(os__WEBPACK_IMPORTED_MODULE_1__);
+
+
+function getAbsoluteAndInOsFormatPath(params) {
+    const { pathIsh, cwd } = params;
+    let pathOut = pathIsh;
+    pathOut = pathOut.replace(/\//g, path__WEBPACK_IMPORTED_MODULE_0__.sep);
+    if (pathOut.startsWith("~")) {
+        pathOut = pathOut.replace("~", os__WEBPACK_IMPORTED_MODULE_1__.homedir());
+    }
+    pathOut = pathOut.endsWith(path__WEBPACK_IMPORTED_MODULE_0__.sep) ? pathOut.slice(0, -1) : pathOut;
+    if (!(0,path__WEBPACK_IMPORTED_MODULE_0__.isAbsolute)(pathOut)) {
+        pathOut = (0,path__WEBPACK_IMPORTED_MODULE_0__.join)(cwd, pathOut);
+    }
+    pathOut = (0,path__WEBPACK_IMPORTED_MODULE_0__.resolve)(pathOut);
+    return pathOut;
+}
+//# sourceMappingURL=getAbsoluteAndInOsFormatPath.js.map
+
+/***/ }),
+
+/***/ 17192:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "A": () => (/* binding */ kebabCaseToCamelCase)
+/* harmony export */ });
+/* harmony import */ var tsafe_capitalize__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(61502);
+
+function kebabCaseToCamelCase(kebabCaseString) {
+    const [first, ...rest] = kebabCaseString.split("-");
+    return [first, ...rest.map(tsafe_capitalize__WEBPACK_IMPORTED_MODULE_0__.capitalize)].join("");
+}
+//# sourceMappingURL=kebabCaseToSnakeCase.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;
+
+/***/ }),
+
+/***/ 31621:
+/***/ ((module) => {
+
+
+
+module.exports = (flag, argv = process.argv) => {
+	const prefix = flag.startsWith('-') ? '' : (flag.length === 1 ? '-' : '--');
+	const position = argv.indexOf(prefix + flag);
+	const terminatorPosition = argv.indexOf('--');
+	return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+};
+
+
+/***/ }),
+
+/***/ 59318:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+
+const os = __webpack_require__(22037);
+const tty = __webpack_require__(76224);
+const hasFlag = __webpack_require__(31621);
+
+const {env} = process;
+
+let forceColor;
+if (hasFlag('no-color') ||
+	hasFlag('no-colors') ||
+	hasFlag('color=false') ||
+	hasFlag('color=never')) {
+	forceColor = 0;
+} else if (hasFlag('color') ||
+	hasFlag('colors') ||
+	hasFlag('color=true') ||
+	hasFlag('color=always')) {
+	forceColor = 1;
+}
+
+if ('FORCE_COLOR' in env) {
+	if (env.FORCE_COLOR === 'true') {
+		forceColor = 1;
+	} else if (env.FORCE_COLOR === 'false') {
+		forceColor = 0;
+	} else {
+		forceColor = env.FORCE_COLOR.length === 0 ? 1 : Math.min(parseInt(env.FORCE_COLOR, 10), 3);
+	}
+}
+
+function translateLevel(level) {
+	if (level === 0) {
+		return false;
+	}
+
+	return {
+		level,
+		hasBasic: true,
+		has256: level >= 2,
+		has16m: level >= 3
+	};
+}
+
+function supportsColor(haveStream, streamIsTTY) {
+	if (forceColor === 0) {
+		return 0;
+	}
+
+	if (hasFlag('color=16m') ||
+		hasFlag('color=full') ||
+		hasFlag('color=truecolor')) {
+		return 3;
+	}
+
+	if (hasFlag('color=256')) {
+		return 2;
+	}
+
+	if (haveStream && !streamIsTTY && forceColor === undefined) {
+		return 0;
+	}
+
+	const min = forceColor || 0;
+
+	if (env.TERM === 'dumb') {
+		return min;
+	}
+
+	if (process.platform === 'win32') {
+		// Windows 10 build 10586 is the first Windows release that supports 256 colors.
+		// Windows 10 build 14931 is the first release that supports 16m/TrueColor.
+		const osRelease = os.release().split('.');
+		if (
+			Number(osRelease[0]) >= 10 &&
+			Number(osRelease[2]) >= 10586
+		) {
+			return Number(osRelease[2]) >= 14931 ? 3 : 2;
+		}
+
+		return 1;
+	}
+
+	if ('CI' in env) {
+		if (['TRAVIS', 'CIRCLECI', 'APPVEYOR', 'GITLAB_CI', 'GITHUB_ACTIONS', 'BUILDKITE'].some(sign => sign in env) || env.CI_NAME === 'codeship') {
+			return 1;
+		}
+
+		return min;
+	}
+
+	if ('TEAMCITY_VERSION' in env) {
+		return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+	}
+
+	if (env.COLORTERM === 'truecolor') {
+		return 3;
+	}
+
+	if ('TERM_PROGRAM' in env) {
+		const version = parseInt((env.TERM_PROGRAM_VERSION || '').split('.')[0], 10);
+
+		switch (env.TERM_PROGRAM) {
+			case 'iTerm.app':
+				return version >= 3 ? 3 : 2;
+			case 'Apple_Terminal':
+				return 2;
+			// No default
+		}
+	}
+
+	if (/-256(color)?$/i.test(env.TERM)) {
+		return 2;
+	}
+
+	if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+		return 1;
+	}
+
+	if ('COLORTERM' in env) {
+		return 1;
+	}
+
+	return min;
+}
+
+function getSupportLevel(stream) {
+	const level = supportsColor(stream, stream && stream.isTTY);
+	return translateLevel(level);
+}
+
+module.exports = {
+	supportsColor: getSupportLevel,
+	stdout: translateLevel(supportsColor(true, tty.isatty(1))),
+	stderr: translateLevel(supportsColor(true, tty.isatty(2)))
+};
+
+
+/***/ })
+
+};
+;