keycloakify 10.0.0-rc.8 → 10.0.0-rc.80

package/bin/751.index.js

@@ -0,0 +1,732 @@
+"use strict";
+exports.id = 751;
+exports.ids = [751];
+exports.modules = {
+
+/***/ 87751:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "s": () => (/* binding */ getBuildContext)
+});
+
+// EXTERNAL MODULE: external "url"
+var external_url_ = __webpack_require__(57310);
+// EXTERNAL MODULE: external "path"
+var external_path_ = __webpack_require__(71017);
+// EXTERNAL MODULE: ./dist/bin/tools/getAbsoluteAndInOsFormatPath.js
+var getAbsoluteAndInOsFormatPath = __webpack_require__(86644);
+// EXTERNAL MODULE: external "child_process"
+var external_child_process_ = __webpack_require__(32081);
+// EXTERNAL MODULE: ./node_modules/tsafe/assert.js
+var assert = __webpack_require__(88078);
+// EXTERNAL MODULE: external "fs"
+var external_fs_ = __webpack_require__(57147);
+;// CONCATENATED MODULE: ./dist/bin/tools/getNpmWorkspaceRootDirPath.js
+
+
+
+
+function getNpmWorkspaceRootDirPath(params) {
+    const { projectDirPath, dependencyExpected } = params;
+    const npmWorkspaceRootDirPath = (function callee(depth) {
+        const cwd = (0,external_path_.resolve)((0,external_path_.join)(...[projectDirPath, ...Array(depth).fill("..")]));
+        (0,assert.assert)(cwd !== external_path_.sep, "NPM workspace not found");
+        try {
+            external_child_process_.execSync("npm config get", {
+                cwd,
+                stdio: "ignore"
+            });
+        }
+        catch (error) {
+            if (String(error).includes("ENOWORKSPACES")) {
+                return callee(depth + 1);
+            }
+            throw error;
+        }
+        const packageJsonFilePath = (0,external_path_.join)(cwd, "package.json");
+        if (!external_fs_.existsSync(packageJsonFilePath)) {
+            return callee(depth + 1);
+        }
+        (0,assert.assert)(external_fs_.existsSync(packageJsonFilePath));
+        const parsedPackageJson = JSON.parse(external_fs_.readFileSync(packageJsonFilePath).toString("utf8"));
+        let isExpectedDependencyFound = false;
+        for (const dependenciesOrDevDependencies of [
+            "dependencies",
+            "devDependencies"
+        ]) {
+            const dependencies = parsedPackageJson[dependenciesOrDevDependencies];
+            if (dependencies === undefined) {
+                continue;
+            }
+            (0,assert.assert)(dependencies instanceof Object);
+            if (dependencies[dependencyExpected] === undefined) {
+                continue;
+            }
+            isExpectedDependencyFound = true;
+        }
+        if (!isExpectedDependencyFound && parsedPackageJson.name !== dependencyExpected) {
+            return callee(depth + 1);
+        }
+        return cwd;
+    })(0);
+    return { npmWorkspaceRootDirPath };
+}
+//# sourceMappingURL=getNpmWorkspaceRootDirPath.js.map
+// EXTERNAL MODULE: ./node_modules/zod/lib/index.mjs
+var lib = __webpack_require__(52300);
+// EXTERNAL MODULE: ./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/objectFromEntries.js
+var objectFromEntries = __webpack_require__(68634);
+// 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/tsafe/symToStr.js
+var symToStr = __webpack_require__(47986);
+// 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/shared/buildContext.js
+var __rest = (undefined && undefined.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+function getBuildContext(params) {
+    var _a, _b, _c, _d, _e, _f;
+    const { cliCommandOptions } = params;
+    const projectDirPath = (() => {
+        if (cliCommandOptions.projectDirPath === undefined) {
+            return process.cwd();
+        }
+        return (0,getAbsoluteAndInOsFormatPath/* getAbsoluteAndInOsFormatPath */.c)({
+            pathIsh: cliCommandOptions.projectDirPath,
+            cwd: process.cwd()
+        });
+    })();
+    const { resolvedViteConfig } = (() => {
+        if (external_fs_.readdirSync(projectDirPath)
+            .find(fileBasename => fileBasename.startsWith("vite.config")) ===
+            undefined) {
+            return { resolvedViteConfig: undefined };
+        }
+        const output = external_child_process_.execSync("npx vite", {
+            cwd: projectDirPath,
+            env: Object.assign(Object.assign({}, process.env), { [constants/* vitePluginSubScriptEnvNames.resolveViteConfig */.fe.resolveViteConfig]: "true" })
+        })
+            .toString("utf8");
+        (0,assert.assert)(output.includes(constants/* vitePluginSubScriptEnvNames.resolveViteConfig */.fe.resolveViteConfig), "Seems like the Keycloakify's Vite plugin is not installed.");
+        const resolvedViteConfigStr = output
+            .split(constants/* vitePluginSubScriptEnvNames.resolveViteConfig */.fe.resolveViteConfig)
+            .reverse()[0];
+        const resolvedViteConfig = JSON.parse(resolvedViteConfigStr);
+        return { resolvedViteConfig };
+    })();
+    const parsedPackageJson = (() => {
+        const zParsedPackageJson = lib.z.object({
+            name: lib.z.string(),
+            version: lib.z.string().optional(),
+            homepage: lib.z.string().optional(),
+            keycloakify: (0,id.id)((() => {
+                const zBuildOptions_packageJson = lib.z.object({
+                    extraThemeProperties: lib.z.array(lib.z.string()).optional(),
+                    artifactId: lib.z.string().optional(),
+                    groupId: lib.z.string().optional(),
+                    loginThemeResourcesFromKeycloakVersion: lib.z.string().optional(),
+                    projectBuildDirPath: lib.z.string().optional(),
+                    keycloakifyBuildDirPath: lib.z.string().optional(),
+                    kcContextExclusionsFtl: lib.z.string().optional(),
+                    environmentVariables: lib.z.array(lib.z.object({
+                        name: lib.z.string(),
+                        default: lib.z.string()
+                    }))
+                        .optional(),
+                    themeName: lib.z.union([lib.z.string(), lib.z.array(lib.z.string())]).optional(),
+                    themeVersion: lib.z.string().optional(),
+                    staticDirPathInProjectBuildDirPath: lib.z.string().optional(),
+                    publicDirPath: lib.z.string().optional(),
+                    keycloakVersionTargets: (0,id.id)((() => {
+                        const zKeycloakVersionTargets = lib.z.union([
+                            lib.z.object({
+                                hasAccountTheme: lib.z.literal(true),
+                                "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()])
+                            }),
+                            lib.z.object({
+                                hasAccountTheme: lib.z.literal(false),
+                                "21-and-below": lib.z.union([
+                                    lib.z.boolean(),
+                                    lib.z.string()
+                                ]),
+                                "22-and-above": lib.z.union([lib.z.boolean(), lib.z.string()])
+                            })
+                        ]);
+                        {
+                            (0,assert.assert)();
+                        }
+                        return zKeycloakVersionTargets;
+                    })()).optional()
+                });
+                {
+                    (0,assert.assert)();
+                }
+                return zBuildOptions_packageJson;
+            })()).optional()
+        });
+        {
+            (0,assert.assert)();
+        }
+        return zParsedPackageJson.parse(JSON.parse(external_fs_.readFileSync((0,external_path_.join)(projectDirPath, "package.json")).toString("utf8")));
+    })();
+    const buildOptions = Object.assign(Object.assign({}, parsedPackageJson.keycloakify), resolvedViteConfig === null || resolvedViteConfig === void 0 ? void 0 : resolvedViteConfig.buildOptions);
+    const { 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/* themeTypes */.rO, "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.",
+            "See: https://docs.keycloakify.dev/v/v10/keycloakify-in-my-app/collocation"
+        ].join("\n")));
+        process.exit(1);
+    })();
+    const recordIsImplementedByThemeType = (0,objectFromEntries.objectFromEntries)(["login", "account", "email"].map(themeType => [
+        themeType,
+        external_fs_.existsSync((0,external_path_.join)(themeSrcDirPath, themeType))
+    ]));
+    const themeNames = (() => {
+        if (buildOptions.themeName === undefined) {
+            return [
+                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 (resolvedViteConfig !== undefined) {
+                break webpack;
+            }
+            if (buildOptions.projectBuildDirPath !== undefined) {
+                return (0,getAbsoluteAndInOsFormatPath/* getAbsoluteAndInOsFormatPath */.c)({
+                    pathIsh: buildOptions.projectBuildDirPath,
+                    cwd: projectDirPath
+                });
+            }
+            return (0,external_path_.join)(projectDirPath, "build");
+        }
+        return (0,external_path_.join)(projectDirPath, resolvedViteConfig.buildDir);
+    })();
+    const { npmWorkspaceRootDirPath } = getNpmWorkspaceRootDirPath({
+        projectDirPath,
+        dependencyExpected: "keycloakify"
+    });
+    const bundler = resolvedViteConfig !== undefined ? "vite" : "webpack";
+    return {
+        bundler,
+        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 : "24.0.4",
+        projectDirPath,
+        projectBuildDirPath,
+        keycloakifyBuildDirPath: (() => {
+            if (buildOptions.keycloakifyBuildDirPath !== undefined) {
+                return (0,getAbsoluteAndInOsFormatPath/* getAbsoluteAndInOsFormatPath */.c)({
+                    pathIsh: buildOptions.keycloakifyBuildDirPath,
+                    cwd: projectDirPath
+                });
+            }
+            return (0,external_path_.join)(projectDirPath, (resolvedViteConfig === null || resolvedViteConfig === void 0 ? void 0 : resolvedViteConfig.buildDir) === undefined
+                ? "build_keycloak"
+                : `${resolvedViteConfig.buildDir}_keycloak`);
+        })(),
+        publicDirPath: (() => {
+            if (process.env.PUBLIC_DIR_PATH !== undefined) {
+                return (0,getAbsoluteAndInOsFormatPath/* getAbsoluteAndInOsFormatPath */.c)({
+                    pathIsh: process.env.PUBLIC_DIR_PATH,
+                    cwd: projectDirPath
+                });
+            }
+            webpack: {
+                if (resolvedViteConfig !== undefined) {
+                    break webpack;
+                }
+                if (buildOptions.publicDirPath !== undefined) {
+                    return (0,getAbsoluteAndInOsFormatPath/* getAbsoluteAndInOsFormatPath */.c)({
+                        pathIsh: buildOptions.publicDirPath,
+                        cwd: projectDirPath
+                    });
+                }
+                return (0,external_path_.join)(projectDirPath, "public");
+            }
+            return (0,external_path_.join)(projectDirPath, resolvedViteConfig.publicDir);
+        })(),
+        cacheDirPath: (() => {
+            const cacheDirPath = (0,external_path_.join)((() => {
+                if (process.env.XDG_CACHE_HOME !== undefined) {
+                    return (0,getAbsoluteAndInOsFormatPath/* getAbsoluteAndInOsFormatPath */.c)({
+                        pathIsh: process.env.XDG_CACHE_HOME,
+                        cwd: process.cwd()
+                    });
+                }
+                return (0,external_path_.join)(npmWorkspaceRootDirPath, "node_modules", ".cache");
+            })(), "keycloakify");
+            return cacheDirPath;
+        })(),
+        urlPathname: (() => {
+            webpack: {
+                if (resolvedViteConfig !== undefined) {
+                    break webpack;
+                }
+                const { homepage } = parsedPackageJson;
+                let url = undefined;
+                if (homepage !== undefined) {
+                    url = new URL(homepage);
+                }
+                if (url === undefined) {
+                    return undefined;
+                }
+                const out = url.pathname.replace(/([^/])$/, "$1/");
+                return out === "/" ? undefined : out;
+            }
+            return resolvedViteConfig.urlPathname;
+        })(),
+        assetsDirPath: (() => {
+            webpack: {
+                if (resolvedViteConfig !== undefined) {
+                    break webpack;
+                }
+                if (buildOptions.staticDirPathInProjectBuildDirPath !== undefined) {
+                    (0,getAbsoluteAndInOsFormatPath/* getAbsoluteAndInOsFormatPath */.c)({
+                        pathIsh: buildOptions.staticDirPathInProjectBuildDirPath,
+                        cwd: projectBuildDirPath
+                    });
+                }
+                return (0,external_path_.join)(projectBuildDirPath, "static");
+            }
+            return (0,external_path_.join)(projectBuildDirPath, resolvedViteConfig.assetsDir);
+        })(),
+        npmWorkspaceRootDirPath,
+        kcContextExclusionsFtlCode: (() => {
+            if (buildOptions.kcContextExclusionsFtl === undefined) {
+                return undefined;
+            }
+            if (buildOptions.kcContextExclusionsFtl.endsWith(".ftl")) {
+                const kcContextExclusionsFtlPath = (0,getAbsoluteAndInOsFormatPath/* getAbsoluteAndInOsFormatPath */.c)({
+                    pathIsh: buildOptions.kcContextExclusionsFtl,
+                    cwd: projectDirPath
+                });
+                return external_fs_.readFileSync(kcContextExclusionsFtlPath).toString("utf8");
+            }
+            return buildOptions.kcContextExclusionsFtl;
+        })(),
+        environmentVariables: (_f = buildOptions.environmentVariables) !== null && _f !== void 0 ? _f : [],
+        recordIsImplementedByThemeType,
+        themeSrcDirPath,
+        jarTargets: (() => {
+            const getDefaultJarFileBasename = (range) => `keycloak-theme-for-kc-${range}.jar`;
+            build_for_specific_keycloak_major_version: {
+                const buildForKeycloakMajorVersionNumber = (() => {
+                    const envValue = process.env[constants/* buildForKeycloakMajorVersionEnvName */.um];
+                    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 = (() => {
+                    const doesImplementAccountTheme = recordIsImplementedByThemeType.account;
+                    if (doesImplementAccountTheme) {
+                        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 (recordIsImplementedByThemeType.account) {
+                    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;
+            }
+            if (buildOptions.keycloakVersionTargets.hasAccountTheme !==
+                recordIsImplementedByThemeType.account) {
+                console.log(source_default().red((() => {
+                    const { keycloakVersionTargets } = buildOptions;
+                    let message = `Bad ${(0,symToStr/* symToStr */.r)({ keycloakVersionTargets })} configuration.\n`;
+                    if (keycloakVersionTargets.hasAccountTheme) {
+                        message +=
+                            "Your codebase does not seem to implement an account theme ";
+                    }
+                    else {
+                        message += "Your codebase implements an account theme ";
+                    }
+                    const { hasAccountTheme } = keycloakVersionTargets;
+                    message += `but you have set ${(0,symToStr/* symToStr */.r)({ keycloakVersionTargets })}.${(0,symToStr/* symToStr */.r)({ hasAccountTheme })}`;
+                    message += ` to ${hasAccountTheme} in your `;
+                    message += (() => {
+                        switch (bundler) {
+                            case "vite":
+                                return "vite.config.ts";
+                            case "webpack":
+                                return "package.json";
+                        }
+                        (0,assert.assert)(false);
+                    })();
+                    message += `. Please set it to ${!hasAccountTheme} `;
+                    message +=
+                        "and fill up the relevant keycloak version ranges.\n";
+                    message += "Example:\n";
+                    message += JSON.stringify((0,id.id)({
+                        keycloakVersionTargets: Object.assign({ hasAccountTheme: recordIsImplementedByThemeType.account }, (0,objectFromEntries.objectFromEntries)(jarTargets_default.map(({ keycloakVersionRange, jarFileBasename }) => [
+                            keycloakVersionRange,
+                            jarFileBasename
+                        ])))
+                    }), null, 2);
+                    message +=
+                        "\nSee: https://docs.keycloakify.dev/v/v10/targetting-specific-keycloak-versions";
+                    return message;
+                })()));
+                process.exit(1);
+            }
+            const jarTargets = [];
+            const _a = buildOptions.keycloakVersionTargets, { hasAccountTheme } = _a, rest = __rest(_a, ["hasAccountTheme"]);
+            for (const [keycloakVersionRange, jarNameOrBoolean] of (0,objectEntries.objectEntries)(rest)) {
+                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 */   "M": () => (/* binding */ basenameOfTheKeycloakifyResourcesDir),
+/* harmony export */   "N$": () => (/* binding */ keycloak_resources),
+/* harmony export */   "UX": () => (/* binding */ accountThemePageIds),
+/* harmony export */   "fe": () => (/* binding */ vitePluginSubScriptEnvNames),
+/* harmony export */   "h6": () => (/* binding */ containerName),
+/* harmony export */   "rO": () => (/* binding */ themeTypes),
+/* harmony export */   "sj": () => (/* binding */ loginThemePageIds),
+/* harmony export */   "um": () => (/* binding */ buildForKeycloakMajorVersionEnvName),
+/* harmony export */   "v$": () => (/* binding */ lastKeycloakVersionWithAccountV1),
+/* harmony export */   "y_": () => (/* binding */ accountV1ThemeName),
+/* harmony export */   "z0": () => (/* binding */ resources_common)
+/* harmony export */ });
+const keycloak_resources = "keycloak-resources";
+const resources_common = "resources-common";
+const lastKeycloakVersionWithAccountV1 = "21.1.2";
+const basenameOfTheKeycloakifyResourcesDir = "dist";
+const themeTypes = ["login", "account"];
+const accountV1ThemeName = "account-v1";
+const vitePluginSubScriptEnvNames = {
+    runPostBuildScript: "KEYCLOAKIFY_RUN_POST_BUILD_SCRIPT",
+    resolveViteConfig: "KEYCLOAKIFY_RESOLVE_VITE_CONFIG"
+};
+const buildForKeycloakMajorVersionEnvName = "KEYCLOAKIFY_BUILD_FOR_KEYCLOAK_MAJOR_VERSION";
+const loginThemePageIds = [
+    "login.ftl",
+    "login-username.ftl",
+    "login-password.ftl",
+    "webauthn-authenticate.ftl",
+    "webauthn-register.ftl",
+    "register.ftl",
+    "info.ftl",
+    "error.ftl",
+    "login-reset-password.ftl",
+    "login-verify-email.ftl",
+    "terms.ftl",
+    "login-oauth2-device-verify-user-code.ftl",
+    "login-oauth-grant.ftl",
+    "login-otp.ftl",
+    "login-update-profile.ftl",
+    "login-update-password.ftl",
+    "login-idp-link-confirm.ftl",
+    "login-idp-link-email.ftl",
+    "login-page-expired.ftl",
+    "login-config-totp.ftl",
+    "logout-confirm.ftl",
+    "idp-review-user-profile.ftl",
+    "update-email.ftl",
+    "select-authenticator.ftl",
+    "saml-post-form.ftl",
+    "delete-credential.ftl",
+    "code.ftl",
+    "delete-account-confirm.ftl",
+    "frontchannel-logout.ftl",
+    "login-recovery-authn-code-config.ftl",
+    "login-recovery-authn-code-input.ftl",
+    "login-reset-otp.ftl",
+    "login-x509-info.ftl",
+    "webauthn-error.ftl"
+];
+const accountThemePageIds = [
+    "password.ftl",
+    "account.ftl",
+    "sessions.ftl",
+    "totp.ftl",
+    "applications.ftl",
+    "log.ftl",
+    "federatedIdentity.ftl"
+];
+const containerName = "keycloak-keycloakify";
+//# sourceMappingURL=constants.js.map
+
+/***/ }),
+
+/***/ 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
+
+/***/ })
+
+};
+;