keycloakify 10.0.0-rc.5 → 10.0.0-rc.50

package/bin/3.index.js

@@ -0,0 +1,1584 @@
+"use strict";
+exports.id = 3;
+exports.ids = [3];
+exports.modules = {
+
+/***/ 73923:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "k": () => (/* binding */ generateMessageProperties)
+/* harmony export */ });
+/* harmony import */ var _tools_crawl__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(73036);
+/* 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 fs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(57147);
+/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(fs__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var tsafe_symToStr__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(47986);
+/* harmony import */ var evt_tools_reducers_removeDuplicates__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(78300);
+/* harmony import */ var evt_tools_reducers_removeDuplicates__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(evt_tools_reducers_removeDuplicates__WEBPACK_IMPORTED_MODULE_4__);
+/* harmony import */ var recast__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(48128);
+/* harmony import */ var _babel_parser__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(85026);
+/* harmony import */ var _babel_generator__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(92332);
+/* harmony import */ var _babel_types__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(7912);
+/* harmony import */ var _babel_types__WEBPACK_IMPORTED_MODULE_8___default = /*#__PURE__*/__webpack_require__.n(_babel_types__WEBPACK_IMPORTED_MODULE_8__);
+/* harmony import */ var _tools_escapeStringForPropertiesFile__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(27190);
+
+
+
+
+
+
+
+
+
+
+function generateMessageProperties(params) {
+    const { themeSrcDirPath, themeType } = params;
+    let files = (0,_tools_crawl__WEBPACK_IMPORTED_MODULE_0__/* .crawl */ .J)({
+        dirPath: (0,path__WEBPACK_IMPORTED_MODULE_1__.join)(themeSrcDirPath, themeType),
+        returnedPathsType: "absolute"
+    });
+    files = files.filter(file => {
+        const regex = /\.(js|ts|tsx)$/;
+        return regex.test(file);
+    });
+    files = files.sort((a, b) => {
+        const regex = /\.i18n\.(ts|js|tsx)$/;
+        const aIsI18nFile = regex.test(a);
+        const bIsI18nFile = regex.test(b);
+        return aIsI18nFile === bIsI18nFile ? 0 : aIsI18nFile ? -1 : 1;
+    });
+    files = files.sort((a, b) => a.length - b.length);
+    files = files.filter(file => (0,fs__WEBPACK_IMPORTED_MODULE_2__.readFileSync)(file).toString("utf8").includes("createUseI18n"));
+    if (files.length === 0) {
+        return [];
+    }
+    const extraMessages = files
+        .map(file => {
+        const root = recast__WEBPACK_IMPORTED_MODULE_5__/* .parse */ .Qc((0,fs__WEBPACK_IMPORTED_MODULE_2__.readFileSync)(file).toString("utf8"), {
+            parser: {
+                parse: (code) => _babel_parser__WEBPACK_IMPORTED_MODULE_6__/* .parse */ .Qc(code, {
+                    sourceType: "module",
+                    plugins: ["typescript"]
+                }),
+                generator: _babel_generator__WEBPACK_IMPORTED_MODULE_7__/* ["default"] */ .ZP,
+                types: _babel_types__WEBPACK_IMPORTED_MODULE_8__
+            }
+        });
+        const codes = [];
+        recast__WEBPACK_IMPORTED_MODULE_5__/* .visit */ .Vn(root, {
+            visitCallExpression: function (path) {
+                if (path.node.callee.type === "Identifier" &&
+                    path.node.callee.name === "createUseI18n") {
+                    codes.push((0,_babel_generator__WEBPACK_IMPORTED_MODULE_7__/* ["default"] */ .ZP)(path.node.arguments[0]).code);
+                }
+                this.traverse(path);
+            }
+        });
+        return codes;
+    })
+        .flat()
+        .map(code => {
+        let extraMessages = {};
+        try {
+            eval(`${(0,tsafe_symToStr__WEBPACK_IMPORTED_MODULE_3__/* .symToStr */ .r)({ extraMessages })} = ${code}`);
+        }
+        catch (_a) {
+            console.warn([
+                "WARNING: Make sure that the first argument of createUseI18n can be evaluated in a javascript",
+                "runtime where only the node globals are available.",
+                "This is important because we need to put your i18n messages in messages_*.properties files",
+                "or they won't be available server side.",
+                "\n",
+                "The following code could not be evaluated:",
+                "\n",
+                code
+            ].join(" "));
+        }
+        return extraMessages;
+    });
+    const languageTags = extraMessages
+        .map(extraMessage => Object.keys(extraMessage))
+        .flat()
+        .reduce(...(0,evt_tools_reducers_removeDuplicates__WEBPACK_IMPORTED_MODULE_4__.removeDuplicates)());
+    const keyValueMapByLanguageTag = {};
+    for (const languageTag of languageTags) {
+        const keyValueMap = {};
+        for (const extraMessage of extraMessages) {
+            const keyValueMap_i = extraMessage[languageTag];
+            if (keyValueMap_i === undefined) {
+                continue;
+            }
+            for (const [key, value] of Object.entries(keyValueMap_i)) {
+                if (keyValueMap[key] !== undefined) {
+                    console.warn([
+                        "WARNING: The following key is defined multiple times:",
+                        "\n",
+                        key,
+                        "\n",
+                        "The following value will be ignored:",
+                        "\n",
+                        value,
+                        "\n",
+                        "The following value was already defined:",
+                        "\n",
+                        keyValueMap[key]
+                    ].join(" "));
+                    continue;
+                }
+                keyValueMap[key] = value;
+            }
+        }
+        keyValueMapByLanguageTag[languageTag] = keyValueMap;
+    }
+    const out = [];
+    for (const [languageTag, keyValueMap] of Object.entries(keyValueMapByLanguageTag)) {
+        const propertiesFileSource = Object.entries(keyValueMap)
+            .map(([key, value]) => `${key}=${(0,_tools_escapeStringForPropertiesFile__WEBPACK_IMPORTED_MODULE_9__/* .escapeStringForPropertiesFile */ .y)(value)}`)
+            .join("\n");
+        out.push({
+            languageTag,
+            propertiesFileSource: [
+                "# This file was generated by keycloakify",
+                "",
+                "parent=base",
+                "",
+                propertiesFileSource,
+                ""
+            ].join("\n")
+        });
+    }
+    return out;
+}
+//# sourceMappingURL=generateMessageProperties.js.map
+
+/***/ }),
+
+/***/ 56003:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "command": () => (/* reexport */ command)
+});
+
+// EXTERNAL MODULE: ./node_modules/tsafe/assert.js
+var assert = __webpack_require__(88078);
+// EXTERNAL MODULE: ./dist/bin/tools/transformCodebase.js
+var transformCodebase = __webpack_require__(60332);
+// EXTERNAL MODULE: external "fs"
+var external_fs_ = __webpack_require__(57147);
+var external_fs_default = /*#__PURE__*/__webpack_require__.n(external_fs_);
+// EXTERNAL MODULE: external "path"
+var external_path_ = __webpack_require__(71017);
+// EXTERNAL MODULE: ./dist/bin/shared/constants.js
+var constants = __webpack_require__(173);
+;// 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);
+}
+//# sourceMappingURL=String.prototype.replaceAll.js.map
+;// CONCATENATED MODULE: ./dist/bin/keycloakify/replacers/replaceImportsInJsCode/vite.js
+
+
+
+
+(0,assert.assert)();
+function replaceImportsInJsCode_vite(params) {
+    const { jsCode, buildContext, basenameOfAssetsFiles, systemType = external_path_.sep === "/" ? "posix" : "win32" } = params;
+    const { relative: pathRelative, sep: pathSep } = external_path_[systemType];
+    let fixedJsCode = jsCode;
+    replace_base_javacript_import: {
+        if (buildContext.urlPathname === undefined) {
+            break replace_base_javacript_import;
+        }
+        // Optimization
+        if (!jsCode.includes(buildContext.urlPathname)) {
+            break replace_base_javacript_import;
+        }
+        // Replace `Hv=function(e){return"/abcde12345/"+e}` by `Hv=function(e){return"/"+e}`
+        fixedJsCode = fixedJsCode.replace(new RegExp(`([\\w\\$][\\w\\d\\$]*)=function\\(([\\w\\$][\\w\\d\\$]*)\\)\\{return"${replaceAll(buildContext.urlPathname, "/", "\\/")}"\\+\\2\\}`, "g"), (...[, funcName, paramName]) => `${funcName}=function(${paramName}){return"/"+${paramName}}`);
+    }
+    replace_javascript_relatives_import_paths: {
+        // Example: "assets/ or "foo/bar/"
+        const staticDir = (() => {
+            let out = pathRelative(buildContext.projectBuildDirPath, buildContext.assetsDirPath);
+            out = replaceAll(out, pathSep, "/") + "/";
+            if (out === "/") {
+                throw new Error(`The assetsDirPath must be a subdirectory of projectBuildDirPath`);
+            }
+            return out;
+        })();
+        // Optimization
+        if (!jsCode.includes(staticDir)) {
+            break replace_javascript_relatives_import_paths;
+        }
+        basenameOfAssetsFiles
+            .map(basenameOfAssetsFile => `${staticDir}${basenameOfAssetsFile}`)
+            .forEach(relativePathOfAssetFile => {
+            var _a;
+            fixedJsCode = replaceAll(fixedJsCode, `"${relativePathOfAssetFile}"`, `(window.${constants/* nameOfTheGlobal */.X4}.url.resourcesPath.substring(1) + "/${constants/* basenameOfTheKeycloakifyResourcesDir */.M}/${relativePathOfAssetFile}")`);
+            fixedJsCode = replaceAll(fixedJsCode, `"${(_a = buildContext.urlPathname) !== null && _a !== void 0 ? _a : "/"}${relativePathOfAssetFile}"`, `(window.${constants/* nameOfTheGlobal */.X4}.url.resourcesPath + "/${constants/* basenameOfTheKeycloakifyResourcesDir */.M}/${relativePathOfAssetFile}")`);
+        });
+    }
+    return { fixedJsCode };
+}
+//# sourceMappingURL=vite.js.map
+;// CONCATENATED MODULE: ./dist/bin/keycloakify/replacers/replaceImportsInJsCode/webpack.js
+
+
+
+
+(0,assert.assert)();
+function replaceImportsInJsCode_webpack(params) {
+    const { jsCode, buildContext, systemType = external_path_.sep === "/" ? "posix" : "win32" } = params;
+    const { relative: pathRelative, sep: pathSep } = external_path_[systemType];
+    let fixedJsCode = jsCode;
+    if (buildContext.urlPathname !== undefined) {
+        // "__esModule",{value:!0})},n.p="/foo-bar/",function(){if("undefined"  -> ... n.p="/" ...
+        fixedJsCode = fixedJsCode.replace(new RegExp(`,([a-zA-Z]\\.[a-zA-Z])="${replaceAll(buildContext.urlPathname, "/", "\\/")}",`, "g"), (...[, assignTo]) => `,${assignTo}="/",`);
+    }
+    // Example: "static/ or "foo/bar/"
+    const staticDir = (() => {
+        let out = pathRelative(buildContext.projectBuildDirPath, buildContext.assetsDirPath);
+        out = replaceAll(out, pathSep, "/") + "/";
+        if (out === "/") {
+            throw new Error(`The assetsDirPath must be a subdirectory of projectBuildDirPath`);
+        }
+        return out;
+    })();
+    const getReplaceArgs = (language) => [
+        new RegExp(`([a-zA-Z_]+)\\.([a-zA-Z]+)=(function\\(([a-z]+)\\){return|([a-z]+)=>)"${staticDir.replace(/\//g, "\\/")}${language}\\/"`, "g"),
+        (...[, n, u, matchedFunction, eForFunction]) => {
+            const isArrowFunction = matchedFunction.includes("=>");
+            const e = isArrowFunction
+                ? matchedFunction.replace("=>", "").trim()
+                : eForFunction;
+            return `
+            ${n}[(function(){
+                var pd = Object.getOwnPropertyDescriptor(${n}, "p");
+                if( pd === undefined || pd.configurable ){
+                    Object.defineProperty(${n}, "p", {
+                        get: function() { return window.${constants/* nameOfTheGlobal */.X4}.url.resourcesPath; },
+                        set: function() {}
+                    });
+                }
+                return "${u}";
+            })()] = ${isArrowFunction ? `${e} =>` : `function(${e}) { return `} "/${constants/* basenameOfTheKeycloakifyResourcesDir */.M}/${staticDir}${language}/"`
+                .replace(/\s+/g, " ")
+                .trim();
+        }
+    ];
+    fixedJsCode = fixedJsCode
+        .replace(...getReplaceArgs("js"))
+        .replace(...getReplaceArgs("css"))
+        .replace(new RegExp(`[a-zA-Z]+\\.[a-zA-Z]+\\+"${staticDir.replace(/\//g, "\\/")}`, "g"), `window.${constants/* nameOfTheGlobal */.X4}.url.resourcesPath + "/${constants/* basenameOfTheKeycloakifyResourcesDir */.M}/${staticDir}`);
+    return { fixedJsCode };
+}
+//# sourceMappingURL=webpack.js.map
+;// CONCATENATED MODULE: ./dist/bin/keycloakify/replacers/replaceImportsInJsCode/replaceImportsInJsCode.js
+
+
+
+
+(0,assert.assert)();
+function replaceImportsInJsCode(params) {
+    const { jsCode, buildContext } = params;
+    const { fixedJsCode } = (() => {
+        switch (buildContext.bundler) {
+            case "vite":
+                return replaceImportsInJsCode_vite({
+                    jsCode,
+                    buildContext,
+                    basenameOfAssetsFiles: readAssetsDirSync({
+                        assetsDirPath: params.buildContext.assetsDirPath
+                    })
+                });
+            case "webpack":
+                return replaceImportsInJsCode_webpack({
+                    jsCode,
+                    buildContext
+                });
+        }
+    })();
+    return { fixedJsCode };
+}
+const { readAssetsDirSync } = (() => {
+    let cache = undefined;
+    function readAssetsDirSync(params) {
+        const { assetsDirPath } = params;
+        if (cache !== undefined && cache.assetsDirPath === assetsDirPath) {
+            return cache.basenameOfAssetsFiles;
+        }
+        const basenameOfAssetsFiles = external_fs_.readdirSync(assetsDirPath);
+        cache = {
+            assetsDirPath,
+            basenameOfAssetsFiles
+        };
+        return basenameOfAssetsFiles;
+    }
+    return { readAssetsDirSync };
+})();
+//# sourceMappingURL=replaceImportsInJsCode.js.map
+;// CONCATENATED MODULE: ./dist/bin/keycloakify/replacers/replaceImportsInJsCode/index.js
+
+//# sourceMappingURL=index.js.map
+// EXTERNAL MODULE: external "crypto"
+var external_crypto_ = __webpack_require__(6113);
+;// CONCATENATED MODULE: ./dist/bin/keycloakify/replacers/replaceImportsInCssCode.js
+
+
+
+(0,assert.assert)();
+function replaceImportsInCssCode(params) {
+    var _a;
+    const { cssCode } = params;
+    const cssGlobalsToDefine = {};
+    new Set((_a = cssCode.match(/url\(["']?\/[^/][^)"']+["']?\)[^;}]*?/g)) !== null && _a !== void 0 ? _a : []).forEach(match => (cssGlobalsToDefine["url" +
+        external_crypto_.createHash("sha256")
+            .update(match)
+            .digest("hex")
+            .substring(0, 15)] = match));
+    let fixedCssCode = cssCode;
+    Object.keys(cssGlobalsToDefine).forEach(cssVariableName => 
+    //NOTE: split/join pattern ~ replace all
+    (fixedCssCode = fixedCssCode
+        .split(cssGlobalsToDefine[cssVariableName])
+        .join(`var(--${cssVariableName})`)));
+    return { fixedCssCode, cssGlobalsToDefine };
+}
+function generateCssCodeToDefineGlobals(params) {
+    const { cssGlobalsToDefine, buildContext } = params;
+    return {
+        cssCodeToPrependInHead: [
+            ":root {",
+            ...Object.keys(cssGlobalsToDefine)
+                .map(cssVariableName => {
+                var _a;
+                return [
+                    `--${cssVariableName}:`,
+                    cssGlobalsToDefine[cssVariableName].replace(new RegExp(`url\\(${((_a = buildContext.urlPathname) !== null && _a !== void 0 ? _a : "/").replace(/\//g, "\\/")}`, "g"), `url(\${url.resourcesPath}/${constants/* basenameOfTheKeycloakifyResourcesDir */.M}/`)
+                ].join(" ");
+            })
+                .map(line => `    ${line};`),
+            "}"
+        ].join("\n")
+    };
+}
+//# sourceMappingURL=replaceImportsInCssCode.js.map
+// EXTERNAL MODULE: ./node_modules/cheerio/lib/esm/index.js + 76 modules
+var esm = __webpack_require__(87182);
+;// CONCATENATED MODULE: ./dist/bin/keycloakify/replacers/replaceImportsInInlineCssCode.js
+
+
+(0,assert.assert)();
+function replaceImportsInInlineCssCode(params) {
+    const { cssCode, buildContext } = params;
+    const fixedCssCode = cssCode.replace(buildContext.urlPathname === undefined
+        ? /url\(["']?\/([^/][^)"']+)["']?\)/g
+        : new RegExp(`url\\(["']?${buildContext.urlPathname}([^)"']+)["']?\\)`, "g"), (...[, group]) => `url(\${url.resourcesPath}/${constants/* basenameOfTheKeycloakifyResourcesDir */.M}/${group})`);
+    return { fixedCssCode };
+}
+//# sourceMappingURL=replaceImportsInInlineCssCode.js.map
+// EXTERNAL MODULE: ./dist/bin/tools/getThisCodebaseRootDirPath.js
+var getThisCodebaseRootDirPath = __webpack_require__(58822);
+;// CONCATENATED MODULE: ./dist/bin/keycloakify/generateFtl/generateFtl.js
+
+
+
+
+
+
+
+
+
+(0,assert.assert)();
+function generateFtlFilesCodeFactory(params) {
+    var _a;
+    const { themeName, cssGlobalsToDefine, indexHtmlCode, buildContext, keycloakifyVersion, themeType, fieldNames } = params;
+    const $ = esm/* default.load */.ZP.load(indexHtmlCode);
+    fix_imports_statements: {
+        $("script:not([src])").each((...[, element]) => {
+            const jsCode = $(element).html();
+            (0,assert.assert)(jsCode !== null);
+            const { fixedJsCode } = replaceImportsInJsCode({
+                jsCode,
+                buildContext
+            });
+            $(element).text(fixedJsCode);
+        });
+        $("style").each((...[, element]) => {
+            const cssCode = $(element).html();
+            (0,assert.assert)(cssCode !== null);
+            const { fixedCssCode } = replaceImportsInInlineCssCode({
+                cssCode,
+                buildContext
+            });
+            $(element).text(fixedCssCode);
+        });
+        [
+            ["link", "href"],
+            ["script", "src"]
+        ].forEach(([selector, attrName]) => $(selector).each((...[, element]) => {
+            var _a;
+            const href = $(element).attr(attrName);
+            if (href === undefined) {
+                return;
+            }
+            $(element).attr(attrName, href.replace(new RegExp(`^${((_a = buildContext.urlPathname) !== null && _a !== void 0 ? _a : "/").replace(/\//g, "\\/")}`), `\${url.resourcesPath}/${constants/* basenameOfTheKeycloakifyResourcesDir */.M}/`));
+        }));
+        if (Object.keys(cssGlobalsToDefine).length !== 0) {
+            $("head").prepend([
+                "",
+                "<style>",
+                generateCssCodeToDefineGlobals({
+                    cssGlobalsToDefine,
+                    buildContext
+                }).cssCodeToPrependInHead,
+                "</style>",
+                ""
+            ].join("\n"));
+        }
+    }
+    //FTL is no valid html, we can't insert with cheerio, we put placeholder for injecting later.
+    const ftlObjectToJsCodeDeclaringAnObject = external_fs_.readFileSync((0,external_path_.join)((0,getThisCodebaseRootDirPath/* getThisCodebaseRootDirPath */.e)(), "src", "bin", "keycloakify", "generateFtl", "ftl_object_to_js_code_declaring_an_object.ftl"))
+        .toString("utf8")
+        .match(/^<script>const _=((?:.|\n)+)<\/script>[\n]?$/)[1]
+        .replace("FIELD_NAMES_eKsIY4ZsZ4xeM", fieldNames.map(name => `"${name}"`).join(", "))
+        .replace("KEYCLOAKIFY_VERSION_xEdKd3xEdr", keycloakifyVersion)
+        .replace("KEYCLOAKIFY_THEME_VERSION_sIgKd3xEdr3dx", buildContext.themeVersion)
+        .replace("KEYCLOAKIFY_THEME_TYPE_dExKd3xEdr", themeType)
+        .replace("KEYCLOAKIFY_THEME_NAME_cXxKd3xEer", themeName)
+        .replace("RESOURCES_COMMON_cLsLsMrtDkpVv", constants/* resources_common */.z0)
+        .replace("lOCALIZATION_REALM_OVERRIDES_USER_PROFILE_PROPERTY_KEY_aaGLsPgGIdeeX", constants/* nameOfTheLocalizationRealmOverridesUserProfileProperty */.lg)
+        .replace("USER_DEFINED_EXCLUSIONS_eKsaY4ZsZ4eMr2", (_a = buildContext.kcContextExclusionsFtlCode) !== null && _a !== void 0 ? _a : "");
+    const ftlObjectToJsCodeDeclaringAnObjectPlaceholder = '{ "x": "vIdLqMeOed9sdLdIdOxdK0d" }';
+    $("head").prepend(`<script>\nwindow.${constants/* nameOfTheGlobal */.X4}=${ftlObjectToJsCodeDeclaringAnObjectPlaceholder}</script>`);
+    // Remove part of the document marked as ignored.
+    {
+        const startTags = $('meta[name="keycloakify-ignore-start"]');
+        startTags.each((...[, startTag]) => {
+            const $startTag = $(startTag);
+            const $endTag = $startTag
+                .nextAll('meta[name="keycloakify-ignore-end"]')
+                .first();
+            if ($endTag.length) {
+                let currentNode = $startTag.next();
+                while (currentNode.length && !currentNode.is($endTag)) {
+                    currentNode.remove();
+                    currentNode = $startTag.next();
+                }
+                $startTag.remove();
+                $endTag.remove();
+            }
+        });
+    }
+    const partiallyFixedIndexHtmlCode = $.html();
+    function generateFtlFilesCode(params) {
+        const { pageId } = params;
+        const $ = esm/* default.load */.ZP.load(partiallyFixedIndexHtmlCode);
+        let ftlCode = $.html();
+        Object.entries({
+            [ftlObjectToJsCodeDeclaringAnObjectPlaceholder]: ftlObjectToJsCodeDeclaringAnObject,
+            PAGE_ID_xIgLsPgGId9D8e: pageId
+        }).map(([searchValue, replaceValue]) => (ftlCode = ftlCode.replace(searchValue, replaceValue)));
+        return { ftlCode };
+    }
+    return { generateFtlFilesCode };
+}
+//# sourceMappingURL=generateFtl.js.map
+;// CONCATENATED MODULE: ./dist/bin/keycloakify/generateFtl/index.js
+
+//# sourceMappingURL=index.js.map
+// EXTERNAL MODULE: ./dist/bin/tools/isInside.js
+var isInside = __webpack_require__(90665);
+// EXTERNAL MODULE: ./dist/bin/shared/downloadKeycloakStaticResources.js
+var downloadKeycloakStaticResources = __webpack_require__(62190);
+// EXTERNAL MODULE: ./dist/bin/tools/crawl.js
+var crawl = __webpack_require__(73036);
+;// CONCATENATED MODULE: ./dist/bin/keycloakify/generateSrcMainResources/readFieldNameUsage.js
+
+
+
+
+/** Assumes the theme type exists */
+function readFieldNameUsage(params) {
+    const { themeSrcDirPath, themeType } = params;
+    const fieldNames = new Set();
+    for (const srcDirPath of [
+        (0,external_path_.join)((0,getThisCodebaseRootDirPath/* getThisCodebaseRootDirPath */.e)(), "src", themeType),
+        (0,external_path_.join)(themeSrcDirPath, themeType)
+    ]) {
+        const filePaths = (0,crawl/* crawl */.J)({
+            dirPath: srcDirPath,
+            returnedPathsType: "absolute"
+        }).filter(filePath => /\.(ts|tsx|js|jsx)$/.test(filePath));
+        for (const filePath of filePaths) {
+            const rawSourceFile = external_fs_.readFileSync(filePath).toString("utf8");
+            if (!rawSourceFile.includes("messagesPerField")) {
+                continue;
+            }
+            for (const functionName of [
+                "printIfExists",
+                "existsError",
+                "get",
+                "exists",
+                "getFirstError"
+            ]) {
+                if (!rawSourceFile.includes(functionName)) {
+                    continue;
+                }
+                try {
+                    rawSourceFile
+                        .split(functionName)
+                        .filter(part => part.startsWith("("))
+                        .map(part => {
+                        let [p1] = part.split(")");
+                        p1 = p1.slice(1);
+                        return p1;
+                    })
+                        .map(part => {
+                        return part
+                            .split(",")
+                            .map(a => a.trim())
+                            .filter((...[, i]) => functionName !== "printIfExists" ? true : i === 0)
+                            .filter(a => a.startsWith('"') ||
+                            a.startsWith("'") ||
+                            a.startsWith("`"))
+                            .filter(a => a.endsWith('"') ||
+                            a.endsWith("'") ||
+                            a.endsWith("`"))
+                            .map(a => a.slice(1).slice(0, -1));
+                    })
+                        .flat()
+                        .forEach(fieldName => fieldNames.add(fieldName));
+                }
+                catch (_a) { }
+            }
+        }
+    }
+    return Array.from(fieldNames);
+}
+//# sourceMappingURL=readFieldNameUsage.js.map
+// EXTERNAL MODULE: ./node_modules/tsafe/id.js
+var id = __webpack_require__(43047);
+// EXTERNAL MODULE: ./node_modules/evt/tools/reducers/removeDuplicates.js
+var removeDuplicates = __webpack_require__(78300);
+;// CONCATENATED MODULE: ./dist/bin/keycloakify/generateSrcMainResources/readExtraPageNames.js
+
+
+
+
+
+
+function readExtraPagesNames(params) {
+    const { themeSrcDirPath, themeType } = params;
+    const filePaths = (0,crawl/* crawl */.J)({
+        dirPath: (0,external_path_.join)(themeSrcDirPath, themeType),
+        returnedPathsType: "absolute"
+    }).filter(filePath => /\.(ts|tsx|js|jsx)$/.test(filePath));
+    const candidateFilePaths = filePaths.filter(filePath => /[kK]cContext\.[^.]+$/.test(filePath));
+    if (candidateFilePaths.length === 0) {
+        candidateFilePaths.push(...filePaths);
+    }
+    const extraPages = [];
+    for (const candidateFilPath of candidateFilePaths) {
+        const rawSourceFile = external_fs_.readFileSync(candidateFilPath).toString("utf8");
+        extraPages.push(...Array.from(rawSourceFile.matchAll(/["']?pageId["']?\s*:\s*["']([^.]+.ftl)["']/g), m => m[1]));
+    }
+    return extraPages.reduce(...(0,removeDuplicates.removeDuplicates)()).filter(pageId => {
+        switch (themeType) {
+            case "account":
+                return !(0,id.id)(constants/* accountThemePageIds */.UX).includes(pageId);
+            case "login":
+                return !(0,id.id)(constants/* loginThemePageIds */.sj).includes(pageId);
+        }
+    });
+}
+//# sourceMappingURL=readExtraPageNames.js.map
+// EXTERNAL MODULE: ./dist/bin/keycloakify/generateSrcMainResources/generateMessageProperties.js
+var generateMessageProperties = __webpack_require__(73923);
+// EXTERNAL MODULE: ./dist/bin/shared/downloadKeycloakDefaultTheme.js + 3 modules
+var downloadKeycloakDefaultTheme = __webpack_require__(47802);
+;// CONCATENATED MODULE: ./dist/bin/keycloakify/generateSrcMainResources/bringInAccountV1.js
+
+
+
+
+
+
+(0,assert.assert)();
+async function bringInAccountV1(params) {
+    const { resourcesDirPath, buildContext } = params;
+    const { defaultThemeDirPath } = await (0,downloadKeycloakDefaultTheme/* downloadKeycloakDefaultTheme */.x)({
+        keycloakVersion: constants/* lastKeycloakVersionWithAccountV1 */.v$,
+        buildContext
+    });
+    const accountV1DirPath = (0,external_path_.join)(resourcesDirPath, "theme", constants/* accountV1ThemeName */.y_, "account");
+    (0,transformCodebase/* transformCodebase */.N)({
+        srcDirPath: (0,external_path_.join)(defaultThemeDirPath, "base", "account"),
+        destDirPath: accountV1DirPath
+    });
+    (0,transformCodebase/* transformCodebase */.N)({
+        srcDirPath: (0,external_path_.join)(defaultThemeDirPath, "keycloak", "account", "resources"),
+        destDirPath: (0,external_path_.join)(accountV1DirPath, "resources")
+    });
+    (0,transformCodebase/* transformCodebase */.N)({
+        srcDirPath: (0,external_path_.join)(defaultThemeDirPath, "keycloak", "common", "resources"),
+        destDirPath: (0,external_path_.join)(accountV1DirPath, "resources", constants/* resources_common */.z0)
+    });
+    external_fs_.writeFileSync((0,external_path_.join)(accountV1DirPath, "theme.properties"), Buffer.from([
+        "accountResourceProvider=account-v1",
+        "",
+        "locales=ar,ca,cs,da,de,en,es,fr,fi,hu,it,ja,lt,nl,no,pl,pt-BR,ru,sk,sv,tr,zh-CN",
+        "",
+        "styles=" +
+            [
+                "css/account.css",
+                "img/icon-sidebar-active.png",
+                "img/logo.png",
+                ...[
+                    "patternfly.min.css",
+                    "patternfly-additions.min.css",
+                    "patternfly-additions.min.css"
+                ].map(fileBasename => `${constants/* resources_common */.z0}/node_modules/patternfly/dist/css/${fileBasename}`)
+            ].join(" "),
+        "",
+        "##### css classes for form buttons",
+        "# main class used for all buttons",
+        "kcButtonClass=btn",
+        "# classes defining priority of the button - primary or default (there is typically only one priority button for the form)",
+        "kcButtonPrimaryClass=btn-primary",
+        "kcButtonDefaultClass=btn-default",
+        "# classes defining size of the button",
+        "kcButtonLargeClass=btn-lg",
+        ""
+    ].join("\n"), "utf8"));
+}
+//# sourceMappingURL=bringInAccountV1.js.map
+// EXTERNAL MODULE: ./dist/bin/shared/getThemeSrcDirPath.js
+var getThemeSrcDirPath = __webpack_require__(39216);
+// EXTERNAL MODULE: ./dist/bin/tools/fs.rmSync.js
+var fs_rmSync = __webpack_require__(89693);
+// EXTERNAL MODULE: ./dist/bin/tools/readThisNpmPackageVersion.js
+var readThisNpmPackageVersion = __webpack_require__(64795);
+// EXTERNAL MODULE: ./dist/bin/shared/metaInfKeycloakThemes.js
+var shared_metaInfKeycloakThemes = __webpack_require__(26914);
+// EXTERNAL MODULE: ./node_modules/tsafe/objectEntries.js
+var objectEntries = __webpack_require__(39612);
+// EXTERNAL MODULE: ./dist/bin/tools/escapeStringForPropertiesFile.js
+var escapeStringForPropertiesFile = __webpack_require__(27190);
+;// CONCATENATED MODULE: ./dist/bin/keycloakify/generateSrcMainResources/generateSrcMainResourcesForMainTheme.js
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+(0,assert.assert)();
+async function generateSrcMainResourcesForMainTheme(params) {
+    var _a;
+    const { themeName, resourcesDirPath, buildContext } = params;
+    const { themeSrcDirPath } = (0,getThemeSrcDirPath/* getThemeSrcDirPath */.f)({
+        projectDirPath: buildContext.projectDirPath
+    });
+    const getThemeTypeDirPath = (params) => {
+        const { themeType } = params;
+        return (0,external_path_.join)(resourcesDirPath, "theme", themeName, themeType);
+    };
+    const cssGlobalsToDefine = {};
+    const implementedThemeTypes = {
+        login: false,
+        account: false,
+        email: false
+    };
+    for (const themeType of ["login", "account"]) {
+        if (!external_fs_.existsSync((0,external_path_.join)(themeSrcDirPath, themeType))) {
+            continue;
+        }
+        implementedThemeTypes[themeType] = true;
+        const themeTypeDirPath = getThemeTypeDirPath({ themeType });
+        apply_replacers_and_move_to_theme_resources: {
+            const destDirPath = (0,external_path_.join)(themeTypeDirPath, "resources", constants/* basenameOfTheKeycloakifyResourcesDir */.M);
+            // NOTE: Prevent accumulation of files in the assets dir, as names are hashed they pile up.
+            (0,fs_rmSync/* rmSync */.a)(destDirPath, { recursive: true, force: true });
+            if (themeType === "account" && implementedThemeTypes.login) {
+                // NOTE: We prevent doing it twice, it has been done for the login theme.
+                (0,transformCodebase/* transformCodebase */.N)({
+                    srcDirPath: (0,external_path_.join)(getThemeTypeDirPath({
+                        themeType: "login"
+                    }), "resources", constants/* basenameOfTheKeycloakifyResourcesDir */.M),
+                    destDirPath
+                });
+                break apply_replacers_and_move_to_theme_resources;
+            }
+            (0,transformCodebase/* transformCodebase */.N)({
+                srcDirPath: buildContext.projectBuildDirPath,
+                destDirPath,
+                transformSourceCode: ({ filePath, sourceCode }) => {
+                    //NOTE: Prevent cycles, excludes the folder we generated for debug in public/
+                    // This should not happen if users follow the new instruction setup but we keep it for retrocompatibility.
+                    if ((0,isInside/* isInside */.V)({
+                        dirPath: (0,external_path_.join)(buildContext.projectBuildDirPath, constants/* keycloak_resources */.N$),
+                        filePath
+                    })) {
+                        return undefined;
+                    }
+                    if (/\.css?$/i.test(filePath)) {
+                        const { cssGlobalsToDefine: cssGlobalsToDefineForThisFile, fixedCssCode } = replaceImportsInCssCode({
+                            cssCode: sourceCode.toString("utf8")
+                        });
+                        Object.entries(cssGlobalsToDefineForThisFile).forEach(([key, value]) => {
+                            cssGlobalsToDefine[key] = value;
+                        });
+                        return {
+                            modifiedSourceCode: Buffer.from(fixedCssCode, "utf8")
+                        };
+                    }
+                    if (/\.js?$/i.test(filePath)) {
+                        const { fixedJsCode } = replaceImportsInJsCode({
+                            jsCode: sourceCode.toString("utf8"),
+                            buildContext
+                        });
+                        return {
+                            modifiedSourceCode: Buffer.from(fixedJsCode, "utf8")
+                        };
+                    }
+                    return { modifiedSourceCode: sourceCode };
+                }
+            });
+        }
+        const { generateFtlFilesCode } = generateFtlFilesCodeFactory({
+            themeName,
+            indexHtmlCode: external_fs_.readFileSync((0,external_path_.join)(buildContext.projectBuildDirPath, "index.html"))
+                .toString("utf8"),
+            cssGlobalsToDefine,
+            buildContext,
+            keycloakifyVersion: (0,readThisNpmPackageVersion/* readThisNpmPackageVersion */.K)(),
+            themeType,
+            fieldNames: readFieldNameUsage({
+                themeSrcDirPath,
+                themeType
+            })
+        });
+        [
+            ...(() => {
+                switch (themeType) {
+                    case "login":
+                        return constants/* loginThemePageIds */.sj;
+                    case "account":
+                        return constants/* accountThemePageIds */.UX;
+                }
+            })(),
+            ...readExtraPagesNames({
+                themeType,
+                themeSrcDirPath
+            })
+        ].forEach(pageId => {
+            const { ftlCode } = generateFtlFilesCode({ pageId });
+            external_fs_.writeFileSync((0,external_path_.join)(themeTypeDirPath, pageId), Buffer.from(ftlCode, "utf8"));
+        });
+        (0,generateMessageProperties/* generateMessageProperties */.k)({
+            themeSrcDirPath,
+            themeType
+        }).forEach(({ languageTag, propertiesFileSource }) => {
+            const messagesDirPath = (0,external_path_.join)(themeTypeDirPath, "messages");
+            external_fs_.mkdirSync((0,external_path_.join)(themeTypeDirPath, "messages"), {
+                recursive: true
+            });
+            const propertiesFilePath = (0,external_path_.join)(messagesDirPath, `messages_${languageTag}.properties`);
+            external_fs_.writeFileSync(propertiesFilePath, Buffer.from(propertiesFileSource, "utf8"));
+        });
+        await (0,downloadKeycloakStaticResources/* downloadKeycloakStaticResources */.p)({
+            keycloakVersion: (() => {
+                switch (themeType) {
+                    case "account":
+                        return constants/* lastKeycloakVersionWithAccountV1 */.v$;
+                    case "login":
+                        return buildContext.loginThemeResourcesFromKeycloakVersion;
+                }
+            })(),
+            themeDirPath: (0,external_path_.resolve)((0,external_path_.join)(themeTypeDirPath, "..")),
+            themeType,
+            buildContext
+        });
+        external_fs_.writeFileSync((0,external_path_.join)(themeTypeDirPath, "theme.properties"), Buffer.from([
+            `parent=${(() => {
+                switch (themeType) {
+                    case "account":
+                        return constants/* accountV1ThemeName */.y_;
+                    case "login":
+                        return "keycloak";
+                }
+                (0,assert.assert)(false);
+            })()}`,
+            ...((_a = buildContext.extraThemeProperties) !== null && _a !== void 0 ? _a : []),
+            buildContext.environmentVariables.map(({ name, default: defaultValue }) => `${name}=\${env.${name}:${(0,escapeStringForPropertiesFile/* escapeStringForPropertiesFile */.y)(defaultValue)}}`)
+        ].join("\n\n"), "utf8"));
+    }
+    email: {
+        const emailThemeSrcDirPath = (0,external_path_.join)(themeSrcDirPath, "email");
+        if (!external_fs_.existsSync(emailThemeSrcDirPath)) {
+            break email;
+        }
+        implementedThemeTypes.email = true;
+        (0,transformCodebase/* transformCodebase */.N)({
+            srcDirPath: emailThemeSrcDirPath,
+            destDirPath: getThemeTypeDirPath({ themeType: "email" })
+        });
+    }
+    if (implementedThemeTypes.account) {
+        await bringInAccountV1({
+            resourcesDirPath,
+            buildContext
+        });
+    }
+    {
+        const metaInfKeycloakThemes = { themes: [] };
+        metaInfKeycloakThemes.themes.push({
+            name: themeName,
+            types: (0,objectEntries.objectEntries)(implementedThemeTypes)
+                .filter(([, isImplemented]) => isImplemented)
+                .map(([themeType]) => themeType)
+        });
+        if (implementedThemeTypes.account) {
+            metaInfKeycloakThemes.themes.push({
+                name: constants/* accountV1ThemeName */.y_,
+                types: ["account"]
+            });
+        }
+        (0,shared_metaInfKeycloakThemes/* writeMetaInfKeycloakThemes */.JJ)({
+            resourcesDirPath,
+            metaInfKeycloakThemes
+        });
+    }
+}
+//# sourceMappingURL=generateSrcMainResourcesForMainTheme.js.map
+;// CONCATENATED MODULE: ./dist/bin/keycloakify/generateSrcMainResources/generateSrcMainResourcesForThemeVariant.js
+
+
+
+
+(0,assert.assert)();
+function generateSrcMainResourcesForThemeVariant(params) {
+    const { resourcesDirPath, themeName, themeVariantName } = params;
+    const mainThemeDirPath = (0,external_path_.join)(resourcesDirPath, "theme", themeName);
+    (0,transformCodebase/* transformCodebase */.N)({
+        srcDirPath: mainThemeDirPath,
+        destDirPath: (0,external_path_.join)(mainThemeDirPath, "..", themeVariantName),
+        transformSourceCode: ({ fileRelativePath, sourceCode }) => {
+            if ((0,external_path_.extname)(fileRelativePath) === ".ftl" &&
+                fileRelativePath.split(external_path_.sep).length === 2) {
+                const modifiedSourceCode = Buffer.from(Buffer.from(sourceCode)
+                    .toString("utf-8")
+                    .replace(`out["themeName"] = "${themeName}";`, `out["themeName"] = "${themeVariantName}";`), "utf8");
+                (0,assert.assert)(Buffer.compare(modifiedSourceCode, sourceCode) !== 0);
+                return { modifiedSourceCode };
+            }
+            return { modifiedSourceCode: sourceCode };
+        }
+    });
+    {
+        const updatedMetaInfKeycloakThemes = (0,shared_metaInfKeycloakThemes/* readMetaInfKeycloakThemes_fromResourcesDirPath */.Ju)({
+            resourcesDirPath
+        });
+        updatedMetaInfKeycloakThemes.themes.push({
+            name: themeVariantName,
+            types: (() => {
+                const theme = updatedMetaInfKeycloakThemes.themes.find(({ name }) => name === themeName);
+                (0,assert.assert)(theme !== undefined);
+                return theme.types;
+            })()
+        });
+        (0,shared_metaInfKeycloakThemes/* writeMetaInfKeycloakThemes */.JJ)({
+            resourcesDirPath,
+            metaInfKeycloakThemes: updatedMetaInfKeycloakThemes
+        });
+    }
+}
+//# sourceMappingURL=generateSrcMainResourcesForThemeVariant.js.map
+;// CONCATENATED MODULE: ./dist/bin/keycloakify/generateSrcMainResources/generateSrcMainResources.js
+
+
+
+
+
+(0,assert.assert)();
+async function generateSrcMainResources(params) {
+    const { resourcesDirPath, buildContext } = params;
+    const [themeName, ...themeVariantNames] = buildContext.themeNames;
+    if (external_fs_default().existsSync(resourcesDirPath)) {
+        (0,fs_rmSync/* rmSync */.a)(resourcesDirPath, { recursive: true });
+    }
+    await generateSrcMainResourcesForMainTheme({
+        resourcesDirPath,
+        themeName,
+        buildContext
+    });
+    for (const themeVariantName of themeVariantNames) {
+        generateSrcMainResourcesForThemeVariant({
+            resourcesDirPath,
+            themeName,
+            themeVariantName
+        });
+    }
+}
+//# sourceMappingURL=generateSrcMainResources.js.map
+;// CONCATENATED MODULE: ./dist/bin/keycloakify/generateSrcMainResources/index.js
+
+//# sourceMappingURL=index.js.map
+// EXTERNAL MODULE: external "child_process"
+var external_child_process_ = __webpack_require__(32081);
+var external_child_process_default = /*#__PURE__*/__webpack_require__.n(external_child_process_);
+// EXTERNAL MODULE: ./dist/bin/shared/buildContext.js + 1 modules
+var shared_buildContext = __webpack_require__(87751);
+// EXTERNAL MODULE: ./node_modules/tsafe/exclude.js
+var exclude = __webpack_require__(41370);
+;// CONCATENATED MODULE: ./dist/bin/keycloakify/buildJars/extensionVersions.js
+// NOTE: v0.5 is a dummy version.
+const keycloakAccountV1Versions = [null, "0.3", "0.4", "0.6"];
+const keycloakThemeAdditionalInfoExtensionVersions = [null, "1.1.5"];
+//# sourceMappingURL=extensionVersions.js.map
+;// CONCATENATED MODULE: ./dist/bin/keycloakify/buildJars/getKeycloakVersionRangeForJar.js
+
+function getKeycloakVersionRangeForJar(params) {
+    const { keycloakAccountV1Version, keycloakThemeAdditionalInfoExtensionVersion, doesImplementAccountTheme } = params;
+    if (doesImplementAccountTheme) {
+        const keycloakVersionRange = (() => {
+            switch (keycloakAccountV1Version) {
+                case null:
+                    switch (keycloakThemeAdditionalInfoExtensionVersion) {
+                        case null:
+                            return "21-and-below";
+                        case "1.1.5":
+                            return undefined;
+                    }
+                    (0,assert.assert)(false);
+                case "0.3":
+                    switch (keycloakThemeAdditionalInfoExtensionVersion) {
+                        case null:
+                            return undefined;
+                        case "1.1.5":
+                            return "23";
+                    }
+                    (0,assert.assert)(false);
+                case "0.4":
+                    switch (keycloakThemeAdditionalInfoExtensionVersion) {
+                        case null:
+                            return undefined;
+                        case "1.1.5":
+                            return "24";
+                    }
+                    (0,assert.assert)(false);
+                case "0.6":
+                    switch (keycloakThemeAdditionalInfoExtensionVersion) {
+                        case null:
+                            return undefined;
+                        case "1.1.5":
+                            return "25-and-above";
+                    }
+            }
+            (0,assert.assert)(false);
+        })();
+        (0,assert.assert)();
+        return keycloakVersionRange;
+    }
+    else {
+        const keycloakVersionRange = (() => {
+            if (keycloakAccountV1Version !== null) {
+                return undefined;
+            }
+            switch (keycloakThemeAdditionalInfoExtensionVersion) {
+                case null:
+                    return "21-and-below";
+                case "1.1.5":
+                    return "22-and-above";
+            }
+            (0,assert.assert)(false);
+        })();
+        (0,assert.assert)();
+        return keycloakVersionRange;
+    }
+}
+//# sourceMappingURL=getKeycloakVersionRangeForJar.js.map
+// EXTERNAL MODULE: external "fs/promises"
+var promises_ = __webpack_require__(73292);
+;// CONCATENATED MODULE: ./dist/bin/keycloakify/buildJars/generatePom.js
+
+(0,assert.assert)();
+function generatePom(params) {
+    const { keycloakAccountV1Version, keycloakThemeAdditionalInfoExtensionVersion, buildContext } = params;
+    const { pomFileCode } = (function generatePomFileCode() {
+        const pomFileCode = [
+            `<?xml version="1.0"?>`,
+            `<project xmlns="http://maven.apache.org/POM/4.0.0"`,
+            `	 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"`,
+            `	 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">`,
+            `  <modelVersion>4.0.0</modelVersion>`,
+            `	<groupId>${buildContext.groupId}</groupId>`,
+            `	<artifactId>${buildContext.artifactId}</artifactId>`,
+            `	<version>${buildContext.themeVersion}</version>`,
+            `	<name>${buildContext.artifactId}</name>`,
+            `  <description />`,
+            `  <packaging>jar</packaging>`,
+            `  <properties>`,
+            `    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>`,
+            `  </properties>`,
+            ...(keycloakAccountV1Version !== null &&
+                keycloakThemeAdditionalInfoExtensionVersion !== null
+                ? [
+                    `  <build>`,
+                    `    <plugins>`,
+                    `      <plugin>`,
+                    `        <groupId>org.apache.maven.plugins</groupId>`,
+                    `        <artifactId>maven-shade-plugin</artifactId>`,
+                    `	     <version>3.5.1</version>`,
+                    `        <executions>`,
+                    `          <execution>`,
+                    `            <phase>package</phase>`,
+                    `            <goals>`,
+                    `              <goal>shade</goal>`,
+                    `            </goals>`,
+                    `          </execution>`,
+                    `        </executions>`,
+                    `      </plugin>`,
+                    `    </plugins>`,
+                    `  </build>`,
+                    `  <dependencies>`,
+                    ...(keycloakAccountV1Version !== null
+                        ? [
+                            `    <dependency>`,
+                            `      <groupId>io.phasetwo.keycloak</groupId>`,
+                            `      <artifactId>keycloak-account-v1</artifactId>`,
+                            `      <version>${keycloakAccountV1Version}</version>`,
+                            `    </dependency>`
+                        ]
+                        : []),
+                    ...(keycloakThemeAdditionalInfoExtensionVersion !== null
+                        ? [
+                            `    <dependency>`,
+                            `      <groupId>dev.jcputney</groupId>`,
+                            `      <artifactId>keycloak-theme-additional-info-extension</artifactId>`,
+                            `      <version>${keycloakThemeAdditionalInfoExtensionVersion}</version>`,
+                            `    </dependency>`
+                        ]
+                        : []),
+                    `  </dependencies>`
+                ]
+                : []),
+            `</project>`
+        ].join("\n");
+        return { pomFileCode };
+    })();
+    return { pomFileCode };
+}
+//# sourceMappingURL=generatePom.js.map
+;// CONCATENATED MODULE: ./dist/bin/keycloakify/buildJars/buildJar.js
+
+
+
+
+
+
+
+
+
+
+
+(0,assert.assert)();
+async function buildJar(params) {
+    const { jarFileBasename, keycloakAccountV1Version, keycloakThemeAdditionalInfoExtensionVersion, resourcesDirPath, buildContext } = params;
+    const keycloakifyBuildTmpDirPath = (0,external_path_.join)(buildContext.cacheDirPath, jarFileBasename.replace(".jar", ""));
+    (0,fs_rmSync/* rmSync */.a)(keycloakifyBuildTmpDirPath, { recursive: true, force: true });
+    (0,transformCodebase/* transformCodebase */.N)({
+        srcDirPath: resourcesDirPath,
+        destDirPath: (0,external_path_.join)(keycloakifyBuildTmpDirPath, "src", "main", "resources"),
+        transformSourceCode: keycloakAccountV1Version !== null
+            ? undefined
+            : (params) => {
+                const { fileRelativePath, sourceCode } = params;
+                if ((0,isInside/* isInside */.V)({
+                    dirPath: (0,external_path_.join)("theme", constants/* accountV1ThemeName */.y_),
+                    filePath: fileRelativePath
+                })) {
+                    return undefined;
+                }
+                if (fileRelativePath ===
+                    (0,shared_metaInfKeycloakThemes/* getMetaInfKeycloakThemesJsonFilePath */.KQ)({
+                        resourcesDirPath: "."
+                    })) {
+                    const keycloakThemesJsonParsed = JSON.parse(sourceCode.toString("utf8"));
+                    keycloakThemesJsonParsed.themes =
+                        keycloakThemesJsonParsed.themes.filter(({ name }) => name !== constants/* accountV1ThemeName */.y_);
+                    return {
+                        modifiedSourceCode: Buffer.from(JSON.stringify(keycloakThemesJsonParsed, null, 2), "utf8")
+                    };
+                }
+                for (const themeName of buildContext.themeNames) {
+                    if (fileRelativePath ===
+                        (0,external_path_.join)("theme", themeName, "account", "theme.properties")) {
+                        const modifiedSourceCode = Buffer.from(sourceCode
+                            .toString("utf8")
+                            .replace(`parent=${constants/* accountV1ThemeName */.y_}`, "parent=keycloak"), "utf8");
+                        (0,assert.assert)(Buffer.compare(modifiedSourceCode, sourceCode) !== 0);
+                        return { modifiedSourceCode };
+                    }
+                }
+                return { modifiedSourceCode: sourceCode };
+            }
+    });
+    route_legacy_pages: {
+        // NOTE: If there's no account theme there is no special target for keycloak 24 and up so we create
+        // the pages anyway. If there is an account pages, since we know that account-v1 is only support keycloak
+        // 24 in version 0.4 and up, we can safely break the route for legacy pages.
+        const doBreak = (() => {
+            switch (keycloakAccountV1Version) {
+                case null:
+                    return false;
+                case "0.3":
+                    return false;
+                default:
+                    return true;
+            }
+        })();
+        if (doBreak) {
+            break route_legacy_pages;
+        }
+        ["register.ftl", "login-update-profile.ftl"].forEach(pageId => buildContext.themeNames.map(themeName => {
+            const ftlFilePath = (0,external_path_.join)(keycloakifyBuildTmpDirPath, "src", "main", "resources", "theme", themeName, "login", pageId);
+            const ftlFileContent = (0,external_fs_.readFileSync)(ftlFilePath).toString("utf8");
+            const realPageId = (() => {
+                switch (pageId) {
+                    case "register.ftl":
+                        return "register-user-profile.ftl";
+                    case "login-update-profile.ftl":
+                        return "update-user-profile.ftl";
+                }
+                (0,assert.assert)(false);
+            })();
+            const modifiedFtlFileContent = ftlFileContent.replace(`out["pageId"] = "\${pageId}";`, `out["pageId"] = "${pageId}"; out["realPageId"] = "${realPageId}";`);
+            (0,assert.assert)(modifiedFtlFileContent !== ftlFileContent);
+            promises_.writeFile((0,external_path_.join)((0,external_path_.dirname)(ftlFilePath), realPageId), Buffer.from(modifiedFtlFileContent, "utf8"));
+        }));
+    }
+    {
+        const { pomFileCode } = generatePom({
+            buildContext,
+            keycloakAccountV1Version,
+            keycloakThemeAdditionalInfoExtensionVersion
+        });
+        await promises_.writeFile((0,external_path_.join)(keycloakifyBuildTmpDirPath, "pom.xml"), Buffer.from(pomFileCode, "utf8"));
+    }
+    await new Promise((resolve, reject) => external_child_process_default().exec(`mvn clean install -Dmaven.repo.local=${(0,external_path_.join)(keycloakifyBuildTmpDirPath, ".m2")}`, { cwd: keycloakifyBuildTmpDirPath }, error => {
+        if (error !== null) {
+            console.error(`Build jar failed: ${JSON.stringify({
+                jarFileBasename,
+                keycloakAccountV1Version,
+                keycloakThemeAdditionalInfoExtensionVersion
+            }, null, 2)}`);
+            reject(error);
+            return;
+        }
+        resolve();
+    }));
+    await promises_.rename((0,external_path_.join)(keycloakifyBuildTmpDirPath, "target", `${buildContext.artifactId}-${buildContext.themeVersion}.jar`), (0,external_path_.join)(buildContext.keycloakifyBuildDirPath, jarFileBasename));
+    (0,fs_rmSync/* rmSync */.a)(keycloakifyBuildTmpDirPath, { recursive: true });
+}
+//# sourceMappingURL=buildJar.js.map
+// EXTERNAL MODULE: ./dist/bin/shared/getJarFileBasename.js
+var getJarFileBasename = __webpack_require__(2323);
+;// CONCATENATED MODULE: ./dist/bin/keycloakify/buildJars/buildJars.js
+
+
+
+
+
+
+
+
+(0,assert.assert)();
+async function buildJars(params) {
+    const { onlyBuildJarFileBasename, resourcesDirPath, buildContext } = params;
+    const doesImplementAccountTheme = (0,shared_metaInfKeycloakThemes/* readMetaInfKeycloakThemes_fromResourcesDirPath */.Ju)({
+        resourcesDirPath
+    }).themes.some(({ name }) => name === constants/* accountV1ThemeName */.y_);
+    await Promise.all(keycloakAccountV1Versions.map(keycloakAccountV1Version => keycloakThemeAdditionalInfoExtensionVersions.map(keycloakThemeAdditionalInfoExtensionVersion => {
+        const keycloakVersionRange = getKeycloakVersionRangeForJar({
+            doesImplementAccountTheme,
+            keycloakAccountV1Version,
+            keycloakThemeAdditionalInfoExtensionVersion
+        });
+        if (keycloakVersionRange === undefined) {
+            return undefined;
+        }
+        return {
+            keycloakThemeAdditionalInfoExtensionVersion,
+            keycloakVersionRange
+        };
+    })
+        .filter((0,exclude.exclude)(undefined))
+        .map(({ keycloakThemeAdditionalInfoExtensionVersion, keycloakVersionRange }) => {
+        const { jarFileBasename } = (0,getJarFileBasename/* getJarFileBasename */.m)({
+            keycloakVersionRange
+        });
+        if (onlyBuildJarFileBasename !== undefined &&
+            onlyBuildJarFileBasename !== jarFileBasename) {
+            return undefined;
+        }
+        return {
+            keycloakThemeAdditionalInfoExtensionVersion,
+            jarFileBasename
+        };
+    })
+        .filter((0,exclude.exclude)(undefined))
+        .map(({ keycloakThemeAdditionalInfoExtensionVersion, jarFileBasename }) => buildJar({
+        jarFileBasename,
+        keycloakAccountV1Version,
+        keycloakThemeAdditionalInfoExtensionVersion,
+        resourcesDirPath,
+        buildContext
+    })))
+        .flat());
+}
+//# sourceMappingURL=buildJars.js.map
+;// CONCATENATED MODULE: ./dist/bin/keycloakify/buildJars/index.js
+
+//# sourceMappingURL=index.js.map
+// EXTERNAL MODULE: ./node_modules/chalk/source/index.js
+var source = __webpack_require__(78818);
+var source_default = /*#__PURE__*/__webpack_require__.n(source);
+// EXTERNAL MODULE: external "os"
+var external_os_ = __webpack_require__(22037);
+;// CONCATENATED MODULE: ./dist/bin/keycloakify/keycloakify.js
+
+
+
+
+
+
+
+
+
+
+
+async function command(params) {
+    exit_if_maven_not_installed: {
+        let commandOutput = undefined;
+        try {
+            commandOutput = external_child_process_.execSync("mvn --version", {
+                stdio: ["ignore", "pipe", "ignore"]
+            });
+        }
+        catch (_a) { }
+        if (commandOutput === null || commandOutput === void 0 ? void 0 : commandOutput.toString("utf8").includes("Apache Maven")) {
+            break exit_if_maven_not_installed;
+        }
+        const installationCommand = (() => {
+            switch (external_os_.platform()) {
+                case "darwin":
+                    return "brew install mvn";
+                case "win32":
+                    return "choco install mvn";
+                case "linux":
+                default:
+                    return "sudo apt-get install mvn";
+            }
+        })();
+        console.log(`${source_default().red("Apache Maven required.")} Install it with \`${source_default().bold(installationCommand)}\` (for example)`);
+        process.exit(1);
+    }
+    const { cliCommandOptions } = params;
+    const buildContext = (0,shared_buildContext/* getBuildContext */.s)({ cliCommandOptions });
+    console.log([
+        source_default().cyan(`keycloakify v${(0,readThisNpmPackageVersion/* readThisNpmPackageVersion */.K)()}`),
+        source_default().green(`Building the keycloak theme in .${external_path_.sep}${(0,external_path_.relative)(process.cwd(), buildContext.keycloakifyBuildDirPath)} ...`)
+    ].join(" "));
+    const startTime = Date.now();
+    {
+        if (!external_fs_.existsSync(buildContext.keycloakifyBuildDirPath)) {
+            external_fs_.mkdirSync(buildContext.keycloakifyBuildDirPath, {
+                recursive: true
+            });
+        }
+        external_fs_.writeFileSync((0,external_path_.join)(buildContext.keycloakifyBuildDirPath, ".gitignore"), Buffer.from("*", "utf8"));
+    }
+    const resourcesDirPath = (0,external_path_.join)(buildContext.keycloakifyBuildDirPath, "resources");
+    await generateSrcMainResources({
+        resourcesDirPath,
+        buildContext
+    });
+    run_post_build_script: {
+        if (buildContext.bundler !== "vite") {
+            break run_post_build_script;
+        }
+        external_child_process_.execSync("npx vite", {
+            cwd: buildContext.projectDirPath,
+            env: Object.assign(Object.assign({}, process.env), { [constants/* vitePluginSubScriptEnvNames.runPostBuildScript */.fe.runPostBuildScript]: JSON.stringify(buildContext) })
+        });
+    }
+    await buildJars({
+        resourcesDirPath,
+        buildContext,
+        onlyBuildJarFileBasename: process.env[constants/* onlyBuildJarFileBasenameEnvName */.Dv]
+    });
+    (0,fs_rmSync/* rmSync */.a)(resourcesDirPath, { recursive: true });
+    console.log(source_default().green(`✓ keycloak theme built in ${((Date.now() - startTime) / 1000).toFixed(2)}s`));
+}
+//# sourceMappingURL=keycloakify.js.map
+;// CONCATENATED MODULE: ./dist/bin/keycloakify/index.js
+
+//# sourceMappingURL=index.js.map
+
+/***/ }),
+
+/***/ 2323:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "m": () => (/* binding */ getJarFileBasename)
+/* harmony export */ });
+function getJarFileBasename(params) {
+    const { keycloakVersionRange } = params;
+    const jarFileBasename = `keycloak-theme-for-kc-${keycloakVersionRange}.jar`;
+    return { jarFileBasename };
+}
+//# sourceMappingURL=getJarFileBasename.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
+
+/***/ }),
+
+/***/ 26914:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "IS": () => (/* binding */ readMetaInfKeycloakThemes_fromJar),
+/* harmony export */   "JJ": () => (/* binding */ writeMetaInfKeycloakThemes),
+/* harmony export */   "Ju": () => (/* binding */ readMetaInfKeycloakThemes_fromResourcesDirPath),
+/* harmony export */   "KQ": () => (/* binding */ getMetaInfKeycloakThemesJsonFilePath)
+/* 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 fs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(57147);
+/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(fs__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var tsafe_assert__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(88078);
+/* harmony import */ var tsafe_assert__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(tsafe_assert__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _tools_extractArchive__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(29121);
+
+
+
+
+function getMetaInfKeycloakThemesJsonFilePath(params) {
+    const { resourcesDirPath } = params;
+    return (0,path__WEBPACK_IMPORTED_MODULE_0__.join)(resourcesDirPath === "." ? "" : resourcesDirPath, "META-INF", "keycloak-themes.json");
+}
+function readMetaInfKeycloakThemes_fromResourcesDirPath(params) {
+    const { resourcesDirPath } = params;
+    return JSON.parse(fs__WEBPACK_IMPORTED_MODULE_1__.readFileSync(getMetaInfKeycloakThemesJsonFilePath({
+        resourcesDirPath
+    }))
+        .toString("utf8"));
+}
+async function readMetaInfKeycloakThemes_fromJar(params) {
+    const { jarFilePath } = params;
+    let metaInfKeycloakThemes = undefined;
+    await (0,_tools_extractArchive__WEBPACK_IMPORTED_MODULE_3__/* .extractArchive */ .N)({
+        archiveFilePath: jarFilePath,
+        onArchiveFile: async ({ relativeFilePathInArchive, readFile, earlyExit }) => {
+            if (relativeFilePathInArchive ===
+                getMetaInfKeycloakThemesJsonFilePath({ resourcesDirPath: "." })) {
+                metaInfKeycloakThemes = JSON.parse((await readFile()).toString("utf8"));
+                earlyExit();
+            }
+        }
+    });
+    (0,tsafe_assert__WEBPACK_IMPORTED_MODULE_2__.assert)(metaInfKeycloakThemes !== undefined);
+    return metaInfKeycloakThemes;
+}
+function writeMetaInfKeycloakThemes(params) {
+    const { resourcesDirPath, metaInfKeycloakThemes } = params;
+    const metaInfKeycloakThemesJsonPath = getMetaInfKeycloakThemesJsonFilePath({
+        resourcesDirPath
+    });
+    {
+        const dirPath = (0,path__WEBPACK_IMPORTED_MODULE_0__.dirname)(metaInfKeycloakThemesJsonPath);
+        if (!fs__WEBPACK_IMPORTED_MODULE_1__.existsSync(dirPath)) {
+            fs__WEBPACK_IMPORTED_MODULE_1__.mkdirSync(dirPath, { recursive: true });
+        }
+    }
+    fs__WEBPACK_IMPORTED_MODULE_1__.writeFileSync(metaInfKeycloakThemesJsonPath, Buffer.from(JSON.stringify(metaInfKeycloakThemes, null, 2), "utf8"));
+}
+//# sourceMappingURL=metaInfKeycloakThemes.js.map
+
+/***/ }),
+
+/***/ 27190:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "y": () => (/* binding */ escapeStringForPropertiesFile)
+/* harmony export */ });
+// Convert a JavaScript string to UTF-16 encoding
+function toUTF16(codePoint) {
+    if (codePoint <= 0xffff) {
+        // BMP character
+        return "\\u" + codePoint.toString(16).padStart(4, "0");
+    }
+    else {
+        // Non-BMP character
+        codePoint -= 0x10000;
+        let highSurrogate = (codePoint >> 10) + 0xd800;
+        let lowSurrogate = (codePoint % 0x400) + 0xdc00;
+        return ("\\u" +
+            highSurrogate.toString(16).padStart(4, "0") +
+            "\\u" +
+            lowSurrogate.toString(16).padStart(4, "0"));
+    }
+}
+// Escapes special characters for use in a .properties file
+function escapeStringForPropertiesFile(str) {
+    let escapedStr = "";
+    for (const char of [...str]) {
+        const codePoint = char.codePointAt(0);
+        if (!codePoint)
+            continue;
+        switch (char) {
+            case "\n":
+                escapedStr += "\\n";
+                break;
+            case "\r":
+                escapedStr += "\\r";
+                break;
+            case "\t":
+                escapedStr += "\\t";
+                break;
+            case "\\":
+                escapedStr += "\\\\";
+                break;
+            case ":":
+                escapedStr += "\\:";
+                break;
+            case "=":
+                escapedStr += "\\=";
+                break;
+            case "#":
+                escapedStr += "\\#";
+                break;
+            case "!":
+                escapedStr += "\\!";
+                break;
+            case "'":
+                escapedStr += "''";
+                break;
+            default:
+                if (codePoint > 0x7f) {
+                    escapedStr += toUTF16(codePoint); // Non-ASCII characters
+                }
+                else {
+                    escapedStr += char; // ASCII character needs no escape
+                }
+        }
+    }
+    return escapedStr;
+}
+//# sourceMappingURL=escapeStringForPropertiesFile.js.map
+
+/***/ })
+
+};
+;