keycloakify 10.0.0-rc.12 → 10.0.0-rc.120

package/bin/31.index.js

@@ -0,0 +1,799 @@
+"use strict";
+exports.id = 31;
+exports.ids = [31];
+exports.modules = {
+
+/***/ 56031:
+/***/ ((__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: ./node_modules/zod/lib/index.mjs
+var lib = __webpack_require__(52300);
+// EXTERNAL MODULE: external "fs"
+var external_fs_ = __webpack_require__(57147);
+// EXTERNAL MODULE: ./node_modules/tsafe/assert.js
+var assert = __webpack_require__(88078);
+// EXTERNAL MODULE: external "child_process"
+var external_child_process_ = __webpack_require__(32081);
+// EXTERNAL MODULE: ./dist/bin/shared/constants.js
+var constants = __webpack_require__(173);
+// EXTERNAL MODULE: ./node_modules/tsafe/index.js
+var tsafe = __webpack_require__(1666);
+// EXTERNAL MODULE: ./dist/bin/tools/crawl.js
+var crawl = __webpack_require__(73036);
+// EXTERNAL MODULE: ./node_modules/tsafe/objectEntries.js
+var objectEntries = __webpack_require__(39612);
+// EXTERNAL MODULE: ./node_modules/tsafe/id.js
+var id = __webpack_require__(43047);
+// EXTERNAL MODULE: ./node_modules/chalk/source/index.js
+var source = __webpack_require__(78818);
+var source_default = /*#__PURE__*/__webpack_require__.n(source);
+;// CONCATENATED MODULE: ./dist/bin/tools/fetchProxyOptions.js
+
+
+function getProxyFetchOptions(params) {
+    var _a, _b, _c;
+    const { npmConfigGetCwd } = params;
+    const cfg = (() => {
+        const output = external_child_process_.execSync("npm config get", {
+            cwd: npmConfigGetCwd
+        })
+            .toString("utf8");
+        return output
+            .split("\n")
+            .filter(line => !line.startsWith(";"))
+            .map(line => line.trim())
+            .map(line => line.split("=", 2))
+            .reduce((cfg, [key, value]) => key in cfg
+            ? Object.assign(Object.assign({}, cfg), { [key]: [...ensureArray(cfg[key]), value] }) : Object.assign(Object.assign({}, cfg), { [key]: value }), {});
+    })();
+    const proxy = ensureSingleOrNone((_a = cfg["https-proxy"]) !== null && _a !== void 0 ? _a : cfg["proxy"]);
+    const noProxy = (_b = cfg["noproxy"]) !== null && _b !== void 0 ? _b : cfg["no-proxy"];
+    function maybeBoolean(arg0) {
+        return typeof arg0 === "undefined" ? undefined : Boolean(arg0);
+    }
+    const strictSSL = maybeBoolean(ensureSingleOrNone(cfg["strict-ssl"]));
+    const cert = cfg["cert"];
+    const ca = ensureArray((_c = cfg["ca"]) !== null && _c !== void 0 ? _c : cfg["ca[]"]);
+    const cafile = ensureSingleOrNone(cfg["cafile"]);
+    if (typeof cafile !== "undefined" && cafile !== "null") {
+        ca.push(...(() => {
+            const cafileContent = external_fs_.readFileSync(cafile).toString("utf8");
+            const newLinePlaceholder = "NEW_LINE_PLACEHOLDER_xIsPsK23svt";
+            const chunks = (arr, size = 2) => arr
+                .map((_, i) => i % size == 0 && arr.slice(i, i + size))
+                .filter(Boolean);
+            return chunks(cafileContent.split(/(-----END CERTIFICATE-----)/), 2).map(ca => ca
+                .join("")
+                .replace(/\r?\n/g, newLinePlaceholder)
+                .replace(new RegExp(`^${newLinePlaceholder}`), "")
+                .replace(new RegExp(newLinePlaceholder, "g"), "\\n"));
+        })());
+    }
+    return {
+        proxy,
+        noProxy,
+        strictSSL,
+        cert,
+        ca: ca.length === 0 ? undefined : ca
+    };
+}
+function ensureArray(arg0) {
+    return Array.isArray(arg0) ? arg0 : typeof arg0 === "undefined" ? [] : [arg0];
+}
+function ensureSingleOrNone(arg0) {
+    if (!Array.isArray(arg0))
+        return arg0;
+    if (arg0.length === 0)
+        return undefined;
+    if (arg0.length === 1)
+        return arg0[0];
+    throw new Error("Illegal configuration, expected a single value but found multiple: " +
+        arg0.map(String).join(", "));
+}
+//# sourceMappingURL=fetchProxyOptions.js.map
+;// CONCATENATED MODULE: ./dist/bin/shared/buildContext.js
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+(0,assert.assert)();
+function getBuildContext(params) {
+    var _a, _b, _c, _d, _e, _f;
+    const { cliCommandOptions } = params;
+    const projectDirPath = cliCommandOptions.projectDirPath !== undefined
+        ? (0,getAbsoluteAndInOsFormatPath/* getAbsoluteAndInOsFormatPath */.c)({
+            pathIsh: cliCommandOptions.projectDirPath,
+            cwd: process.cwd()
+        })
+        : process.cwd();
+    const { themeSrcDirPath } = (() => {
+        const srcDirPath = (0,external_path_.join)(projectDirPath, "src");
+        const themeSrcDirPath = (0,crawl/* crawl */.J)({
+            dirPath: srcDirPath,
+            returnedPathsType: "relative to dirPath"
+        })
+            .map(fileRelativePath => {
+            for (const themeSrcDirBasename of ["keycloak-theme", "keycloak_theme"]) {
+                const split = fileRelativePath.split(themeSrcDirBasename);
+                if (split.length === 2) {
+                    return (0,external_path_.join)(srcDirPath, split[0] + themeSrcDirBasename);
+                }
+            }
+            return undefined;
+        })
+            .filter((0,tsafe.exclude)(undefined))[0];
+        if (themeSrcDirPath !== undefined) {
+            return { themeSrcDirPath };
+        }
+        for (const themeType of [...constants/* THEME_TYPES */.Jh, "email"]) {
+            if (!external_fs_.existsSync((0,external_path_.join)(srcDirPath, themeType))) {
+                continue;
+            }
+            return { themeSrcDirPath: srcDirPath };
+        }
+        console.log(source_default().red([
+            `Can't locate your Keycloak theme source directory in .${external_path_.sep}${(0,external_path_.relative)(process.cwd(), srcDirPath)}`,
+            `Make sure to either use the Keycloakify CLI in the root of your Keycloakify project or use the --project CLI option`,
+            `If you are collocating your Keycloak theme with your app you must have a directory named 'keycloak-theme' or 'keycloak_theme' in your 'src' directory`
+        ].join("\n")));
+        process.exit(1);
+    })();
+    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/* VITE_PLUGIN_SUB_SCRIPTS_ENV_NAMES.RESOLVE_VITE_CONFIG */.TE.RESOLVE_VITE_CONFIG]: "true" })
+        })
+            .toString("utf8");
+        (0,assert.assert)(output.includes(constants/* VITE_PLUGIN_SUB_SCRIPTS_ENV_NAMES.RESOLVE_VITE_CONFIG */.TE.RESOLVE_VITE_CONFIG), "Seems like the Keycloakify's Vite plugin is not installed.");
+        const resolvedViteConfigStr = output
+            .split(constants/* VITE_PLUGIN_SUB_SCRIPTS_ENV_NAMES.RESOLVE_VITE_CONFIG */.TE.RESOLVE_VITE_CONFIG)
+            .reverse()[0];
+        const resolvedViteConfig = JSON.parse(resolvedViteConfigStr);
+        return { resolvedViteConfig };
+    })();
+    const packageJsonFilePath = (function getPackageJSonDirPath(upCount) {
+        var _a, _b;
+        const dirPath = (0,external_path_.resolve)((0,external_path_.join)(...[projectDirPath, ...Array(upCount).fill("..")]));
+        (0,assert.assert)(dirPath !== external_path_.sep, "Root package.json not found");
+        success: {
+            const packageJsonFilePath = (0,external_path_.join)(dirPath, "package.json");
+            if (!external_fs_.existsSync(packageJsonFilePath)) {
+                break success;
+            }
+            const parsedPackageJson = lib.z.object({
+                name: lib.z.string().optional(),
+                dependencies: lib.z.record(lib.z.string()).optional(),
+                devDependencies: lib.z.record(lib.z.string()).optional()
+            })
+                .parse(JSON.parse(external_fs_.readFileSync(packageJsonFilePath).toString("utf8")));
+            if (((_a = parsedPackageJson.dependencies) === null || _a === void 0 ? void 0 : _a.keycloakify) === undefined &&
+                ((_b = parsedPackageJson.devDependencies) === null || _b === void 0 ? void 0 : _b.keycloakify) === undefined &&
+                parsedPackageJson.name !== "keycloakify" // NOTE: For local storybook build
+            ) {
+                break success;
+            }
+            return packageJsonFilePath;
+        }
+        return getPackageJSonDirPath(upCount + 1);
+    })(0);
+    const parsedPackageJson = (() => {
+        const zMultiPageApp = (() => {
+            const zTargetType = lib.z.object({
+                accountThemeImplementation: lib.z.literal("Multi-Page"),
+                keycloakVersionTargets: lib.z.object({
+                    "21-and-below": lib.z.union([lib.z.boolean(), lib.z.string()]),
+                    "23": lib.z.union([lib.z.boolean(), lib.z.string()]),
+                    "24": lib.z.union([lib.z.boolean(), lib.z.string()]),
+                    "25-and-above": lib.z.union([lib.z.boolean(), lib.z.string()])
+                })
+                    .optional()
+            });
+            (0,assert.assert)();
+            return (0,id.id)(zTargetType);
+        })();
+        const zSinglePageApp = (() => {
+            const zTargetType = lib.z.object({
+                accountThemeImplementation: lib.z.union([
+                    lib.z.literal("Single-Page"),
+                    lib.z.literal("none")
+                ]),
+                keycloakVersionTargets: lib.z.object({
+                    "21-and-below": lib.z.union([lib.z.boolean(), lib.z.string()]),
+                    "22-and-above": lib.z.union([lib.z.boolean(), lib.z.string()])
+                })
+                    .optional()
+            });
+            (0,assert.assert)();
+            return (0,id.id)(zTargetType);
+        })();
+        const zAccountThemeImplAndKeycloakVersionTargets = (() => {
+            const zTargetType = lib.z.union([zMultiPageApp, zSinglePageApp]);
+            (0,assert.assert)();
+            return (0,id.id)(zTargetType);
+        })();
+        const zBuildOptions = (() => {
+            const zTargetType = lib.z.intersection(lib.z.object({
+                themeName: lib.z.union([lib.z.string(), lib.z.array(lib.z.string())]).optional(),
+                themeVersion: lib.z.string().optional(),
+                environmentVariables: lib.z.array(lib.z.object({
+                    name: lib.z.string(),
+                    default: lib.z.string()
+                }))
+                    .optional(),
+                extraThemeProperties: lib.z.array(lib.z.string()).optional(),
+                artifactId: lib.z.string().optional(),
+                groupId: lib.z.string().optional(),
+                loginThemeResourcesFromKeycloakVersion: lib.z.string().optional(),
+                keycloakifyBuildDirPath: lib.z.string().optional(),
+                kcContextExclusionsFtl: lib.z.string().optional()
+            }), zAccountThemeImplAndKeycloakVersionTargets);
+            (0,assert.assert)();
+            return (0,id.id)(zTargetType);
+        })();
+        const zBuildOptions_packageJson = (() => {
+            const zTargetType = lib.z.intersection(zBuildOptions, lib.z.object({
+                projectBuildDirPath: lib.z.string().optional(),
+                staticDirPathInProjectBuildDirPath: lib.z.string().optional(),
+                publicDirPath: lib.z.string().optional()
+            }));
+            (0,assert.assert)();
+            return (0,id.id)(zTargetType);
+        })();
+        const zParsedPackageJson = (() => {
+            const zTargetType = lib.z.object({
+                name: lib.z.string().optional(),
+                version: lib.z.string().optional(),
+                homepage: lib.z.string().optional(),
+                keycloakify: zBuildOptions_packageJson.optional()
+            });
+            (0,assert.assert)();
+            return (0,id.id)(zTargetType);
+        })();
+        const configurationPackageJsonFilePath = (() => {
+            const rootPackageJsonFilePath = (0,external_path_.join)(projectDirPath, "package.json");
+            return external_fs_.existsSync(rootPackageJsonFilePath)
+                ? rootPackageJsonFilePath
+                : packageJsonFilePath;
+        })();
+        return zParsedPackageJson.parse(JSON.parse(external_fs_.readFileSync(configurationPackageJsonFilePath).toString("utf8")));
+    })();
+    const bundler = resolvedViteConfig !== undefined ? "vite" : "webpack";
+    if (bundler === "vite" && parsedPackageJson.keycloakify !== undefined) {
+        console.error(source_default().red(`In vite projects, provide your Keycloakify options in vite.config.ts, not in package.json`));
+        process.exit(-1);
+    }
+    const buildOptions = (() => {
+        switch (bundler) {
+            case "vite":
+                (0,assert.assert)(resolvedViteConfig !== undefined);
+                return resolvedViteConfig.buildOptions;
+            case "webpack":
+                (0,assert.assert)(parsedPackageJson.keycloakify !== undefined);
+                return parsedPackageJson.keycloakify;
+        }
+        (0,assert.assert)(false);
+    })();
+    const implementedThemeTypes = {
+        login: {
+            isImplemented: external_fs_.existsSync((0,external_path_.join)(themeSrcDirPath, "login"))
+        },
+        email: {
+            isImplemented: external_fs_.existsSync((0,external_path_.join)(themeSrcDirPath, "email"))
+        },
+        account: (() => {
+            if (buildOptions.accountThemeImplementation === "none") {
+                return { isImplemented: false };
+            }
+            return {
+                isImplemented: true,
+                type: buildOptions.accountThemeImplementation
+            };
+        })()
+    };
+    if (implementedThemeTypes.account.isImplemented &&
+        !external_fs_.existsSync((0,external_path_.join)(themeSrcDirPath, "account"))) {
+        console.error(source_default().red([
+            `You have set 'accountThemeImplementation' to '${implementedThemeTypes.account.type}'`,
+            `but the 'account' directory is missing in your theme source directory`,
+            "Use the `npx keycloakify initialize-account-theme` command to create it"
+        ].join(" ")));
+        process.exit(-1);
+    }
+    const themeNames = (() => {
+        if (buildOptions.themeName === undefined) {
+            return parsedPackageJson.name === undefined
+                ? ["keycloakify"]
+                : [
+                    parsedPackageJson.name
+                        .replace(/^@(.*)/, "$1")
+                        .split("/")
+                        .join("-")
+                ];
+        }
+        if (typeof buildOptions.themeName === "string") {
+            return [buildOptions.themeName];
+        }
+        const [mainThemeName, ...themeVariantNames] = buildOptions.themeName;
+        (0,assert.assert)(mainThemeName !== undefined);
+        return [mainThemeName, ...themeVariantNames];
+    })();
+    const projectBuildDirPath = (() => {
+        webpack: {
+            if (bundler !== "webpack") {
+                break webpack;
+            }
+            (0,assert.assert)(parsedPackageJson.keycloakify !== undefined);
+            if (parsedPackageJson.keycloakify.projectBuildDirPath !== undefined) {
+                return (0,getAbsoluteAndInOsFormatPath/* getAbsoluteAndInOsFormatPath */.c)({
+                    pathIsh: parsedPackageJson.keycloakify.projectBuildDirPath,
+                    cwd: projectDirPath
+                });
+            }
+            return (0,external_path_.join)(projectDirPath, "build");
+        }
+        (0,assert.assert)(bundler === "vite");
+        (0,assert.assert)(resolvedViteConfig !== undefined);
+        return (0,external_path_.join)(projectDirPath, resolvedViteConfig.buildDir);
+    })();
+    return {
+        bundler,
+        packageJsonFilePath,
+        themeVersion: (_b = (_a = buildOptions.themeVersion) !== 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 : constants/* LOGIN_THEME_RESOURCES_FROMkEYCLOAK_VERSION_DEFAULT */.fY,
+        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: (() => {
+            if (process.env.PUBLIC_DIR_PATH !== undefined) {
+                return (0,getAbsoluteAndInOsFormatPath/* getAbsoluteAndInOsFormatPath */.c)({
+                    pathIsh: process.env.PUBLIC_DIR_PATH,
+                    cwd: projectDirPath
+                });
+            }
+            webpack: {
+                if (bundler !== "webpack") {
+                    break webpack;
+                }
+                (0,assert.assert)(parsedPackageJson.keycloakify !== undefined);
+                if (parsedPackageJson.keycloakify.publicDirPath !== undefined) {
+                    return (0,getAbsoluteAndInOsFormatPath/* getAbsoluteAndInOsFormatPath */.c)({
+                        pathIsh: parsedPackageJson.keycloakify.publicDirPath,
+                        cwd: projectDirPath
+                    });
+                }
+                return (0,external_path_.join)(projectDirPath, "public");
+            }
+            (0,assert.assert)(bundler === "vite");
+            (0,assert.assert)(resolvedViteConfig !== undefined);
+            return (0,external_path_.join)(projectDirPath, resolvedViteConfig.publicDir);
+        })(),
+        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)((0,external_path_.dirname)(packageJsonFilePath), "node_modules", ".cache");
+        })(), "keycloakify"),
+        urlPathname: (() => {
+            webpack: {
+                if (bundler !== "webpack") {
+                    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;
+            }
+            (0,assert.assert)(bundler === "vite");
+            (0,assert.assert)(resolvedViteConfig !== undefined);
+            return resolvedViteConfig.urlPathname;
+        })(),
+        assetsDirPath: (() => {
+            webpack: {
+                if (bundler !== "webpack") {
+                    break webpack;
+                }
+                (0,assert.assert)(parsedPackageJson.keycloakify !== undefined);
+                if (parsedPackageJson.keycloakify.staticDirPathInProjectBuildDirPath !==
+                    undefined) {
+                    (0,getAbsoluteAndInOsFormatPath/* getAbsoluteAndInOsFormatPath */.c)({
+                        pathIsh: parsedPackageJson.keycloakify
+                            .staticDirPathInProjectBuildDirPath,
+                        cwd: projectBuildDirPath
+                    });
+                }
+                return (0,external_path_.join)(projectBuildDirPath, "static");
+            }
+            (0,assert.assert)(bundler === "vite");
+            (0,assert.assert)(resolvedViteConfig !== undefined);
+            return (0,external_path_.join)(projectBuildDirPath, resolvedViteConfig.assetsDir);
+        })(),
+        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 : [],
+        implementedThemeTypes,
+        themeSrcDirPath,
+        fetchOptions: getProxyFetchOptions({
+            npmConfigGetCwd: (function callee(upCount) {
+                const dirPath = (0,external_path_.resolve)((0,external_path_.join)(...[projectDirPath, ...Array(upCount).fill("..")]));
+                (0,assert.assert)(dirPath !== external_path_.sep, "Couldn't find a place to run 'npm config get'");
+                try {
+                    external_child_process_.execSync("npm config get", {
+                        cwd: dirPath,
+                        stdio: "pipe"
+                    });
+                }
+                catch (error) {
+                    if (String(error).includes("ENOWORKSPACES")) {
+                        return callee(upCount + 1);
+                    }
+                    throw error;
+                }
+                return dirPath;
+            })(0)
+        }),
+        jarTargets: (() => {
+            const getDefaultJarFileBasename = (range) => `keycloak-theme-for-kc-${range}.jar`;
+            build_for_specific_keycloak_major_version: {
+                const buildForKeycloakMajorVersionNumber = (() => {
+                    const envValue = process.env[constants/* BUILD_FOR_KEYCLOAK_MAJOR_VERSION_ENV_NAME */.ac];
+                    if (envValue === undefined) {
+                        return undefined;
+                    }
+                    const major = parseInt(envValue);
+                    (0,assert.assert)(!isNaN(major));
+                    return major;
+                })();
+                if (buildForKeycloakMajorVersionNumber === undefined) {
+                    break build_for_specific_keycloak_major_version;
+                }
+                const keycloakVersionRange = (() => {
+                    if (implementedThemeTypes.account.isImplemented &&
+                        implementedThemeTypes.account.type === "Multi-Page") {
+                        const keycloakVersionRange = (() => {
+                            if (buildForKeycloakMajorVersionNumber <= 21) {
+                                return "21-and-below";
+                            }
+                            (0,assert.assert)(buildForKeycloakMajorVersionNumber !== 22);
+                            if (buildForKeycloakMajorVersionNumber === 23) {
+                                return "23";
+                            }
+                            if (buildForKeycloakMajorVersionNumber === 24) {
+                                return "24";
+                            }
+                            return "25-and-above";
+                        })();
+                        (0,assert.assert)();
+                        return keycloakVersionRange;
+                    }
+                    else {
+                        const keycloakVersionRange = (() => {
+                            if (buildForKeycloakMajorVersionNumber <= 21) {
+                                return "21-and-below";
+                            }
+                            return "22-and-above";
+                        })();
+                        (0,assert.assert)();
+                        return keycloakVersionRange;
+                    }
+                })();
+                const jarFileBasename = (() => {
+                    use_custom_jar_basename: {
+                        const { keycloakVersionTargets } = buildOptions;
+                        if (keycloakVersionTargets === undefined) {
+                            break use_custom_jar_basename;
+                        }
+                        const entry = (0,objectEntries.objectEntries)(keycloakVersionTargets).find(([keycloakVersionRange_entry]) => keycloakVersionRange_entry === keycloakVersionRange);
+                        if (entry === undefined) {
+                            break use_custom_jar_basename;
+                        }
+                        const maybeJarFileBasename = entry[1];
+                        if (typeof maybeJarFileBasename !== "string") {
+                            break use_custom_jar_basename;
+                        }
+                        return maybeJarFileBasename;
+                    }
+                    return getDefaultJarFileBasename(keycloakVersionRange);
+                })();
+                return [
+                    {
+                        keycloakVersionRange,
+                        jarFileBasename
+                    }
+                ];
+            }
+            const jarTargets_default = (() => {
+                const jarTargets = [];
+                if (implementedThemeTypes.account.isImplemented &&
+                    implementedThemeTypes.account.type === "Multi-Page") {
+                    for (const keycloakVersionRange of [
+                        "21-and-below",
+                        "23",
+                        "24",
+                        "25-and-above"
+                    ]) {
+                        (0,assert.assert)(true);
+                        jarTargets.push({
+                            keycloakVersionRange,
+                            jarFileBasename: getDefaultJarFileBasename(keycloakVersionRange)
+                        });
+                    }
+                }
+                else {
+                    for (const keycloakVersionRange of [
+                        "21-and-below",
+                        "22-and-above"
+                    ]) {
+                        (0,assert.assert)(true);
+                        jarTargets.push({
+                            keycloakVersionRange,
+                            jarFileBasename: getDefaultJarFileBasename(keycloakVersionRange)
+                        });
+                    }
+                }
+                return jarTargets;
+            })();
+            if (buildOptions.keycloakVersionTargets === undefined) {
+                return jarTargets_default;
+            }
+            const jarTargets = [];
+            for (const [keycloakVersionRange, jarNameOrBoolean] of (0,objectEntries.objectEntries)(buildOptions.keycloakVersionTargets)) {
+                if (jarNameOrBoolean === false) {
+                    continue;
+                }
+                if (jarNameOrBoolean === true) {
+                    jarTargets.push({
+                        keycloakVersionRange: keycloakVersionRange,
+                        jarFileBasename: getDefaultJarFileBasename(keycloakVersionRange)
+                    });
+                    continue;
+                }
+                const jarFileBasename = jarNameOrBoolean;
+                if (!jarFileBasename.endsWith(".jar")) {
+                    console.log(source_default().red(`Bad ${jarFileBasename} should end with '.jar'\n`));
+                    process.exit(1);
+                }
+                if (jarFileBasename.includes("/") || jarFileBasename.includes("\\")) {
+                    console.log(source_default().red([
+                        `Invalid ${jarFileBasename}. It's not supposed to be a path,`,
+                        `Only the basename of the jar file is expected.`,
+                        `Example: keycloak-theme.jar`
+                    ].join(" ")));
+                    process.exit(1);
+                }
+                jarTargets.push({
+                    keycloakVersionRange: keycloakVersionRange,
+                    jarFileBasename: jarNameOrBoolean
+                });
+            }
+            if (jarTargets.length === 0) {
+                console.log(source_default().red("All jar targets are disabled. Please enable at least one jar target."));
+                process.exit(1);
+            }
+            return jarTargets;
+        })()
+    };
+}
+//# sourceMappingURL=buildContext.js.map
+
+/***/ }),
+
+/***/ 173:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "F_": () => (/* binding */ BASENAME_OF_KEYCLOAKIFY_RESOURCES_DIR),
+/* harmony export */   "Jh": () => (/* binding */ THEME_TYPES),
+/* harmony export */   "TE": () => (/* binding */ VITE_PLUGIN_SUB_SCRIPTS_ENV_NAMES),
+/* harmony export */   "XV": () => (/* binding */ LOGIN_THEME_PAGE_IDS),
+/* harmony export */   "ZQ": () => (/* binding */ ACCOUNT_V1_THEME_NAME),
+/* harmony export */   "_L": () => (/* binding */ FALLBACK_LANGUAGE_TAG),
+/* harmony export */   "ac": () => (/* binding */ BUILD_FOR_KEYCLOAK_MAJOR_VERSION_ENV_NAME),
+/* harmony export */   "fY": () => (/* binding */ LOGIN_THEME_RESOURCES_FROMkEYCLOAK_VERSION_DEFAULT),
+/* harmony export */   "lj": () => (/* binding */ KEYCLOAK_RESOURCES),
+/* harmony export */   "nX": () => (/* binding */ RESOURCES_COMMON),
+/* harmony export */   "rK": () => (/* binding */ LAST_KEYCLOAK_VERSION_WITH_ACCOUNT_V1),
+/* harmony export */   "sv": () => (/* binding */ CONTAINER_NAME),
+/* harmony export */   "yV": () => (/* binding */ ACCOUNT_THEME_PAGE_IDS)
+/* harmony export */ });
+const KEYCLOAK_RESOURCES = "keycloak-resources";
+const RESOURCES_COMMON = "resources-common";
+const LAST_KEYCLOAK_VERSION_WITH_ACCOUNT_V1 = "21.1.2";
+const BASENAME_OF_KEYCLOAKIFY_RESOURCES_DIR = "dist";
+const THEME_TYPES = ["login", "account"];
+const ACCOUNT_V1_THEME_NAME = "account-v1";
+const VITE_PLUGIN_SUB_SCRIPTS_ENV_NAMES = {
+    RUN_POST_BUILD_SCRIPT: "KEYCLOAKIFY_RUN_POST_BUILD_SCRIPT",
+    RESOLVE_VITE_CONFIG: "KEYCLOAKIFY_RESOLVE_VITE_CONFIG"
+};
+const BUILD_FOR_KEYCLOAK_MAJOR_VERSION_ENV_NAME = "KEYCLOAKIFY_BUILD_FOR_KEYCLOAK_MAJOR_VERSION";
+const LOGIN_THEME_PAGE_IDS = [
+    "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 ACCOUNT_THEME_PAGE_IDS = [
+    "password.ftl",
+    "account.ftl",
+    "sessions.ftl",
+    "totp.ftl",
+    "applications.ftl",
+    "log.ftl",
+    "federatedIdentity.ftl"
+];
+const CONTAINER_NAME = "keycloak-keycloakify";
+const FALLBACK_LANGUAGE_TAG = "en";
+const LOGIN_THEME_RESOURCES_FROMkEYCLOAK_VERSION_DEFAULT = "24.0.4";
+//# sourceMappingURL=constants.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
+
+/***/ })
+
+};
+;