fix(deps): update dependency powerhooks to ^0.26.0

bump version
Use keycloakify as bundler by default
2023-02-05 15:10:42 +00:00 · 2023-02-05 14:58:53 +01:00 · 2023-02-05 14:58:38 +01:00 · 2023-02-05 14:41:32 +01:00 · 2023-02-05 14:41:13 +01:00 · 2023-02-05 13:36:52 +01:00
44 changed files with 1284 additions and 528 deletions
--- a/README.md
+++ b/README.md
@ -49,6 +49,20 @@

 # Changelog highlights

+## 6.11.4
+
+-   You no longer need to have Maven installed to build the theme. Thanks to @lordvlad, [see PR](https://github.com/InseeFrLab/keycloakify/pull/239).
+-   Feature new build options: [`bundler`](https://docs.keycloakify.dev/build-options#keycloakify.bundler), [`groupId`](https://docs.keycloakify.dev/build-options#keycloakify.groupid), [`artifactId`](https://docs.keycloakify.dev/build-options#keycloakify.artifactid), [`version`](https://docs.keycloakify.dev/build-options#version).  
+    Theses options can be user to customize the output name of the .jar. You can use environnement variables to overrides the values read in the package.json. Thanks to @lordvlad.
+
+## 6.10.0
+
+-   Widows compat (thanks to @lordvlad, [see PR](https://github.com/InseeFrLab/keycloakify/pull/226)). WSL is no longer required 🎉
+
+## 6.8.4
+
+-   `@emotion/react` is no longer a peer dependency of Keycloakify.
+
 ## 6.8.0

 -   It is now possible to pass a custom `<Template />` component as a prop to `<KcApp />` and every
--- a/package.json
+++ b/package.json
@ -1,6 +1,6 @@
 {
    "name": "keycloakify",
-    "version": "6.8.2",
+    "version": "6.11.5",
    "description": "Keycloak theme generator for Reacts app",
    "repository": {
        "type": "git",
@ -55,12 +55,10 @@
    ],
    "homepage": "https://github.com/garronej/keycloakify",
    "peerDependencies": {
-        "@emotion/react": "^11.4.1",
        "react": "^16.8.0 || ^17.0.0 || ^18.0.0"
    },
    "devDependencies": {
        "@babel/core": "^7.0.0",
-        "@emotion/react": "^11.4.1",
        "@types/memoizee": "^0.4.7",
        "@types/minimist": "^1.2.2",
        "@types/node": "^17.0.25",
@ -72,23 +70,24 @@
        "properties-parser": "^0.3.1",
        "react": "18.1.0",
        "rimraf": "^3.0.2",
+        "@emotion/react": "^11.10.4",
        "typescript": "^4.2.3"
    },
    "dependencies": {
        "@octokit/rest": "^18.12.0",
        "cheerio": "^1.0.0-rc.5",
        "cli-select": "^1.1.2",
-        "evt": "^2.4.6",
+        "evt": "^2.4.13",
        "memoizee": "^0.4.15",
        "minimal-polyfills": "^2.2.2",
        "minimist": "^1.2.6",
        "path-browserify": "^1.0.1",
-        "powerhooks": "^0.20.23",
+        "powerhooks": "^0.26.0",
        "react-markdown": "^5.0.3",
        "rfc4648": "^1.5.2",
        "scripting-tools": "^0.19.13",
-        "tsafe": "^1.1.3",
-        "tss-react": "^4.3.4",
+        "tsafe": "^1.4.2",
+        "tss-react": "4.4.1-rc.0",
        "zod": "^3.17.10"
    }
 }
--- a/renovate.json
+++ b/renovate.json
@ -13,11 +13,11 @@
    "packageRules": [
        {
            "packagePatterns": ["*"],
-            "excludePackagePatterns": ["tss-react", "powerhooks", "tsafe", "evt"],
+            "excludePackagePatterns": ["powerhooks", "tsafe", "evt"],
            "enabled": false
        },
        {
-            "packagePatterns": ["tss-react", "powerhooks", "tsafe", "evt"],
+            "packagePatterns": ["powerhooks", "tsafe", "evt"],
            "matchUpdateTypes": ["minor", "patch"],
            "automerge": true,
            "automergeType": "branch",
--- a/src/bin/download-builtin-keycloak-theme.ts
+++ b/src/bin/download-builtin-keycloak-theme.ts
@ -7,11 +7,11 @@ import { promptKeycloakVersion } from "./promptKeycloakVersion";
 import { getCliOptions } from "./tools/cliOptions";
 import { getLogger } from "./tools/logger";

-export function downloadBuiltinKeycloakTheme(params: { keycloakVersion: string; destDirPath: string; isSilent: boolean }) {
+export async function downloadBuiltinKeycloakTheme(params: { keycloakVersion: string; destDirPath: string; isSilent: boolean }) {
    const { keycloakVersion, destDirPath, isSilent } = params;

    for (const ext of ["", "-community"]) {
-        downloadAndUnzip({
+        await downloadAndUnzip({
            "destDirPath": destDirPath,
            "url": `https://github.com/keycloak/keycloak/archive/refs/tags/${keycloakVersion}.zip`,
            "pathOfDirToExtractInArchive": `keycloak-${keycloakVersion}/themes/src/main/resources${ext}/theme`,
@ -31,7 +31,7 @@ if (require.main === module) {

        logger.log(`Downloading builtins theme of Keycloak ${keycloakVersion} here ${destDirPath}`);

-        downloadBuiltinKeycloakTheme({
+        await downloadBuiltinKeycloakTheme({
            keycloakVersion,
            destDirPath,
            isSilent
--- a/src/bin/generate-i18n-messages.ts
+++ b/src/bin/generate-i18n-messages.ts
@ -4,7 +4,6 @@ import { join as pathJoin, relative as pathRelative, dirname as pathDirname } fr
 import { crawl } from "./tools/crawl";
 import { downloadBuiltinKeycloakTheme } from "./download-builtin-keycloak-theme";
 import { getProjectRoot } from "./tools/getProjectRoot";
-import { rm_rf, rm_r } from "./tools/rm";
 import { getCliOptions } from "./tools/cliOptions";
 import { getLogger } from "./tools/logger";

@ -22,7 +21,7 @@ for (const keycloakVersion of ["11.0.3", "15.0.2", "18.0.1"]) {

    const tmpDirPath = pathJoin(getProjectRoot(), "tmp_xImOef9dOd44");

-    rm_rf(tmpDirPath);
+    fs.rmSync(tmpDirPath, { "recursive": true, "force": true });

    downloadBuiltinKeycloakTheme({
        keycloakVersion,
@ -54,7 +53,7 @@ for (const keycloakVersion of ["11.0.3", "15.0.2", "18.0.1"]) {
        });
    }

-    rm_r(tmpDirPath);
+    fs.rmSync(tmpDirPath, { recursive: true, force: true });

    Object.keys(record).forEach(pageType => {
        const recordForPageType = record[pageType];
--- a/src/bin/keycloakify/BuildOptions.ts
+++ b/src/bin/keycloakify/BuildOptions.ts
@ -3,7 +3,11 @@ import { assert } from "tsafe/assert";
 import type { Equals } from "tsafe";
 import { id } from "tsafe/id";
 import { parse as urlParse } from "url";
+import { typeGuard } from "tsafe/typeGuard";
+import { symToStr } from "tsafe/symToStr";

+const bundlers = ["mvn", "keycloakify", "none"] as const;
+type Bundler = typeof bundlers[number];
 type ParsedPackageJson = {
    name: string;
    version: string;
@ -12,6 +16,9 @@ type ParsedPackageJson = {
        extraPages?: string[];
        extraThemeProperties?: string[];
        areAppAndKeycloakServerSharingSameDomain?: boolean;
+        artifactId?: string;
+        groupId?: string;
+        bundler?: Bundler;
    };
 };

@ -23,7 +30,10 @@ const zParsedPackageJson = z.object({
        .object({
            "extraPages": z.array(z.string()).optional(),
            "extraThemeProperties": z.array(z.string()).optional(),
-            "areAppAndKeycloakServerSharingSameDomain": z.boolean().optional()
+            "areAppAndKeycloakServerSharingSameDomain": z.boolean().optional(),
+            "artifactId": z.string().optional(),
+            "groupId": z.string().optional(),
+            "bundler": z.enum(bundlers).optional()
        })
        .optional()
 });
@ -40,8 +50,9 @@ export namespace BuildOptions {
        themeName: string;
        extraPages?: string[];
        extraThemeProperties?: string[];
-        //NOTE: Only for the pom.xml file, questionable utility...
        groupId: string;
+        artifactId: string;
+        bundler: Bundler;
    };

    export type Standalone = Common & {
@ -108,7 +119,7 @@ export function readBuildOptions(params: {
    const common: BuildOptions.Common = (() => {
        const { name, keycloakify = {}, version, homepage } = parsedPackageJson;

-        const { extraPages, extraThemeProperties } = keycloakify ?? {};
+        const { extraPages, extraThemeProperties, groupId, artifactId, bundler } = keycloakify ?? {};

        const themeName = name
            .replace(/^@(.*)/, "$1")
@ -117,10 +128,26 @@ export function readBuildOptions(params: {

        return {
            themeName,
+            "bundler": (() => {
+                const { KEYCLOAKIFY_BUNDLER } = process.env;
+
+                assert(
+                    typeGuard<Bundler | undefined>(
+                        KEYCLOAKIFY_BUNDLER,
+                        [undefined, ...id<readonly string[]>(bundlers)].includes(KEYCLOAKIFY_BUNDLER)
+                    ),
+                    `${symToStr({ KEYCLOAKIFY_BUNDLER })} should be one of ${bundlers.join(", ")}`
+                );
+
+                return KEYCLOAKIFY_BUNDLER ?? bundler ?? "keycloakify";
+            })(),
+            "artifactId": process.env.KEYCLOAKIFY_ARTIFACT_ID ?? artifactId ?? `${themeName}-keycloak-theme`,
            "groupId": (() => {
                const fallbackGroupId = `${themeName}.keycloak`;

                return (
+                    process.env.KEYCLOAKIFY_GROUP_ID ??
+                    groupId ??
                    (!homepage
                        ? fallbackGroupId
                        : urlParse(homepage)
@ -130,7 +157,7 @@ export function readBuildOptions(params: {
                              .join(".") ?? fallbackGroupId) + ".keycloak"
                );
            })(),
-            "version": version,
+            "version": process.env.KEYCLOAKIFY_VERSION ?? version,
            extraPages,
            extraThemeProperties,
            isSilent
--- a/src/bin/keycloakify/generateFtl/ftl_object_to_js_code_declaring_an_object.ftl
+++ b/src/bin/keycloakify/generateFtl/ftl_object_to_js_code_declaring_an_object.ftl
@ -36,7 +36,11 @@ ${ftl_object_to_js_code_declaring_an_object(.data_model, [])?no_esc};
                <#list fieldNames as fieldName>
                    if(fieldName === "${fieldName}" ){
                        <#attempt>
-                            return "${messagesPerField.printIfExists(fieldName,'1')}" ? x : undefined;
+                            <#if '${fieldName}' == 'username' || '${fieldName}' == 'password'>
+                                return <#if messagesPerField.existsError('username', 'password')>x<#else>undefined</#if>;
+                            <#else>
+                                return <#if messagesPerField.existsError('${fieldName}')>x<#else>undefined</#if>;
+                            </#if>
                        <#recover>
                        </#attempt>
                    }
@ -51,7 +55,11 @@ ${ftl_object_to_js_code_declaring_an_object(.data_model, [])?no_esc};
                <#list fieldNames as fieldName>
                    if(fieldName === "${fieldName}" ){
                        <#attempt>
-                            return <#if messagesPerField.existsError('${fieldName}')>true<#else>false</#if>;
+                            <#if '${fieldName}' == 'username' || '${fieldName}' == 'password'>
+                                return <#if messagesPerField.existsError('username', 'password')>true<#else>false</#if>;
+                            <#else>
+                                return <#if messagesPerField.existsError('${fieldName}')>true<#else>false</#if>;
+                            </#if>
                        <#recover>
                        </#attempt>
                    }
@ -66,8 +74,14 @@ ${ftl_object_to_js_code_declaring_an_object(.data_model, [])?no_esc};
                <#list fieldNames as fieldName>
                    if(fieldName === "${fieldName}" ){
                        <#attempt>
-                            <#if messagesPerField.existsError('${fieldName}')>
-                                return "${messagesPerField.get('${fieldName}')?no_esc}";
+                            <#if '${fieldName}' == 'username' || '${fieldName}' == 'password'>
+                                <#if messagesPerField.existsError('username', 'password')>
+                                    return 'Invalid username or password.';
+                                </#if>
+                            <#else>
+                                <#if messagesPerField.existsError('${fieldName}')>
+                                    return "${messagesPerField.get('${fieldName}')?no_esc}";
+                                </#if>
                            </#if>
                        <#recover>
                        </#attempt>
@ -83,7 +97,11 @@ ${ftl_object_to_js_code_declaring_an_object(.data_model, [])?no_esc};
                <#list fieldNames as fieldName>
                    if(fieldName === "${fieldName}" ){
                        <#attempt>
-                            return <#if messagesPerField.exists('${fieldName}')>true<#else>false</#if>;
+                            <#if '${fieldName}' == 'username' || '${fieldName}' == 'password'>
+                                return <#if messagesPerField.exists('username') ||  messagesPerField.exists('password')>true<#else>false</#if>;
+                            <#else>
+                                return <#if messagesPerField.exists('${fieldName}')>true<#else>false</#if>;
+                            </#if>
                        <#recover>
                        </#attempt>
                    }
--- a/src/bin/keycloakify/generateJavaStackFiles.ts
+++ b/src/bin/keycloakify/generateJavaStackFiles.ts
@ -7,6 +7,8 @@ import type { BuildOptions } from "./BuildOptions";
 export type BuildOptionsLike = {
    themeName: string;
    groupId: string;
+    artifactId?: string;
+    version: string;
 };

 {
@ -16,7 +18,6 @@ export type BuildOptionsLike = {
 }

 export function generateJavaStackFiles(params: {
-    version: string;
    keycloakThemeBuildingDirPath: string;
    doBundlesEmailTemplate: boolean;
    buildOptions: BuildOptionsLike;
@ -24,8 +25,7 @@ export function generateJavaStackFiles(params: {
    jarFilePath: string;
 } {
    const {
-        version,
-        buildOptions: { groupId, themeName },
+        buildOptions: { groupId, themeName, version, artifactId },
        keycloakThemeBuildingDirPath,
        doBundlesEmailTemplate
    } = params;
@ -34,8 +34,6 @@ export function generateJavaStackFiles(params: {
        const { pomFileCode } = (function generatePomFileCode(): {
            pomFileCode: string;
        } {
-            const artefactId = `${themeName}-keycloak-theme`;
-
            const pomFileCode = [
                `<?xml version="1.0"?>`,
                `<project xmlns="http://maven.apache.org/POM/4.0.0"`,
@ -43,9 +41,9 @@ export function generateJavaStackFiles(params: {
                `	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>${groupId}</groupId>`,
-                `	<artifactId>${artefactId}</artifactId>`,
+                `	<artifactId>${artifactId}</artifactId>`,
                `	<version>${version}</version>`,
-                `	<name>${artefactId}</name>`,
+                `	<name>${artifactId}</name>`,
                `	<description />`,
                `</project>`
            ].join("\n");
@ -84,6 +82,6 @@ export function generateJavaStackFiles(params: {
    }

    return {
-        "jarFilePath": pathJoin(keycloakThemeBuildingDirPath, "target", `${themeName}-${version}.jar`)
+        "jarFilePath": pathJoin(keycloakThemeBuildingDirPath, "target", `${artifactId}-${version}.jar`)
    };
 }
--- a/src/bin/keycloakify/generateKeycloakThemeResources.ts
+++ b/src/bin/keycloakify/generateKeycloakThemeResources.ts
@ -5,7 +5,6 @@ import { replaceImportsFromStaticInJsCode } from "./replacers/replaceImportsFrom
 import { replaceImportsInCssCode } from "./replacers/replaceImportsInCssCode";
 import { generateFtlFilesCodeFactory, pageIds } from "./generateFtl";
 import { downloadBuiltinKeycloakTheme } from "../download-builtin-keycloak-theme";
-import * as child_process from "child_process";
 import { mockTestingResourcesCommonPath, mockTestingResourcesPath, mockTestingSubDirOfPublicDirBasename } from "../mockTestingResourcesPath";
 import { isInside } from "../tools/isInside";
 import type { BuildOptions } from "./BuildOptions";
@ -53,13 +52,13 @@ export namespace BuildOptionsLike {
    assert<typeof buildOptions extends BuildOptionsLike ? true : false>();
 }

-export function generateKeycloakThemeResources(params: {
+export async function generateKeycloakThemeResources(params: {
    reactAppBuildDirPath: string;
    keycloakThemeBuildingDirPath: string;
    keycloakThemeEmailDirPath: string;
    keycloakVersion: string;
    buildOptions: BuildOptionsLike;
-}): { doBundlesEmailTemplate: boolean } {
+}): Promise<{ doBundlesEmailTemplate: boolean }> {
    const { reactAppBuildDirPath, keycloakThemeBuildingDirPath, keycloakThemeEmailDirPath, keycloakVersion, buildOptions } = params;

    const logger = getLogger({ isSilent: buildOptions.isSilent });
@ -155,7 +154,7 @@ export function generateKeycloakThemeResources(params: {
    {
        const tmpDirPath = pathJoin(themeDirPath, "..", "tmp_xxKdLpdIdLd");

-        downloadBuiltinKeycloakTheme({
+        await downloadBuiltinKeycloakTheme({
            keycloakVersion,
            "destDirPath": tmpDirPath,
            isSilent: buildOptions.isSilent
@ -190,8 +189,7 @@ export function generateKeycloakThemeResources(params: {
        );

        fs.writeFileSync(pathJoin(keycloakResourcesWithinPublicDirPath, ".gitignore"), Buffer.from("*", "utf8"));
-
-        child_process.execSync(`rm -r ${tmpDirPath}`);
+        fs.rmSync(tmpDirPath, { recursive: true, force: true });
    }

    fs.writeFileSync(
--- a/src/bin/keycloakify/generateStartKeycloakTestingContainer.ts
+++ b/src/bin/keycloakify/generateStartKeycloakTestingContainer.ts
@ -34,7 +34,7 @@ export function generateStartKeycloakTestingContainer(params: {
        pathJoin(keycloakThemeBuildingDirPath, generateStartKeycloakTestingContainer.basename),
        Buffer.from(
            [
-                "#!/bin/bash",
+                "#!/usr/bin/env bash",
                "",
                `docker rm ${containerName} || true`,
                "",
--- a/src/bin/keycloakify/index.ts
+++ b/src/bin/keycloakify/index.ts
@ -4,5 +4,5 @@ export * from "./keycloakify";
 import { main } from "./keycloakify";

 if (require.main === module) {
-    main();
+    main().catch(e => console.error(e));
 }
--- a/src/bin/keycloakify/keycloakify.ts
+++ b/src/bin/keycloakify/keycloakify.ts
@ -7,13 +7,16 @@ import * as fs from "fs";
 import { readBuildOptions } from "./BuildOptions";
 import { getLogger } from "../tools/logger";
 import { getCliOptions } from "../tools/cliOptions";
+import jar from "../tools/jar";
+import { assert } from "tsafe/assert";
+import type { Equals } from "tsafe";

 const reactProjectDirPath = process.cwd();

 export const keycloakThemeBuildingDirPath = pathJoin(reactProjectDirPath, "build_keycloak");
 export const keycloakThemeEmailDirPath = pathJoin(keycloakThemeBuildingDirPath, "..", "keycloak_email");

-export function main() {
+export async function main() {
    const { isSilent, hasExternalAssets } = getCliOptions(process.argv.slice(2));
    const logger = getLogger({ isSilent });
    logger.log("🔏 Building the keycloak theme...⌚");
@ -33,7 +36,7 @@ export function main() {
        "isSilent": isSilent
    });

-    const { doBundlesEmailTemplate } = generateKeycloakThemeResources({
+    const { doBundlesEmailTemplate } = await generateKeycloakThemeResources({
        keycloakThemeBuildingDirPath,
        keycloakThemeEmailDirPath,
        "reactAppBuildDirPath": pathJoin(reactProjectDirPath, "build"),
@ -45,18 +48,35 @@ export function main() {
    });

    const { jarFilePath } = generateJavaStackFiles({
-        "version": buildOptions.version,
        keycloakThemeBuildingDirPath,
        doBundlesEmailTemplate,
        buildOptions
    });

-    child_process.execSync("mvn package", {
-        "cwd": keycloakThemeBuildingDirPath
-    });
+    switch (buildOptions.bundler) {
+        case "none":
+            logger.log("😱 Skipping bundling step, there will be no jar");
+            break;
+        case "keycloakify":
+            logger.log("🫶 Let keycloakify do its thang");
+            await jar({
+                "rootPath": pathJoin(keycloakThemeBuildingDirPath, "src", "main", "resources"),
+                "version": buildOptions.version,
+                "groupId": buildOptions.groupId,
+                "artifactId": buildOptions.artifactId,
+                "targetPath": jarFilePath
+            });
+            break;
+        case "mvn":
+            logger.log("🫙 Run maven to deliver a jar");
+            child_process.execSync("mvn package", { "cwd": keycloakThemeBuildingDirPath });
+            break;
+        default:
+            assert<Equals<typeof buildOptions.bundler, never>>(false);
+    }

-    //We want, however, to test in a container running the latest Keycloak version
-    const containerKeycloakVersion = "19.0.1";
+    // We want, however, to test in a container running the latest Keycloak version
+    const containerKeycloakVersion = "20.0.1";

    generateStartKeycloakTestingContainer({
        keycloakThemeBuildingDirPath,
--- a/src/bin/link_in_test_app.ts
+++ b/src/bin/link_in_test_app.ts
@ -15,7 +15,8 @@ fs.writeFileSync(
                return {
                    ...packageJsonParsed,
                    "main": packageJsonParsed["main"].replace(/^dist\//, ""),
-                    "types": packageJsonParsed["types"].replace(/^dist\//, "")
+                    "types": packageJsonParsed["types"].replace(/^dist\//, ""),
+                    "bin": Object.fromEntries(Object.entries<string>(packageJsonParsed["bin"]).map(([k, v]) => [k, v.replace(/^dist\//, "")]))
                };
            })(),
            null,
@ -43,7 +44,8 @@ const commonThirdPartyDeps = (() => {

 const yarnHomeDirPath = pathJoin(keycloakifyDirPath, ".yarn_home");

-execSync(["rm -rf", "mkdir"].map(cmd => `${cmd} ${yarnHomeDirPath}`).join(" && "));
+fs.rmSync(yarnHomeDirPath, { "recursive": true, "force": true });
+fs.mkdirSync(yarnHomeDirPath);

 const execYarnLink = (params: { targetModuleName?: string; cwd: string }) => {
    const { targetModuleName, cwd } = params;
--- a/src/bin/tools/crc32.ts
+++ b/src/bin/tools/crc32.ts
@ -0,0 +1,54 @@
+import { Readable } from "stream";
+
+const crc32tab = [
+    0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
+    0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
+    0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
+    0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
+    0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
+    0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
+    0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
+    0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
+    0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
+    0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
+    0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
+    0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
+    0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
+    0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
+    0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
+    0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
+    0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
+    0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
+    0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
+    0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
+    0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
+    0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
+];
+
+/**
+ *
+ * @param input either a byte stream, a string or a buffer, you want to have the checksum for
+ * @returns a promise for a checksum (uint32)
+ */
+export function crc32(input: Readable | String | Buffer): Promise<number> {
+    if (typeof input === "string") {
+        let crc = ~0;
+        for (let i = 0; i < input.length; i++) crc = (crc >>> 8) ^ crc32tab[(crc ^ input.charCodeAt(i)) & 0xff];
+        return Promise.resolve((crc ^ -1) >>> 0);
+    } else if (input instanceof Buffer) {
+        let crc = ~0;
+        for (let i = 0; i < input.length; i++) crc = (crc >>> 8) ^ crc32tab[(crc ^ input[i]) & 0xff];
+        return Promise.resolve((crc ^ -1) >>> 0);
+    } else if (input instanceof Readable) {
+        return new Promise<number>((resolve, reject) => {
+            let crc = ~0;
+            input.on("end", () => resolve((crc ^ -1) >>> 0));
+            input.on("error", e => reject(e));
+            input.on("data", (chunk: Buffer) => {
+                for (let i = 0; i < chunk.length; i++) crc = (crc >>> 8) ^ crc32tab[(crc ^ chunk[i]) & 0xff];
+            });
+        });
+    } else {
+        throw new Error("Unsupported input " + typeof input);
+    }
+}
--- a/src/bin/tools/deflate.ts
+++ b/src/bin/tools/deflate.ts
@ -0,0 +1,61 @@
+import { PassThrough, Readable, TransformCallback, Writable } from "stream";
+import { pipeline } from "stream/promises";
+import { deflateRaw as deflateRawCb, createDeflateRaw } from "zlib";
+import { promisify } from "util";
+
+import { crc32 } from "./crc32";
+import tee from "./tee";
+
+const deflateRaw = promisify(deflateRawCb);
+
+/**
+ * A stream transformer that records the number of bytes
+ * passed in its `size` property.
+ */
+class ByteCounter extends PassThrough {
+    size: number = 0;
+    _transform(chunk: any, encoding: BufferEncoding, callback: TransformCallback) {
+        if ("length" in chunk) this.size += chunk.length;
+        super._transform(chunk, encoding, callback);
+    }
+}
+
+/**
+ * @param data buffer containing the data to be compressed
+ * @returns a buffer containing the compressed/deflated data and the crc32 checksum
+ *  of the source data
+ */
+export async function deflateBuffer(data: Buffer) {
+    const [deflated, checksum] = await Promise.all([deflateRaw(data), crc32(data)]);
+    return { deflated, crc32: checksum };
+}
+
+/**
+ * @param input a byte stream, containing data to be compressed
+ * @param sink a method that will accept chunks of compressed data; We don't pass
+ *   a writable here, since we don't want the writablestream to be closed after
+ *   a single file
+ * @returns a promise, which will resolve with the crc32 checksum and the
+ * compressed size
+ */
+export async function deflateStream(input: Readable, sink: (chunk: Buffer) => void) {
+    const deflateWriter = new Writable({
+        write(chunk, _, callback) {
+            sink(chunk);
+            callback();
+        }
+    });
+
+    // tee the input stream, so we can compress and calc crc32 in parallel
+    const [rs1, rs2] = tee(input);
+    const byteCounter = new ByteCounter();
+    const [_, crc] = await Promise.all([
+        // pipe input into zip compressor, count the bytes
+        // returned and pass compressed data to the sink
+        pipeline(rs1, createDeflateRaw(), byteCounter, deflateWriter),
+        // calc checksum
+        crc32(rs2)
+    ]);
+
+    return { crc32: crc, compressedSize: byteCounter.size };
+}
--- a/src/bin/tools/downloadAndUnzip.ts
+++ b/src/bin/tools/downloadAndUnzip.ts
@ -1,81 +1,289 @@
-import { basename as pathBasename, join as pathJoin } from "path";
-import { execSync } from "child_process";
-import * as fs from "fs";
+import { dirname as pathDirname, basename as pathBasename, join as pathJoin } from "path";
+import { createReadStream, createWriteStream, unlinkSync } from "fs";
+import { stat, mkdir, unlink, readFile, writeFile } from "fs/promises";
 import { transformCodebase } from "./transformCodebase";
-import { rm, rm_rf } from "./rm";
-import * as crypto from "crypto";
+import { createHash } from "crypto";
+import http from "http";
+import https from "https";
+import { createInflateRaw } from "zlib";

-/** assert url ends with .zip */
-export function downloadAndUnzip(params: {
+import type { Readable } from "stream";
+
+function hash(s: string) {
+    return createHash("sha256").update(s).digest("hex");
+}
+
+async function maybeReadFile(path: string) {
+    try {
+        return await readFile(path, "utf-8");
+    } catch (error) {
+        if ((error as Error & { code: string }).code === "ENOENT") return undefined;
+        throw error;
+    }
+}
+
+async function maybeStat(path: string) {
+    try {
+        return await stat(path);
+    } catch (error) {
+        if ((error as Error & { code: string }).code === "ENOENT") return undefined;
+        throw error;
+    }
+}
+
+/**
+ * Download a file from `url` to `dir`. Will try to avoid downloading existing
+ * files by using an `{hash(url)}.etag` file. If this file exists, we add an
+ * etag headear, so server can tell us if file changed and we should re-download
+ * or if our file is up-to-date.
+ *
+ * Warning, this method assumes that the target filename can be extracted from
+ * url, content-disposition headers are ignored.
+ *
+ * If the target directory does not exist, it will be created.
+ *
+ * If the target file exists and is out of date, it will be overwritten.
+ * If the target file exists and there is no etag file, the target file will
+ * be overwritten.
+ *
+ * @param url download url
+ * @param dir target directory
+ * @returns promise for the full path of the downloaded file
+ */
+async function download(url: string, dir: string): Promise<string> {
+    await mkdir(dir, { recursive: true });
+    const filename = pathBasename(url);
+    const filepath = pathJoin(dir, filename);
+    // If downloaded file exists already and has an `.etag` companion file,
+    // read the etag from that file. This will avoid re-downloading the file
+    // if it is up to date.
+    const exists = await maybeStat(filepath);
+    const etagFilepath = pathJoin(dir, "_" + hash(url).substring(0, 15) + ".etag");
+    const etag = !exists ? undefined : await maybeReadFile(etagFilepath);
+
+    return new Promise((resolve, reject) => {
+        // use inner method to allow following redirects
+        function request(url1: URL) {
+            const headers: Record<string, string> = {};
+            if (etag) headers["If-None-Match"] = etag;
+            (url1.protocol === "https:" ? https : http).get(url1, { headers }, response => {
+                if (response.statusCode === 301 || response.statusCode === 302) {
+                    // follow redirects
+                    request(new URL(response.headers.location!!));
+                } else if (response.statusCode === 304) {
+                    // up-to-date, resolve now
+                    resolve(filepath);
+                } else if (response.statusCode !== 200) {
+                    reject(new Error(`Request to ${url1} returned status ${response.statusCode}.`));
+                } else {
+                    const fp = createWriteStream(filepath, { autoClose: true });
+                    fp.on("err", e => {
+                        fp.close();
+                        unlinkSync(filepath);
+                        reject(e);
+                    });
+                    fp.on("finish", async () => {
+                        // when targetfile has been written, write etag file so that
+                        // next time around we don't need to re-download
+                        const responseEtag = response.headers.etag;
+                        if (responseEtag) await writeFile(etagFilepath, responseEtag, "utf-8");
+                        resolve(filepath);
+                    });
+                    response.pipe(fp);
+                }
+            });
+        }
+        request(new URL(url));
+    });
+}
+
+/**
+ * @typedef
+ * @type MultiError = Error & { cause: Error[] }
+ */
+
+/**
+ * Extract the archive `zipFile` into the directory `dir`. If `archiveDir` is given,
+ * only that directory will be extracted, stripping the given path components.
+ *
+ * If dir does not exist, it will be created.
+ *
+ * If any archive file exists, it will be overwritten.
+ *
+ * Will unzip using all available nodejs worker threads.
+ *
+ * Will try to clean up extracted files on failure.
+ *
+ * If unpacking fails, will either throw an regular error, or
+ * possibly an `MultiError`, which contains a `cause` field with
+ * a number of root cause errors.
+ *
+ * Warning this method is not optimized for continuous reading of the zip
+ * archive, but is a trade-off between simplicity and allowing extraction
+ * of a single directory from the archive.
+ *
+ * @param zipFile the file to unzip
+ * @param dir the target directory
+ * @param archiveDir if given, unpack only files from this archive directory
+ * @throws {MultiError} error
+ * @returns Promise for a list of full file paths pointing to actually extracted files
+ */
+async function unzip(zipFile: string, dir: string, archiveDir?: string): Promise<string[]> {
+    await mkdir(dir, { recursive: true });
+    const promises: Promise<string>[] = [];
+
+    // Iterate over all files in the zip, skip files which are not in archiveDir,
+    // if given.
+    for await (const record of iterateZipArchive(zipFile)) {
+        const { path: recordPath, createReadStream: createRecordReadStream } = record;
+        const filePath = pathJoin(dir, recordPath);
+        const parent = pathDirname(filePath);
+        if (archiveDir && !recordPath.startsWith(archiveDir)) continue;
+        promises.push(
+            new Promise<string>(async (resolve, reject) => {
+                await mkdir(parent, { recursive: true });
+                // Pull the file out of the archive, write it to the target directory
+                const input = createRecordReadStream();
+                const output = createWriteStream(filePath);
+                output.on("error", e => reject(Object.assign(e, { filePath })));
+                output.on("finish", () => resolve(filePath));
+                input.pipe(output);
+            })
+        );
+    }
+
+    // Wait until _all_ files are either extracted or failed
+    const results = await Promise.allSettled(promises);
+    const success = results.filter(r => r.status === "fulfilled").map(r => (r as PromiseFulfilledResult<string>).value);
+    const failure = results.filter(r => r.status === "rejected").map(r => (r as PromiseRejectedResult).reason);
+
+    // If any extraction failed, try to clean up, then throw a MultiError,
+    // which has a `cause` field, containing a list of root cause errors.
+    if (failure.length) {
+        await Promise.all(success.map(path => unlink(path)));
+        await Promise.all(failure.map(e => e && e.path && unlink(e.path as string)));
+        const e = new Error("Failed to extract: " + failure.map(e => e.message).join(";"));
+        (e as any).cause = failure;
+        throw e;
+    }
+
+    return success;
+}
+
+/**
+ *
+ * @param file file to read
+ * @param start first byte to read
+ * @param end last byte to read
+ * @returns Promise of a buffer of read bytes
+ */
+async function readFileChunk(file: string, start: number, end: number): Promise<Buffer> {
+    const chunks: Buffer[] = [];
+    return new Promise((resolve, reject) => {
+        const stream = createReadStream(file, { start, end });
+        stream.on("error", e => reject(e));
+        stream.on("end", () => resolve(Buffer.concat(chunks)));
+        stream.on("data", chunk => chunks.push(chunk as Buffer));
+    });
+}
+
+type ZipRecord = {
+    path: string;
+    createReadStream: () => Readable;
+    compressionMethod: "deflate" | undefined;
+};
+
+type ZipRecordGenerator = AsyncGenerator<ZipRecord, void, unknown>;
+
+/**
+ * Iterate over all records of a zipfile, and yield a ZipRecord.
+ * Use `record.createReadStream()` to actually read the file.
+ *
+ * Warning this method will only work with single-disk zip files.
+ * Warning this method may fail if the zip archive has an crazy amount
+ * of files and the central directory is not fully contained within the
+ * last 65k bytes of the zip file.
+ *
+ * @param zipFile
+ * @returns AsyncGenerator which will yield ZipRecords
+ */
+async function* iterateZipArchive(zipFile: string): ZipRecordGenerator {
+    // Need to know zip file size before we can do anything  else
+    const { size } = await stat(zipFile);
+    const chunkSize = 65_535 + 22 + 1; // max comment size + end header size + wiggle
+    // Read last ~65k bytes. Zip files have an comment up to 65_535 bytes at the very end,
+    // before that comes the zip central directory end header.
+    let chunk = await readFileChunk(zipFile, size - chunkSize, size);
+    const unread = size - chunk.length;
+    let i = chunk.length - 4;
+    let found = false;
+    // Find central directory end header, reading backwards from the end
+    while (!found && i-- > 0) if (chunk[i] === 0x50 && chunk.readUInt32LE(i) === 0x06054b50) found = true;
+    if (!found) throw new Error("Not a zip file");
+    // This method will fail on a multi-disk zip, so bail early.
+    if (chunk.readUInt16LE(i + 4) !== 0) throw new Error("Multi-disk zip not supported");
+    let nFiles = chunk.readUint16LE(i + 10);
+    // Get the position of the central directory
+    const directorySize = chunk.readUint32LE(i + 12);
+    const directoryOffset = chunk.readUint32LE(i + 16);
+    if (directoryOffset === 0xffff_ffff) throw new Error("zip64 not supported");
+    if (directoryOffset > size) throw new Error(`Central directory offset ${directoryOffset} is outside file`);
+    i = directoryOffset - unread;
+    // If i < 0, it means that the central directory is not contained within `chunk`
+    if (i < 0) {
+        chunk = await readFileChunk(zipFile, directoryOffset, directoryOffset + directorySize);
+        i = 0;
+    }
+    // Now iterate the central directory records, yield an `ZipRecord` for every entry
+    while (nFiles-- > 0) {
+        // Check for marker bytes
+        if (chunk.readUInt32LE(i) !== 0x02014b50) throw new Error("No central directory record at position " + (unread + i));
+        const compressionMethod = ({ 8: "deflate" } as const)[chunk.readUint16LE(i + 10)];
+        const compressedFileSize = chunk.readUint32LE(i + 20);
+        const filenameLength = chunk.readUint16LE(i + 28);
+        const extraLength = chunk.readUint16LE(i + 30);
+        const commentLength = chunk.readUint16LE(i + 32);
+        // Start of the actual content byte stream is after the 'local' record header,
+        // which is  30 bytes long plus filename and extra field
+        const start = chunk.readUint32LE(i + 42) + 30 + filenameLength + extraLength;
+        const end = start + compressedFileSize;
+        const filename = chunk.slice(i + 46, i + 46 + filenameLength).toString("utf-8");
+        const createRecordReadStream = () => {
+            const input = createReadStream(zipFile, { start, end });
+            if (compressionMethod === "deflate") {
+                const inflate = createInflateRaw();
+                input.pipe(inflate);
+                return inflate;
+            }
+            return input;
+        };
+        if (end > start) yield { path: filename, createReadStream: createRecordReadStream, compressionMethod };
+        // advance pointer to next central directory entry
+        i += 46 + filenameLength + extraLength + commentLength;
+    }
+}
+
+export async function downloadAndUnzip({
+    url,
+    destDirPath,
+    pathOfDirToExtractInArchive,
+    cacheDirPath
+}: {
    isSilent: boolean;
    url: string;
    destDirPath: string;
    pathOfDirToExtractInArchive?: string;
    cacheDirPath: string;
 }) {
-    const { url, destDirPath, pathOfDirToExtractInArchive, cacheDirPath } = params;
+    const downloadHash = hash(JSON.stringify({ url, pathOfDirToExtractInArchive })).substring(0, 15);
+    const extractDirPath = pathJoin(cacheDirPath, `_${downloadHash}`);

-    const extractDirPath = pathJoin(
-        cacheDirPath,
-        `_${crypto.createHash("sha256").update(JSON.stringify({ url, pathOfDirToExtractInArchive })).digest("hex").substring(0, 15)}`
-    );
+    const zipFilepath = await download(url, cacheDirPath);
+    const zipMtime = (await stat(zipFilepath)).mtimeMs;
+    const unzipMtime = (await maybeStat(extractDirPath))?.mtimeMs;

-    fs.mkdirSync(cacheDirPath, { "recursive": true });
+    if (!unzipMtime || zipMtime > unzipMtime) await unzip(zipFilepath, extractDirPath, pathOfDirToExtractInArchive);

-    const { readIsSuccessByExtractDirPath, writeIsSuccessByExtractDirPath } = (() => {
-        const filePath = pathJoin(cacheDirPath, "isSuccessByExtractDirPath.json");
-
-        type IsSuccessByExtractDirPath = Record<string, boolean | undefined>;
-
-        function readIsSuccessByExtractDirPath(): IsSuccessByExtractDirPath {
-            if (!fs.existsSync(filePath)) {
-                return {};
-            }
-
-            return JSON.parse(fs.readFileSync(filePath).toString("utf8"));
-        }
-
-        function writeIsSuccessByExtractDirPath(isSuccessByExtractDirPath: IsSuccessByExtractDirPath): void {
-            fs.writeFileSync(filePath, Buffer.from(JSON.stringify(isSuccessByExtractDirPath, null, 2), "utf8"));
-        }
-
-        return { readIsSuccessByExtractDirPath, writeIsSuccessByExtractDirPath };
-    })();
-
-    downloadAndUnzip: {
-        const isSuccessByExtractDirPath = readIsSuccessByExtractDirPath();
-
-        if (isSuccessByExtractDirPath[extractDirPath]) {
-            break downloadAndUnzip;
-        }
-
-        writeIsSuccessByExtractDirPath({
-            ...isSuccessByExtractDirPath,
-            [extractDirPath]: false
-        });
-
-        rm_rf(extractDirPath);
-
-        fs.mkdirSync(extractDirPath);
-
-        const zipFileBasename = pathBasename(url);
-
-        execSync(`curl -L ${url} -o ${zipFileBasename} ${params.isSilent ? "-s" : ""}`, { "cwd": extractDirPath });
-
-        execSync(`unzip -o ${zipFileBasename}${pathOfDirToExtractInArchive === undefined ? "" : ` "${pathOfDirToExtractInArchive}/**/*"`}`, {
-            "cwd": extractDirPath
-        });
-
-        rm(zipFileBasename, { "cwd": extractDirPath });
-
-        writeIsSuccessByExtractDirPath({
-            ...isSuccessByExtractDirPath,
-            [extractDirPath]: true
-        });
-    }
-
-    transformCodebase({
-        "srcDirPath": pathOfDirToExtractInArchive === undefined ? extractDirPath : pathJoin(extractDirPath, pathOfDirToExtractInArchive),
-        destDirPath
-    });
+    const srcDirPath = pathOfDirToExtractInArchive === undefined ? extractDirPath : pathJoin(extractDirPath, pathOfDirToExtractInArchive);
+    transformCodebase({ srcDirPath, destDirPath });
 }
--- a/src/bin/tools/grant-exec-perms.ts
+++ b/src/bin/tools/grant-exec-perms.ts
@ -1,10 +1,17 @@
 import { getProjectRoot } from "./getProjectRoot";
 import { join as pathJoin } from "path";
-import * as child_process from "child_process";
-import * as fs from "fs";
+import { constants } from "fs";
+import { chmod, stat } from "fs/promises";

-Object.entries<string>(JSON.parse(fs.readFileSync(pathJoin(getProjectRoot(), "package.json")).toString("utf8"))["bin"]).forEach(([, scriptPath]) =>
-    child_process.execSync(`chmod +x ${scriptPath}`, {
-        "cwd": getProjectRoot()
-    })
-);
+(async () => {
+    const { bin } = await import(pathJoin(getProjectRoot(), "package.json"));
+
+    const promises = Object.values<string>(bin).map(async scriptPath => {
+        const fullPath = pathJoin(getProjectRoot(), scriptPath);
+        const oldMode = (await stat(fullPath)).mode;
+        const newMode = oldMode | constants.S_IXUSR | constants.S_IXGRP | constants.S_IXOTH;
+        await chmod(fullPath, newMode);
+    });
+
+    await Promise.all(promises);
+})();
--- a/src/bin/tools/jar.ts
+++ b/src/bin/tools/jar.ts
@ -0,0 +1,102 @@
+import { Readable, Transform } from "stream";
+import { dirname, relative, sep } from "path";
+import { createWriteStream } from "fs";
+
+import walk from "./walk";
+import type { ZipSource } from "./zip";
+import zip from "./zip";
+import { mkdir } from "fs/promises";
+
+/** Trim leading whitespace from every line */
+const trimIndent = (s: string) => s.replace(/(\n)\s+/g, "$1");
+
+type JarArgs = {
+    rootPath: string;
+    targetPath: string;
+    groupId: string;
+    artifactId: string;
+    version: string;
+};
+
+/**
+ * Create a jar archive, using the resources found at `rootPath` (a directory) and write the
+ * archive to `targetPath` (a file). Use `groupId`, `artifactId` and `version` to define
+ * the contents of the pom.properties file which is going to be added to the archive.
+ */
+export default async function jar({ groupId, artifactId, version, rootPath, targetPath }: JarArgs) {
+    const manifest: ZipSource = {
+        path: "META-INF/MANIFEST.MF",
+        data: Buffer.from(
+            trimIndent(
+                `Manifest-Version: 1.0
+                 Archiver-Version: Plexus Archiver
+                 Created-By: Keycloakify
+                 Built-By: unknown
+                 Build-Jdk: 19.0.0`
+            )
+        )
+    };
+
+    const pomProps: ZipSource = {
+        path: `META-INF/maven/${groupId}/${artifactId}/pom.properties`,
+        data: Buffer.from(
+            trimIndent(
+                `# Generated by keycloakify
+                 # ${new Date()}
+                 artifactId=${artifactId}
+                 groupId=${groupId}
+                 version=${version}`
+            )
+        )
+    };
+
+    /**
+     * Convert every path entry to a ZipSource record, and when all records are
+     * processed, append records for MANIFEST.mf and pom.properties
+     */
+    const pathToRecord = () =>
+        new Transform({
+            objectMode: true,
+            transform: function (fsPath, _, cb) {
+                const path = relative(rootPath, fsPath).split(sep).join("/");
+                this.push({ path, fsPath });
+                cb();
+            },
+            final: function () {
+                this.push(manifest);
+                this.push(pomProps);
+                this.push(null);
+            }
+        });
+
+    await mkdir(dirname(targetPath), { recursive: true });
+
+    // Create an async pipeline, wait until everything is fully processed
+    await new Promise<void>((resolve, reject) => {
+        // walk all files in `rootPath` recursively
+        Readable.from(walk(rootPath))
+            // transform every path into a ZipSource object
+            .pipe(pathToRecord())
+            // let the zip lib convert all ZipSource objects into a byte stream
+            .pipe(zip())
+            // write that byte stream to targetPath
+            .pipe(createWriteStream(targetPath, { encoding: "binary" }))
+            .on("finish", () => resolve())
+            .on("error", e => reject(e));
+    });
+}
+
+/**
+ * Standalone usage, call e.g. `ts-node jar.ts dirWithSources some-jar.jar`
+ */
+if (require.main === module) {
+    const main = () =>
+        jar({
+            rootPath: process.argv[2],
+            targetPath: process.argv[3],
+            artifactId: process.env.ARTIFACT_ID ?? "artifact",
+            groupId: process.env.GROUP_ID ?? "group",
+            version: process.env.VERSION ?? "1.0.0"
+        });
+    main().catch(e => console.error(e));
+}
--- a/src/bin/tools/rm.ts
+++ b/src/bin/tools/rm.ts
@ -1,31 +0,0 @@
-import { execSync } from "child_process";
-
-function rmInternal(params: { pathToRemove: string; args: string | undefined; cwd: string | undefined }) {
-    const { pathToRemove, args, cwd } = params;
-
-    execSync(`rm ${args ? `-${args} ` : ""}${pathToRemove.replace(/ /g, "\\ ")}`, cwd !== undefined ? { cwd } : undefined);
-}
-
-export function rm(pathToRemove: string, options?: { cwd: string }) {
-    rmInternal({
-        pathToRemove,
-        "args": undefined,
-        "cwd": options?.cwd
-    });
-}
-
-export function rm_r(pathToRemove: string, options?: { cwd: string }) {
-    rmInternal({
-        pathToRemove,
-        "args": "r",
-        "cwd": options?.cwd
-    });
-}
-
-export function rm_rf(pathToRemove: string, options?: { cwd: string }) {
-    rmInternal({
-        pathToRemove,
-        "args": "rf",
-        "cwd": options?.cwd
-    });
-}
--- a/src/bin/tools/tee.ts
+++ b/src/bin/tools/tee.ts
@ -0,0 +1,37 @@
+import { PassThrough, Readable } from "stream";
+
+export default function tee(input: Readable) {
+    const a = new PassThrough();
+    const b = new PassThrough();
+
+    let aFull = false;
+    let bFull = false;
+
+    a.on("drain", () => {
+        aFull = false;
+        if (!aFull && !bFull) input.resume();
+    });
+    b.on("drain", () => {
+        bFull = false;
+        if (!aFull && !bFull) input.resume();
+    });
+
+    input.on("error", e => {
+        a.emit("error", e);
+        b.emit("error", e);
+    });
+
+    input.on("data", chunk => {
+        aFull = !a.write(chunk);
+        bFull = !b.write(chunk);
+
+        if (aFull || bFull) input.pause();
+    });
+
+    input.on("end", () => {
+        a.end();
+        b.end();
+    });
+
+    return [a, b] as const;
+}
--- a/src/bin/tools/walk.ts
+++ b/src/bin/tools/walk.ts
@ -0,0 +1,19 @@
+import { readdir } from "fs/promises";
+import { resolve } from "path";
+
+/**
+ * Asynchronously and recursively walk a directory tree, yielding every file and directory
+ * found
+ *
+ * @param root the starting directory
+ * @returns AsyncGenerator
+ */
+export default async function* walk(root: string): AsyncGenerator<string, void, void> {
+    for (const entry of await readdir(root, { withFileTypes: true })) {
+        const absolutePath = resolve(root, entry.name);
+        if (entry.isDirectory()) {
+            yield absolutePath;
+            yield* walk(absolutePath);
+        } else yield absolutePath;
+    }
+}
--- a/src/bin/tools/zip.ts
+++ b/src/bin/tools/zip.ts
@ -0,0 +1,245 @@
+import { Transform, TransformOptions } from "stream";
+import { createReadStream } from "fs";
+import { stat } from "fs/promises";
+
+import { deflateBuffer, deflateStream } from "./deflate";
+
+/**
+ * Zip source
+ * @property filename the name of the entry in the archie
+ * @property path of the source file, if the source is an actual file
+ * @property data the actual data buffer, if the source is constructed in-memory
+ */
+export type ZipSource = { path: string } & ({ fsPath: string } | { data: Buffer });
+
+export type ZipRecord = {
+    path: string;
+    compression: "deflate" | undefined;
+    uncompressedSize: number;
+    compressedSize?: number;
+    crc32?: number;
+    offset?: number;
+};
+
+/**
+ * @returns the actual byte size of an string
+ */
+function utf8size(s: string) {
+    return new Blob([s]).size;
+}
+
+/**
+ * @param record
+ * @returns a buffer representing a Zip local header
+ * @link https://en.wikipedia.org/wiki/ZIP_(file_format)#Local_file_header
+ */
+function localHeader(record: ZipRecord) {
+    const { path, compression, uncompressedSize } = record;
+    const filenameSize = utf8size(path);
+    const buf = Buffer.alloc(30 + filenameSize);
+
+    buf.writeUInt32LE(0x04_03_4b_50, 0); // local header signature
+    buf.writeUInt16LE(10, 4); // min version
+    // we write 0x08 because crc and compressed size are unknown at
+    buf.writeUInt16LE(0x08, 6); // general purpose bit flag
+    buf.writeUInt16LE(compression ? ({ "deflate": 8 } as const)[compression] : 0, 8);
+    buf.writeUInt16LE(0, 10); // modified time
+    buf.writeUInt16LE(0, 12); // modified date
+    buf.writeUInt32LE(0, 14); // crc unknown
+    buf.writeUInt32LE(0, 18); // compressed size unknown
+    buf.writeUInt32LE(uncompressedSize, 22);
+    buf.writeUInt16LE(filenameSize, 26);
+    buf.writeUInt16LE(0, 28); // extra field length
+    buf.write(path, 30, "utf-8");
+
+    return buf;
+}
+
+/**
+ * @param record
+ * @returns a buffer representing a Zip central header
+ * @link https://en.wikipedia.org/wiki/ZIP_(file_format)#Central_directory_file_header
+ */
+function centralHeader(record: ZipRecord) {
+    const { path, compression, crc32, compressedSize, uncompressedSize, offset } = record;
+    const filenameSize = utf8size(path);
+    const buf = Buffer.alloc(46 + filenameSize);
+    const isFile = !path.endsWith("/");
+
+    if (typeof offset === "undefined") throw new Error("Illegal argument");
+
+    // we don't want to deal with possibly messed up file or directory
+    // permissions, so we ignore the original permissions
+    const externalAttr = isFile ? 0x81a40000 : 0x41ed0000;
+
+    buf.writeUInt32LE(0x0201_4b50, 0); // central header signature
+    buf.writeUInt16LE(10, 4); // version
+    buf.writeUInt16LE(10, 6); // min version
+    buf.writeUInt16LE(0, 8); // general purpose bit flag
+    buf.writeUInt16LE(compression ? ({ "deflate": 8 } as const)[compression] : 0, 10);
+    buf.writeUInt16LE(0, 12); // modified time
+    buf.writeUInt16LE(0, 14); // modified date
+    buf.writeUInt32LE(crc32 || 0, 16);
+    buf.writeUInt32LE(compressedSize || 0, 20);
+    buf.writeUInt32LE(uncompressedSize, 24);
+    buf.writeUInt16LE(filenameSize, 28);
+    buf.writeUInt16LE(0, 30); // extra field length
+    buf.writeUInt16LE(0, 32); // comment field length
+    buf.writeUInt16LE(0, 34); // disk number
+    buf.writeUInt16LE(0, 36); // internal
+    buf.writeUInt32LE(externalAttr, 38); // external
+    buf.writeUInt32LE(offset, 42); // offset where file starts
+    buf.write(path, 46, "utf-8");
+
+    return buf;
+}
+
+/**
+ * @returns a buffer representing an Zip End-Of-Central-Directory block
+ * @link https://en.wikipedia.org/wiki/ZIP_(file_format)#End_of_central_directory_record_(EOCD)
+ */
+function eocd({ offset, cdSize, nRecords }: { offset: number; cdSize: number; nRecords: number }) {
+    const buf = Buffer.alloc(22);
+    buf.writeUint32LE(0x06054b50, 0); // eocd signature
+    buf.writeUInt16LE(0, 4); // disc number
+    buf.writeUint16LE(0, 6); // disc where central directory starts
+    buf.writeUint16LE(nRecords, 8); // records on this disc
+    buf.writeUInt16LE(nRecords, 10); // records total
+    buf.writeUInt32LE(cdSize, 12); // byte size of cd
+    buf.writeUInt32LE(offset, 16); // cd offset
+    buf.writeUint16LE(0, 20); // comment length
+
+    return buf;
+}
+
+/**
+ * @returns a stream Transform, which reads a stream of ZipRecords and
+ * writes a bytestream
+ */
+export default function zip() {
+    /**
+     * This is called when the input stream of ZipSource items is finished.
+     * Will write central directory and end-of-central-direcotry blocks.
+     */
+    const final = () => {
+        // write central directory
+        let cdSize = 0;
+        for (const record of records) {
+            const head = centralHeader(record);
+            zipTransform.push(head);
+            cdSize += head.length;
+        }
+
+        // write end-of-central-directory
+        zipTransform.push(eocd({ offset, cdSize, nRecords: records.length }));
+        // signal stream end
+        zipTransform.push(null);
+    };
+
+    /**
+     * Write a directory entry to the archive
+     * @param path
+     */
+    const writeDir = async (path: string) => {
+        const record: ZipRecord = {
+            path: path + "/",
+            offset,
+            compression: undefined,
+            uncompressedSize: 0
+        };
+        const head = localHeader(record);
+        zipTransform.push(head);
+        records.push(record);
+        offset += head.length;
+    };
+
+    /**
+     * Write a file entry to the archive
+     * @param archivePath path of the file in archive
+     * @param fsPath path to file on filesystem
+     * @param size of the actual, uncompressed, file
+     */
+    const writeFile = async (archivePath: string, fsPath: string, size: number) => {
+        const record: ZipRecord = {
+            path: archivePath,
+            offset,
+            compression: "deflate",
+            uncompressedSize: size
+        };
+        const head = localHeader(record);
+        zipTransform.push(head);
+
+        const { crc32, compressedSize } = await deflateStream(createReadStream(fsPath), chunk => zipTransform.push(chunk));
+
+        record.crc32 = crc32;
+        record.compressedSize = compressedSize;
+        records.push(record);
+        offset += head.length + compressedSize;
+    };
+
+    /**
+     * Write archive record based on filesystem file or directory
+     * @param archivePath path of item in archive
+     * @param fsPath path to item on filesystem
+     */
+    const writeFromPath = async (archivePath: string, fsPath: string) => {
+        const fileStats = await stat(fsPath);
+        fileStats.isDirectory() ? await writeDir(archivePath) /**/ : await writeFile(archivePath, fsPath, fileStats.size) /**/;
+    };
+
+    /**
+     * Write archive record based on data in a buffer
+     * @param path
+     * @param data
+     */
+    const writeFromBuffer = async (path: string, data: Buffer) => {
+        const { deflated, crc32 } = await deflateBuffer(data);
+        const record: ZipRecord = {
+            path,
+            compression: "deflate",
+            crc32,
+            uncompressedSize: data.length,
+            compressedSize: deflated.length,
+            offset
+        };
+        const head = localHeader(record);
+        zipTransform.push(head);
+        zipTransform.push(deflated);
+        records.push(record);
+        offset += head.length + deflated.length;
+    };
+
+    /**
+     * Write an archive record
+     * @param source
+     */
+    const writeRecord = async (source: ZipSource) => {
+        if ("fsPath" in source) await writeFromPath(source.path, source.fsPath);
+        else if ("data" in source) await writeFromBuffer(source.path, source.data);
+        else throw new Error("Illegal argument " + typeof source + "  " + JSON.stringify(source));
+    };
+
+    /**
+     * The actual stream transform function
+     * @param source
+     * @param _ encoding, ignored
+     * @param cb
+     */
+    const transform: TransformOptions["transform"] = async (source: ZipSource, _, cb) => {
+        await writeRecord(source);
+        cb();
+    };
+
+    /** offset and records keep local state during processing */
+    let offset = 0;
+    const records: ZipRecord[] = [];
+
+    const zipTransform = new Transform({
+        readableObjectMode: false,
+        writableObjectMode: true,
+        transform,
+        final
+    });
+
+    return zipTransform;
+}
--- a/src/lib/components/IdpReviewUserProfile.tsx
+++ b/src/lib/components/IdpReviewUserProfile.tsx
@ -3,7 +3,7 @@ import DefaultTemplate from "./Template";
 import type { TemplateProps } from "./Template";
 import type { KcProps } from "./KcProps";
 import type { KcContextBase } from "../getKcContext/KcContextBase";
-import { useCssAndCx } from "../tools/useCssAndCx";
+import { clsx } from "../tools/clsx";
 import type { I18n } from "../i18n";
 import { UserProfileFormFields } from "./shared/UserProfileCommons";

@ -17,8 +17,6 @@ export type IdpReviewUserProfileProps = KcProps & {
 const IdpReviewUserProfile = memo((props: IdpReviewUserProfileProps) => {
    const { kcContext, i18n, doFetchDefaultThemeResources = true, Template = DefaultTemplate, ...kcProps } = props;

-    const { cx } = useCssAndCx();
-
    const { msg, msgStr } = i18n;

    const { url } = kcContext;
@ -30,16 +28,16 @@ const IdpReviewUserProfile = memo((props: IdpReviewUserProfileProps) => {
            {...{ kcContext, i18n, doFetchDefaultThemeResources, ...kcProps }}
            headerNode={msg("loginIdpReviewProfileTitle")}
            formNode={
-                <form id="kc-idp-review-profile-form" className={cx(kcProps.kcFormClass)} action={url.loginAction} method="post">
+                <form id="kc-idp-review-profile-form" className={clsx(kcProps.kcFormClass)} action={url.loginAction} method="post">
                    <UserProfileFormFields kcContext={kcContext} onIsFormSubmittableValueChange={setIsFomSubmittable} i18n={i18n} {...kcProps} />

-                    <div className={cx(kcProps.kcFormGroupClass)}>
-                        <div id="kc-form-options" className={cx(kcProps.kcFormOptionsClass)}>
-                            <div className={cx(kcProps.kcFormOptionsWrapperClass)} />
+                    <div className={clsx(kcProps.kcFormGroupClass)}>
+                        <div id="kc-form-options" className={clsx(kcProps.kcFormOptionsClass)}>
+                            <div className={clsx(kcProps.kcFormOptionsWrapperClass)} />
                        </div>
-                        <div id="kc-form-buttons" className={cx(kcProps.kcFormButtonsClass)}>
+                        <div id="kc-form-buttons" className={clsx(kcProps.kcFormButtonsClass)}>
                            <input
-                                className={cx(
+                                className={clsx(
                                    kcProps.kcButtonClass,
                                    kcProps.kcButtonPrimaryClass,
                                    kcProps.kcButtonBlockClass,
--- a/src/lib/components/KcApp.tsx
+++ b/src/lib/components/KcApp.tsx
@ -32,7 +32,7 @@ export type KcAppProps = KcProps & {
    kcContext: KcContextBase;
    i18n?: I18n;
    doFetchDefaultThemeResources?: boolean;
-    Template: (props: TemplateProps) => JSX.Element | null;
+    Template?: (props: TemplateProps) => JSX.Element | null;
 };

 const KcApp = memo((props_: KcAppProps) => {
--- a/src/lib/components/Login.tsx
+++ b/src/lib/components/Login.tsx
@ -3,7 +3,7 @@ import DefaultTemplate from "./Template";
 import type { TemplateProps } from "./Template";
 import type { KcProps } from "./KcProps";
 import type { KcContextBase } from "../getKcContext/KcContextBase";
-import { useCssAndCx } from "../tools/useCssAndCx";
+import { clsx } from "../tools/clsx";
 import { useConstCallback } from "powerhooks/useConstCallback";
 import type { FormEventHandler } from "react";
 import type { I18n } from "../i18n";
@ -22,8 +22,6 @@ const Login = memo((props: LoginProps) => {

    const { msg, msgStr } = i18n;

-    const { cx } = useCssAndCx();
-
    const [isLoginButtonDisabled, setIsLoginButtonDisabled] = useState(false);

    const onSubmit = useConstCallback<FormEventHandler<HTMLFormElement>>(e => {
@ -47,16 +45,16 @@ const Login = memo((props: LoginProps) => {
            displayWide={realm.password && social.providers !== undefined}
            headerNode={msg("doLogIn")}
            formNode={
-                <div id="kc-form" className={cx(realm.password && social.providers !== undefined && kcProps.kcContentWrapperClass)}>
+                <div id="kc-form" className={clsx(realm.password && social.providers !== undefined && kcProps.kcContentWrapperClass)}>
                    <div
                        id="kc-form-wrapper"
-                        className={cx(
+                        className={clsx(
                            realm.password && social.providers && [kcProps.kcFormSocialAccountContentClass, kcProps.kcFormSocialAccountClass]
                        )}
                    >
                        {realm.password && (
                            <form id="kc-form-login" onSubmit={onSubmit} action={url.loginAction} method="post">
-                                <div className={cx(kcProps.kcFormGroupClass)}>
+                                <div className={clsx(kcProps.kcFormGroupClass)}>
                                    {(() => {
                                        const label = !realm.loginWithEmailAllowed
                                            ? "username"
@ -68,13 +66,13 @@ const Login = memo((props: LoginProps) => {

                                        return (
                                            <>
-                                                <label htmlFor={autoCompleteHelper} className={cx(kcProps.kcLabelClass)}>
+                                                <label htmlFor={autoCompleteHelper} className={clsx(kcProps.kcLabelClass)}>
                                                    {msg(label)}
                                                </label>
                                                <input
                                                    tabIndex={1}
                                                    id={autoCompleteHelper}
-                                                    className={cx(kcProps.kcInputClass)}
+                                                    className={clsx(kcProps.kcInputClass)}
                                                    //NOTE: This is used by Google Chrome auto fill so we use it to tell
                                                    //the browser how to pre fill the form but before submit we put it back
                                                    //to username because it is what keycloak expects.
@ -92,20 +90,20 @@ const Login = memo((props: LoginProps) => {
                                        );
                                    })()}
                                </div>
-                                <div className={cx(kcProps.kcFormGroupClass)}>
-                                    <label htmlFor="password" className={cx(kcProps.kcLabelClass)}>
+                                <div className={clsx(kcProps.kcFormGroupClass)}>
+                                    <label htmlFor="password" className={clsx(kcProps.kcLabelClass)}>
                                        {msg("password")}
                                    </label>
                                    <input
                                        tabIndex={2}
                                        id="password"
-                                        className={cx(kcProps.kcInputClass)}
+                                        className={clsx(kcProps.kcInputClass)}
                                        name="password"
                                        type="password"
                                        autoComplete="off"
                                    />
                                </div>
-                                <div className={cx(kcProps.kcFormGroupClass, kcProps.kcFormSettingClass)}>
+                                <div className={clsx(kcProps.kcFormGroupClass, kcProps.kcFormSettingClass)}>
                                    <div id="kc-form-options">
                                        {realm.rememberMe && !usernameEditDisabled && (
                                            <div className="checkbox">
@ -126,7 +124,7 @@ const Login = memo((props: LoginProps) => {
                                            </div>
                                        )}
                                    </div>
-                                    <div className={cx(kcProps.kcFormOptionsWrapperClass)}>
+                                    <div className={clsx(kcProps.kcFormOptionsWrapperClass)}>
                                        {realm.resetPasswordAllowed && (
                                            <span>
                                                <a tabIndex={5} href={url.loginResetCredentialsUrl}>
@ -136,7 +134,7 @@ const Login = memo((props: LoginProps) => {
                                        )}
                                    </div>
                                </div>
-                                <div id="kc-form-buttons" className={cx(kcProps.kcFormGroupClass)}>
+                                <div id="kc-form-buttons" className={clsx(kcProps.kcFormGroupClass)}>
                                    <input
                                        type="hidden"
                                        id="id-hidden-input"
@ -149,7 +147,7 @@ const Login = memo((props: LoginProps) => {
                                    />
                                    <input
                                        tabIndex={4}
-                                        className={cx(
+                                        className={clsx(
                                            kcProps.kcButtonClass,
                                            kcProps.kcButtonPrimaryClass,
                                            kcProps.kcButtonBlockClass,
@ -166,16 +164,16 @@ const Login = memo((props: LoginProps) => {
                        )}
                    </div>
                    {realm.password && social.providers !== undefined && (
-                        <div id="kc-social-providers" className={cx(kcProps.kcFormSocialAccountContentClass, kcProps.kcFormSocialAccountClass)}>
+                        <div id="kc-social-providers" className={clsx(kcProps.kcFormSocialAccountContentClass, kcProps.kcFormSocialAccountClass)}>
                            <ul
-                                className={cx(
+                                className={clsx(
                                    kcProps.kcFormSocialAccountListClass,
                                    social.providers.length > 4 && kcProps.kcFormSocialAccountDoubleListClass
                                )}
                            >
                                {social.providers.map(p => (
-                                    <li key={p.providerId} className={cx(kcProps.kcFormSocialAccountListLinkClass)}>
-                                        <a href={p.loginUrl} id={`zocial-${p.alias}`} className={cx("zocial", p.providerId)}>
+                                    <li key={p.providerId} className={clsx(kcProps.kcFormSocialAccountListLinkClass)}>
+                                        <a href={p.loginUrl} id={`zocial-${p.alias}`} className={clsx("zocial", p.providerId)}>
                                            <span>{p.displayName}</span>
                                        </a>
                                    </li>
--- a/src/lib/components/LoginConfigTotp.tsx
+++ b/src/lib/components/LoginConfigTotp.tsx
@ -3,7 +3,7 @@ import DefaultTemplate from "./Template";
 import type { TemplateProps } from "./Template";
 import type { KcProps } from "./KcProps";
 import type { KcContextBase } from "../getKcContext/KcContextBase";
-import { useCssAndCx } from "../tools/useCssAndCx";
+import { clsx } from "../tools/clsx";
 import type { I18n } from "../i18n";

 export type LoginConfigTotpProps = KcProps & {
@ -18,8 +18,6 @@ const LoginConfigTotp = memo((props: LoginConfigTotpProps) => {

    const { url, isAppInitiatedAction, totp, mode, messagesPerField } = kcContext;

-    const { cx } = useCssAndCx();
-
    const { msg, msgStr } = i18n;

    const algToKeyUriAlg: Record<KcContextBase.LoginConfigTotp["totp"]["policy"]["algorithm"], string> = {
@ -102,26 +100,26 @@ const LoginConfigTotp = memo((props: LoginConfigTotpProps) => {
                        </li>
                    </ol>

-                    <form action={url.loginAction} className={cx(kcProps.kcFormClass)} id="kc-totp-settings-form" method="post">
-                        <div className={cx(kcProps.kcFormGroupClass)}>
-                            <div className={cx(kcProps.kcInputWrapperClass)}>
-                                <label htmlFor="totp" className={cx(kcProps.kcLabelClass)}>
+                    <form action={url.loginAction} className={clsx(kcProps.kcFormClass)} id="kc-totp-settings-form" method="post">
+                        <div className={clsx(kcProps.kcFormGroupClass)}>
+                            <div className={clsx(kcProps.kcInputWrapperClass)}>
+                                <label htmlFor="totp" className={clsx(kcProps.kcLabelClass)}>
                                    {msg("authenticatorCode")}
                                </label>{" "}
                                <span className="required">*</span>
                            </div>
-                            <div className={cx(kcProps.kcInputWrapperClass)}>
+                            <div className={clsx(kcProps.kcInputWrapperClass)}>
                                <input
                                    type="text"
                                    id="totp"
                                    name="totp"
                                    autoComplete="off"
-                                    className={cx(kcProps.kcInputClass)}
+                                    className={clsx(kcProps.kcInputClass)}
                                    aria-invalid={messagesPerField.existsError("totp")}
                                />

                                {messagesPerField.existsError("totp") && (
-                                    <span id="input-error-otp-code" className={cx(kcProps.kcInputErrorMessageClass)} aria-live="polite">
+                                    <span id="input-error-otp-code" className={clsx(kcProps.kcInputErrorMessageClass)} aria-live="polite">
                                        {messagesPerField.get("totp")}
                                    </span>
                                )}
@ -130,24 +128,24 @@ const LoginConfigTotp = memo((props: LoginConfigTotpProps) => {
                            {mode && <input type="hidden" id="mode" value={mode} />}
                        </div>

-                        <div className={cx(kcProps.kcFormGroupClass)}>
-                            <div className={cx(kcProps.kcInputWrapperClass)}>
-                                <label htmlFor="userLabel" className={cx(kcProps.kcLabelClass)}>
+                        <div className={clsx(kcProps.kcFormGroupClass)}>
+                            <div className={clsx(kcProps.kcInputWrapperClass)}>
+                                <label htmlFor="userLabel" className={clsx(kcProps.kcLabelClass)}>
                                    {msg("loginTotpDeviceName")}
                                </label>{" "}
                                {totp.otpCredentials.length >= 1 && <span className="required">*</span>}
                            </div>
-                            <div className={cx(kcProps.kcInputWrapperClass)}>
+                            <div className={clsx(kcProps.kcInputWrapperClass)}>
                                <input
                                    type="text"
                                    id="userLabel"
                                    name="userLabel"
                                    autoComplete="off"
-                                    className={cx(kcProps.kcInputClass)}
+                                    className={clsx(kcProps.kcInputClass)}
                                    aria-invalid={messagesPerField.existsError("userLabel")}
                                />
                                {messagesPerField.existsError("userLabel") && (
-                                    <span id="input-error-otp-label" className={cx(kcProps.kcInputErrorMessageClass)} aria-live="polite">
+                                    <span id="input-error-otp-label" className={clsx(kcProps.kcInputErrorMessageClass)} aria-live="polite">
                                        {messagesPerField.get("userLabel")}
                                    </span>
                                )}
@ -158,13 +156,13 @@ const LoginConfigTotp = memo((props: LoginConfigTotpProps) => {
                            <>
                                <input
                                    type="submit"
-                                    className={cx(kcProps.kcButtonClass, kcProps.kcButtonPrimaryClass, kcProps.kcButtonLargeClass)}
+                                    className={clsx(kcProps.kcButtonClass, kcProps.kcButtonPrimaryClass, kcProps.kcButtonLargeClass)}
                                    id="saveTOTPBtn"
                                    value={msgStr("doSubmit")}
                                />
                                <button
                                    type="submit"
-                                    className={cx(
+                                    className={clsx(
                                        kcProps.kcButtonClass,
                                        kcProps.kcButtonDefaultClass,
                                        kcProps.kcButtonLargeClass,
@ -180,7 +178,7 @@ const LoginConfigTotp = memo((props: LoginConfigTotpProps) => {
                        ) : (
                            <input
                                type="submit"
-                                className={cx(kcProps.kcButtonClass, kcProps.kcButtonPrimaryClass, kcProps.kcButtonLargeClass)}
+                                className={clsx(kcProps.kcButtonClass, kcProps.kcButtonPrimaryClass, kcProps.kcButtonLargeClass)}
                                id="saveTOTPBtn"
                                value={msgStr("doSubmit")}
                            />
--- a/src/lib/components/LoginIdpLinkConfirm.tsx
+++ b/src/lib/components/LoginIdpLinkConfirm.tsx
@ -3,7 +3,7 @@ import DefaultTemplate from "./Template";
 import type { TemplateProps } from "./Template";
 import type { KcProps } from "./KcProps";
 import type { KcContextBase } from "../getKcContext/KcContextBase";
-import { useCssAndCx } from "../tools/useCssAndCx";
+import { clsx } from "../tools/clsx";
 import type { I18n } from "../i18n";

 export type LoginIdpLinkConfirmProps = KcProps & {
@ -20,18 +20,16 @@ const LoginIdpLinkConfirm = memo((props: LoginIdpLinkConfirmProps) => {

    const { msg } = i18n;

-    const { cx } = useCssAndCx();
-
    return (
        <Template
            {...{ kcContext, i18n, doFetchDefaultThemeResources, ...kcProps }}
            headerNode={msg("confirmLinkIdpTitle")}
            formNode={
                <form id="kc-register-form" action={url.loginAction} method="post">
-                    <div className={cx(kcProps.kcFormGroupClass)}>
+                    <div className={clsx(kcProps.kcFormGroupClass)}>
                        <button
                            type="submit"
-                            className={cx(
+                            className={clsx(
                                kcProps.kcButtonClass,
                                kcProps.kcButtonDefaultClass,
                                kcProps.kcButtonBlockClass,
@ -45,7 +43,7 @@ const LoginIdpLinkConfirm = memo((props: LoginIdpLinkConfirmProps) => {
                        </button>
                        <button
                            type="submit"
-                            className={cx(
+                            className={clsx(
                                kcProps.kcButtonClass,
                                kcProps.kcButtonDefaultClass,
                                kcProps.kcButtonBlockClass,
--- a/src/lib/components/LoginOtp.tsx
+++ b/src/lib/components/LoginOtp.tsx
@ -5,7 +5,7 @@ import type { KcProps } from "./KcProps";
 import type { KcContextBase } from "../getKcContext/KcContextBase";
 import { headInsert } from "../tools/headInsert";
 import { pathJoin } from "../../bin/tools/pathJoin";
-import { useCssAndCx } from "../tools/useCssAndCx";
+import { clsx } from "../tools/clsx";
 import type { I18n } from "../i18n";

 export type LoginOtpProps = KcProps & {
@ -20,8 +20,6 @@ const LoginOtp = memo((props: LoginOtpProps) => {

    const { otpLogin, url } = kcContext;

-    const { cx } = useCssAndCx();
-
    const { msg, msgStr } = i18n;

    useEffect(() => {
@ -46,42 +44,42 @@ const LoginOtp = memo((props: LoginOtpProps) => {
            {...{ kcContext, i18n, doFetchDefaultThemeResources, ...kcProps }}
            headerNode={msg("doLogIn")}
            formNode={
-                <form id="kc-otp-login-form" className={cx(kcProps.kcFormClass)} action={url.loginAction} method="post">
+                <form id="kc-otp-login-form" className={clsx(kcProps.kcFormClass)} action={url.loginAction} method="post">
                    {otpLogin.userOtpCredentials.length > 1 && (
-                        <div className={cx(kcProps.kcFormGroupClass)}>
-                            <div className={cx(kcProps.kcInputWrapperClass)}>
+                        <div className={clsx(kcProps.kcFormGroupClass)}>
+                            <div className={clsx(kcProps.kcInputWrapperClass)}>
                                {otpLogin.userOtpCredentials.map(otpCredential => (
-                                    <div key={otpCredential.id} className={cx(kcProps.kcSelectOTPListClass)}>
+                                    <div key={otpCredential.id} className={clsx(kcProps.kcSelectOTPListClass)}>
                                        <input type="hidden" value="${otpCredential.id}" />
-                                        <div className={cx(kcProps.kcSelectOTPListItemClass)}>
-                                            <span className={cx(kcProps.kcAuthenticatorOtpCircleClass)} />
-                                            <h2 className={cx(kcProps.kcSelectOTPItemHeadingClass)}>{otpCredential.userLabel}</h2>
+                                        <div className={clsx(kcProps.kcSelectOTPListItemClass)}>
+                                            <span className={clsx(kcProps.kcAuthenticatorOtpCircleClass)} />
+                                            <h2 className={clsx(kcProps.kcSelectOTPItemHeadingClass)}>{otpCredential.userLabel}</h2>
                                        </div>
                                    </div>
                                ))}
                            </div>
                        </div>
                    )}
-                    <div className={cx(kcProps.kcFormGroupClass)}>
-                        <div className={cx(kcProps.kcLabelWrapperClass)}>
-                            <label htmlFor="otp" className={cx(kcProps.kcLabelClass)}>
+                    <div className={clsx(kcProps.kcFormGroupClass)}>
+                        <div className={clsx(kcProps.kcLabelWrapperClass)}>
+                            <label htmlFor="otp" className={clsx(kcProps.kcLabelClass)}>
                                {msg("loginOtpOneTime")}
                            </label>
                        </div>

-                        <div className={cx(kcProps.kcInputWrapperClass)}>
-                            <input id="otp" name="otp" autoComplete="off" type="text" className={cx(kcProps.kcInputClass)} autoFocus />
+                        <div className={clsx(kcProps.kcInputWrapperClass)}>
+                            <input id="otp" name="otp" autoComplete="off" type="text" className={clsx(kcProps.kcInputClass)} autoFocus />
                        </div>
                    </div>

-                    <div className={cx(kcProps.kcFormGroupClass)}>
-                        <div id="kc-form-options" className={cx(kcProps.kcFormOptionsClass)}>
-                            <div className={cx(kcProps.kcFormOptionsWrapperClass)} />
+                    <div className={clsx(kcProps.kcFormGroupClass)}>
+                        <div id="kc-form-options" className={clsx(kcProps.kcFormOptionsClass)}>
+                            <div className={clsx(kcProps.kcFormOptionsWrapperClass)} />
                        </div>

-                        <div id="kc-form-buttons" className={cx(kcProps.kcFormButtonsClass)}>
+                        <div id="kc-form-buttons" className={clsx(kcProps.kcFormButtonsClass)}>
                            <input
-                                className={cx(
+                                className={clsx(
                                    kcProps.kcButtonClass,
                                    kcProps.kcButtonPrimaryClass,
                                    kcProps.kcButtonBlockClass,
--- a/src/lib/components/LoginPassword.tsx
+++ b/src/lib/components/LoginPassword.tsx
@ -3,7 +3,7 @@ import DefaultTemplate from "./Template";
 import type { TemplateProps } from "./Template";
 import type { KcProps } from "./KcProps";
 import type { KcContextBase } from "../getKcContext/KcContextBase";
-import { useCssAndCx } from "../tools/useCssAndCx";
+import { clsx } from "../tools/clsx";
 import { useConstCallback } from "powerhooks/useConstCallback";
 import type { FormEventHandler } from "react";
 import type { I18n } from "../i18n";
@ -22,8 +22,6 @@ const LoginPassword = memo((props: LoginPasswordProps) => {

    const { msg, msgStr } = i18n;

-    const { cx } = useCssAndCx();
-
    const [isLoginButtonDisabled, setIsLoginButtonDisabled] = useState(false);

    const onSubmit = useConstCallback<FormEventHandler<HTMLFormElement>>(e => {
@ -44,15 +42,15 @@ const LoginPassword = memo((props: LoginPasswordProps) => {
                <div id="kc-form">
                    <div id="kc-form-wrapper">
                        <form id="kc-form-login" onSubmit={onSubmit} action={url.loginAction} method="post">
-                            <div className={cx(kcProps.kcFormGroupClass)}>
+                            <div className={clsx(kcProps.kcFormGroupClass)}>
                                <hr />
-                                <label htmlFor="password" className={cx(kcProps.kcLabelClass)}>
+                                <label htmlFor="password" className={clsx(kcProps.kcLabelClass)}>
                                    {msg("password")}
                                </label>
                                <input
                                    tabIndex={2}
                                    id="password"
-                                    className={cx(kcProps.kcInputClass)}
+                                    className={clsx(kcProps.kcInputClass)}
                                    name="password"
                                    type="password"
                                    autoFocus={true}
@ -60,9 +58,9 @@ const LoginPassword = memo((props: LoginPasswordProps) => {
                                    defaultValue={login.password ?? ""}
                                />
                            </div>
-                            <div className={cx(kcProps.kcFormGroupClass, kcProps.kcFormSettingClass)}>
+                            <div className={clsx(kcProps.kcFormGroupClass, kcProps.kcFormSettingClass)}>
                                <div id="kc-form-options" />
-                                <div className={cx(kcProps.kcFormOptionsWrapperClass)}>
+                                <div className={clsx(kcProps.kcFormOptionsWrapperClass)}>
                                    {realm.resetPasswordAllowed && (
                                        <span>
                                            <a tabIndex={5} href={url.loginResetCredentialsUrl}>
@ -72,10 +70,10 @@ const LoginPassword = memo((props: LoginPasswordProps) => {
                                    )}
                                </div>
                            </div>
-                            <div id="kc-form-buttons" className={cx(kcProps.kcFormGroupClass)}>
+                            <div id="kc-form-buttons" className={clsx(kcProps.kcFormGroupClass)}>
                                <input
                                    tabIndex={4}
-                                    className={cx(
+                                    className={clsx(
                                        kcProps.kcButtonClass,
                                        kcProps.kcButtonPrimaryClass,
                                        kcProps.kcButtonBlockClass,
--- a/src/lib/components/LoginResetPassword.tsx
+++ b/src/lib/components/LoginResetPassword.tsx
@ -3,7 +3,7 @@ import DefaultTemplate from "./Template";
 import type { TemplateProps } from "./Template";
 import type { KcProps } from "./KcProps";
 import type { KcContextBase } from "../getKcContext/KcContextBase";
-import { useCssAndCx } from "../tools/useCssAndCx";
+import { clsx } from "../tools/clsx";
 import type { I18n } from "../i18n";

 export type LoginResetPasswordProps = KcProps & {
@ -20,18 +20,16 @@ const LoginResetPassword = memo((props: LoginResetPasswordProps) => {

    const { msg, msgStr } = i18n;

-    const { cx } = useCssAndCx();
-
    return (
        <Template
            {...{ kcContext, i18n, doFetchDefaultThemeResources, ...kcProps }}
            displayMessage={false}
            headerNode={msg("emailForgotTitle")}
            formNode={
-                <form id="kc-reset-password-form" className={cx(kcProps.kcFormClass)} action={url.loginAction} method="post">
-                    <div className={cx(kcProps.kcFormGroupClass)}>
-                        <div className={cx(kcProps.kcLabelWrapperClass)}>
-                            <label htmlFor="username" className={cx(kcProps.kcLabelClass)}>
+                <form id="kc-reset-password-form" className={clsx(kcProps.kcFormClass)} action={url.loginAction} method="post">
+                    <div className={clsx(kcProps.kcFormGroupClass)}>
+                        <div className={clsx(kcProps.kcLabelWrapperClass)}>
+                            <label htmlFor="username" className={clsx(kcProps.kcLabelClass)}>
                                {!realm.loginWithEmailAllowed
                                    ? msg("username")
                                    : !realm.registrationEmailAsUsername
@ -39,29 +37,29 @@ const LoginResetPassword = memo((props: LoginResetPasswordProps) => {
                                    : msg("email")}
                            </label>
                        </div>
-                        <div className={cx(kcProps.kcInputWrapperClass)}>
+                        <div className={clsx(kcProps.kcInputWrapperClass)}>
                            <input
                                type="text"
                                id="username"
                                name="username"
-                                className={cx(kcProps.kcInputClass)}
+                                className={clsx(kcProps.kcInputClass)}
                                autoFocus
                                defaultValue={auth !== undefined && auth.showUsername ? auth.attemptedUsername : undefined}
                            />
                        </div>
                    </div>
-                    <div className={cx(kcProps.kcFormGroupClass, kcProps.kcFormSettingClass)}>
-                        <div id="kc-form-options" className={cx(kcProps.kcFormOptionsClass)}>
-                            <div className={cx(kcProps.kcFormOptionsWrapperClass)}>
+                    <div className={clsx(kcProps.kcFormGroupClass, kcProps.kcFormSettingClass)}>
+                        <div id="kc-form-options" className={clsx(kcProps.kcFormOptionsClass)}>
+                            <div className={clsx(kcProps.kcFormOptionsWrapperClass)}>
                                <span>
                                    <a href={url.loginUrl}>{msg("backToLogin")}</a>
                                </span>
                            </div>
                        </div>

-                        <div id="kc-form-buttons" className={cx(kcProps.kcFormButtonsClass)}>
+                        <div id="kc-form-buttons" className={clsx(kcProps.kcFormButtonsClass)}>
                            <input
-                                className={cx(
+                                className={clsx(
                                    kcProps.kcButtonClass,
                                    kcProps.kcButtonPrimaryClass,
                                    kcProps.kcButtonBlockClass,
--- a/src/lib/components/LoginUpdatePassword.tsx
+++ b/src/lib/components/LoginUpdatePassword.tsx
@ -3,7 +3,7 @@ import DefaultTemplate from "./Template";
 import type { TemplateProps } from "./Template";
 import type { KcProps } from "./KcProps";
 import type { KcContextBase } from "../getKcContext/KcContextBase";
-import { useCssAndCx } from "../tools/useCssAndCx";
+import { clsx } from "../tools/clsx";
 import type { I18n } from "../i18n";

 export type LoginUpdatePasswordProps = KcProps & {
@ -16,8 +16,6 @@ export type LoginUpdatePasswordProps = KcProps & {
 const LoginUpdatePassword = memo((props: LoginUpdatePasswordProps) => {
    const { kcContext, i18n, doFetchDefaultThemeResources = true, Template = DefaultTemplate, ...kcProps } = props;

-    const { cx } = useCssAndCx();
-
    const { msg, msgStr } = i18n;

    const { url, messagesPerField, isAppInitiatedAction, username } = kcContext;
@ -27,7 +25,7 @@ const LoginUpdatePassword = memo((props: LoginUpdatePasswordProps) => {
            {...{ kcContext, i18n, doFetchDefaultThemeResources, ...kcProps }}
            headerNode={msg("updatePasswordTitle")}
            formNode={
-                <form id="kc-passwd-update-form" className={cx(kcProps.kcFormClass)} action={url.loginAction} method="post">
+                <form id="kc-passwd-update-form" className={clsx(kcProps.kcFormClass)} action={url.loginAction} method="post">
                    <input
                        type="text"
                        id="username"
@ -39,44 +37,46 @@ const LoginUpdatePassword = memo((props: LoginUpdatePasswordProps) => {
                    />
                    <input type="password" id="password" name="password" autoComplete="current-password" style={{ display: "none" }} />

-                    <div className={cx(kcProps.kcFormGroupClass, messagesPerField.printIfExists("password", kcProps.kcFormGroupErrorClass))}>
-                        <div className={cx(kcProps.kcLabelWrapperClass)}>
-                            <label htmlFor="password-new" className={cx(kcProps.kcLabelClass)}>
+                    <div className={clsx(kcProps.kcFormGroupClass, messagesPerField.printIfExists("password", kcProps.kcFormGroupErrorClass))}>
+                        <div className={clsx(kcProps.kcLabelWrapperClass)}>
+                            <label htmlFor="password-new" className={clsx(kcProps.kcLabelClass)}>
                                {msg("passwordNew")}
                            </label>
                        </div>
-                        <div className={cx(kcProps.kcInputWrapperClass)}>
+                        <div className={clsx(kcProps.kcInputWrapperClass)}>
                            <input
                                type="password"
                                id="password-new"
                                name="password-new"
                                autoFocus
                                autoComplete="new-password"
-                                className={cx(kcProps.kcInputClass)}
+                                className={clsx(kcProps.kcInputClass)}
                            />
                        </div>
                    </div>

-                    <div className={cx(kcProps.kcFormGroupClass, messagesPerField.printIfExists("password-confirm", kcProps.kcFormGroupErrorClass))}>
-                        <div className={cx(kcProps.kcLabelWrapperClass)}>
-                            <label htmlFor="password-confirm" className={cx(kcProps.kcLabelClass)}>
+                    <div
+                        className={clsx(kcProps.kcFormGroupClass, messagesPerField.printIfExists("password-confirm", kcProps.kcFormGroupErrorClass))}
+                    >
+                        <div className={clsx(kcProps.kcLabelWrapperClass)}>
+                            <label htmlFor="password-confirm" className={clsx(kcProps.kcLabelClass)}>
                                {msg("passwordConfirm")}
                            </label>
                        </div>
-                        <div className={cx(kcProps.kcInputWrapperClass)}>
+                        <div className={clsx(kcProps.kcInputWrapperClass)}>
                            <input
                                type="password"
                                id="password-confirm"
                                name="password-confirm"
                                autoComplete="new-password"
-                                className={cx(kcProps.kcInputClass)}
+                                className={clsx(kcProps.kcInputClass)}
                            />
                        </div>
                    </div>

-                    <div className={cx(kcProps.kcFormGroupClass)}>
-                        <div id="kc-form-options" className={cx(kcProps.kcFormOptionsClass)}>
-                            <div className={cx(kcProps.kcFormOptionsWrapperClass)}>
+                    <div className={clsx(kcProps.kcFormGroupClass)}>
+                        <div id="kc-form-options" className={clsx(kcProps.kcFormOptionsClass)}>
+                            <div className={clsx(kcProps.kcFormOptionsWrapperClass)}>
                                {isAppInitiatedAction && (
                                    <div className="checkbox">
                                        <label>
@ -88,16 +88,16 @@ const LoginUpdatePassword = memo((props: LoginUpdatePasswordProps) => {
                            </div>
                        </div>

-                        <div id="kc-form-buttons" className={cx(kcProps.kcFormButtonsClass)}>
+                        <div id="kc-form-buttons" className={clsx(kcProps.kcFormButtonsClass)}>
                            {isAppInitiatedAction ? (
                                <>
                                    <input
-                                        className={cx(kcProps.kcButtonClass, kcProps.kcButtonPrimaryClass, kcProps.kcButtonLargeClass)}
+                                        className={clsx(kcProps.kcButtonClass, kcProps.kcButtonPrimaryClass, kcProps.kcButtonLargeClass)}
                                        type="submit"
                                        defaultValue={msgStr("doSubmit")}
                                    />
                                    <button
-                                        className={cx(kcProps.kcButtonClass, kcProps.kcButtonDefaultClass, kcProps.kcButtonLargeClass)}
+                                        className={clsx(kcProps.kcButtonClass, kcProps.kcButtonDefaultClass, kcProps.kcButtonLargeClass)}
                                        type="submit"
                                        name="cancel-aia"
                                        value="true"
@ -107,7 +107,7 @@ const LoginUpdatePassword = memo((props: LoginUpdatePasswordProps) => {
                                </>
                            ) : (
                                <input
-                                    className={cx(
+                                    className={clsx(
                                        kcProps.kcButtonClass,
                                        kcProps.kcButtonPrimaryClass,
                                        kcProps.kcButtonBlockClass,
--- a/src/lib/components/LoginUpdateProfile.tsx
+++ b/src/lib/components/LoginUpdateProfile.tsx
@ -3,7 +3,7 @@ import DefaultTemplate from "./Template";
 import type { TemplateProps } from "./Template";
 import type { KcProps } from "./KcProps";
 import type { KcContextBase } from "../getKcContext/KcContextBase";
-import { useCssAndCx } from "../tools/useCssAndCx";
+import { clsx } from "../tools/clsx";
 import type { I18n } from "../i18n";

 export type LoginUpdateProfile = KcProps & {
@ -16,8 +16,6 @@ export type LoginUpdateProfile = KcProps & {
 const LoginUpdateProfile = memo((props: LoginUpdateProfile) => {
    const { kcContext, i18n, doFetchDefaultThemeResources = true, Template = DefaultTemplate, ...kcProps } = props;

-    const { cx } = useCssAndCx();
-
    const { msg, msgStr } = i18n;

    const { url, user, messagesPerField, isAppInitiatedAction } = kcContext;
@ -27,86 +25,86 @@ const LoginUpdateProfile = memo((props: LoginUpdateProfile) => {
            {...{ kcContext, i18n, doFetchDefaultThemeResources, ...kcProps }}
            headerNode={msg("loginProfileTitle")}
            formNode={
-                <form id="kc-update-profile-form" className={cx(kcProps.kcFormClass)} action={url.loginAction} method="post">
+                <form id="kc-update-profile-form" className={clsx(kcProps.kcFormClass)} action={url.loginAction} method="post">
                    {user.editUsernameAllowed && (
-                        <div className={cx(kcProps.kcFormGroupClass, messagesPerField.printIfExists("username", kcProps.kcFormGroupErrorClass))}>
-                            <div className={cx(kcProps.kcLabelWrapperClass)}>
-                                <label htmlFor="username" className={cx(kcProps.kcLabelClass)}>
+                        <div className={clsx(kcProps.kcFormGroupClass, messagesPerField.printIfExists("username", kcProps.kcFormGroupErrorClass))}>
+                            <div className={clsx(kcProps.kcLabelWrapperClass)}>
+                                <label htmlFor="username" className={clsx(kcProps.kcLabelClass)}>
                                    {msg("username")}
                                </label>
                            </div>
-                            <div className={cx(kcProps.kcInputWrapperClass)}>
+                            <div className={clsx(kcProps.kcInputWrapperClass)}>
                                <input
                                    type="text"
                                    id="username"
                                    name="username"
                                    defaultValue={user.username ?? ""}
-                                    className={cx(kcProps.kcInputClass)}
+                                    className={clsx(kcProps.kcInputClass)}
                                />
                            </div>
                        </div>
                    )}

-                    <div className={cx(kcProps.kcFormGroupClass, messagesPerField.printIfExists("email", kcProps.kcFormGroupErrorClass))}>
-                        <div className={cx(kcProps.kcLabelWrapperClass)}>
-                            <label htmlFor="email" className={cx(kcProps.kcLabelClass)}>
+                    <div className={clsx(kcProps.kcFormGroupClass, messagesPerField.printIfExists("email", kcProps.kcFormGroupErrorClass))}>
+                        <div className={clsx(kcProps.kcLabelWrapperClass)}>
+                            <label htmlFor="email" className={clsx(kcProps.kcLabelClass)}>
                                {msg("email")}
                            </label>
                        </div>
-                        <div className={cx(kcProps.kcInputWrapperClass)}>
-                            <input type="text" id="email" name="email" defaultValue={user.email ?? ""} className={cx(kcProps.kcInputClass)} />
+                        <div className={clsx(kcProps.kcInputWrapperClass)}>
+                            <input type="text" id="email" name="email" defaultValue={user.email ?? ""} className={clsx(kcProps.kcInputClass)} />
                        </div>
                    </div>

-                    <div className={cx(kcProps.kcFormGroupClass, messagesPerField.printIfExists("firstName", kcProps.kcFormGroupErrorClass))}>
-                        <div className={cx(kcProps.kcLabelWrapperClass)}>
-                            <label htmlFor="firstName" className={cx(kcProps.kcLabelClass)}>
+                    <div className={clsx(kcProps.kcFormGroupClass, messagesPerField.printIfExists("firstName", kcProps.kcFormGroupErrorClass))}>
+                        <div className={clsx(kcProps.kcLabelWrapperClass)}>
+                            <label htmlFor="firstName" className={clsx(kcProps.kcLabelClass)}>
                                {msg("firstName")}
                            </label>
                        </div>
-                        <div className={cx(kcProps.kcInputWrapperClass)}>
+                        <div className={clsx(kcProps.kcInputWrapperClass)}>
                            <input
                                type="text"
                                id="firstName"
                                name="firstName"
                                defaultValue={user.firstName ?? ""}
-                                className={cx(kcProps.kcInputClass)}
+                                className={clsx(kcProps.kcInputClass)}
                            />
                        </div>
                    </div>

-                    <div className={cx(kcProps.kcFormGroupClass, messagesPerField.printIfExists("lastName", kcProps.kcFormGroupErrorClass))}>
-                        <div className={cx(kcProps.kcLabelWrapperClass)}>
-                            <label htmlFor="lastName" className={cx(kcProps.kcLabelClass)}>
+                    <div className={clsx(kcProps.kcFormGroupClass, messagesPerField.printIfExists("lastName", kcProps.kcFormGroupErrorClass))}>
+                        <div className={clsx(kcProps.kcLabelWrapperClass)}>
+                            <label htmlFor="lastName" className={clsx(kcProps.kcLabelClass)}>
                                {msg("lastName")}
                            </label>
                        </div>
-                        <div className={cx(kcProps.kcInputWrapperClass)}>
+                        <div className={clsx(kcProps.kcInputWrapperClass)}>
                            <input
                                type="text"
                                id="lastName"
                                name="lastName"
                                defaultValue={user.lastName ?? ""}
-                                className={cx(kcProps.kcInputClass)}
+                                className={clsx(kcProps.kcInputClass)}
                            />
                        </div>
                    </div>

-                    <div className={cx(kcProps.kcFormGroupClass)}>
-                        <div id="kc-form-options" className={cx(kcProps.kcFormOptionsClass)}>
-                            <div className={cx(kcProps.kcFormOptionsWrapperClass)} />
+                    <div className={clsx(kcProps.kcFormGroupClass)}>
+                        <div id="kc-form-options" className={clsx(kcProps.kcFormOptionsClass)}>
+                            <div className={clsx(kcProps.kcFormOptionsWrapperClass)} />
                        </div>

-                        <div id="kc-form-buttons" className={cx(kcProps.kcFormButtonsClass)}>
+                        <div id="kc-form-buttons" className={clsx(kcProps.kcFormButtonsClass)}>
                            {isAppInitiatedAction ? (
                                <>
                                    <input
-                                        className={cx(kcProps.kcButtonClass, kcProps.kcButtonPrimaryClass, kcProps.kcButtonLargeClass)}
+                                        className={clsx(kcProps.kcButtonClass, kcProps.kcButtonPrimaryClass, kcProps.kcButtonLargeClass)}
                                        type="submit"
                                        defaultValue={msgStr("doSubmit")}
                                    />
                                    <button
-                                        className={cx(kcProps.kcButtonClass, kcProps.kcButtonDefaultClass, kcProps.kcButtonLargeClass)}
+                                        className={clsx(kcProps.kcButtonClass, kcProps.kcButtonDefaultClass, kcProps.kcButtonLargeClass)}
                                        type="submit"
                                        name="cancel-aia"
                                        value="true"
@ -116,7 +114,7 @@ const LoginUpdateProfile = memo((props: LoginUpdateProfile) => {
                                </>
                            ) : (
                                <input
-                                    className={cx(
+                                    className={clsx(
                                        kcProps.kcButtonClass,
                                        kcProps.kcButtonPrimaryClass,
                                        kcProps.kcButtonBlockClass,
--- a/src/lib/components/LoginUsername.tsx
+++ b/src/lib/components/LoginUsername.tsx
@ -3,7 +3,7 @@ import DefaultTemplate from "./Template";
 import type { TemplateProps } from "./Template";
 import type { KcProps } from "./KcProps";
 import type { KcContextBase } from "../getKcContext/KcContextBase";
-import { useCssAndCx } from "../tools/useCssAndCx";
+import { clsx } from "../tools/clsx";
 import { useConstCallback } from "powerhooks/useConstCallback";
 import type { FormEventHandler } from "react";
 import type { I18n } from "../i18n";
@ -22,8 +22,6 @@ const LoginUsername = memo((props: LoginUsernameProps) => {

    const { msg, msgStr } = i18n;

-    const { cx } = useCssAndCx();
-
    const [isLoginButtonDisabled, setIsLoginButtonDisabled] = useState(false);

    const onSubmit = useConstCallback<FormEventHandler<HTMLFormElement>>(e => {
@ -47,16 +45,16 @@ const LoginUsername = memo((props: LoginUsernameProps) => {
            displayWide={realm.password && social.providers !== undefined}
            headerNode={msg("doLogIn")}
            formNode={
-                <div id="kc-form" className={cx(realm.password && social.providers !== undefined && kcProps.kcContentWrapperClass)}>
+                <div id="kc-form" className={clsx(realm.password && social.providers !== undefined && kcProps.kcContentWrapperClass)}>
                    <div
                        id="kc-form-wrapper"
-                        className={cx(
+                        className={clsx(
                            realm.password && social.providers && [kcProps.kcFormSocialAccountContentClass, kcProps.kcFormSocialAccountClass]
                        )}
                    >
                        {realm.password && (
                            <form id="kc-form-login" onSubmit={onSubmit} action={url.loginAction} method="post">
-                                <div className={cx(kcProps.kcFormGroupClass)}>
+                                <div className={clsx(kcProps.kcFormGroupClass)}>
                                    {!usernameHidden &&
                                        (() => {
                                            const label = !realm.loginWithEmailAllowed
@ -69,13 +67,13 @@ const LoginUsername = memo((props: LoginUsernameProps) => {

                                            return (
                                                <>
-                                                    <label htmlFor={autoCompleteHelper} className={cx(kcProps.kcLabelClass)}>
+                                                    <label htmlFor={autoCompleteHelper} className={clsx(kcProps.kcLabelClass)}>
                                                        {msg(label)}
                                                    </label>
                                                    <input
                                                        tabIndex={1}
                                                        id={autoCompleteHelper}
-                                                        className={cx(kcProps.kcInputClass)}
+                                                        className={clsx(kcProps.kcInputClass)}
                                                        //NOTE: This is used by Google Chrome auto fill so we use it to tell
                                                        //the browser how to pre fill the form but before submit we put it back
                                                        //to username because it is what keycloak expects.
@ -89,7 +87,7 @@ const LoginUsername = memo((props: LoginUsernameProps) => {
                                            );
                                        })()}
                                </div>
-                                <div className={cx(kcProps.kcFormGroupClass, kcProps.kcFormSettingClass)}>
+                                <div className={clsx(kcProps.kcFormGroupClass, kcProps.kcFormSettingClass)}>
                                    <div id="kc-form-options">
                                        {realm.rememberMe && !usernameHidden && (
                                            <div className="checkbox">
@ -111,10 +109,10 @@ const LoginUsername = memo((props: LoginUsernameProps) => {
                                        )}
                                    </div>
                                </div>
-                                <div id="kc-form-buttons" className={cx(kcProps.kcFormGroupClass)}>
+                                <div id="kc-form-buttons" className={clsx(kcProps.kcFormGroupClass)}>
                                    <input
                                        tabIndex={4}
-                                        className={cx(
+                                        className={clsx(
                                            kcProps.kcButtonClass,
                                            kcProps.kcButtonPrimaryClass,
                                            kcProps.kcButtonBlockClass,
@ -131,16 +129,16 @@ const LoginUsername = memo((props: LoginUsernameProps) => {
                        )}
                    </div>
                    {realm.password && social.providers !== undefined && (
-                        <div id="kc-social-providers" className={cx(kcProps.kcFormSocialAccountContentClass, kcProps.kcFormSocialAccountClass)}>
+                        <div id="kc-social-providers" className={clsx(kcProps.kcFormSocialAccountContentClass, kcProps.kcFormSocialAccountClass)}>
                            <ul
-                                className={cx(
+                                className={clsx(
                                    kcProps.kcFormSocialAccountListClass,
                                    social.providers.length > 4 && kcProps.kcFormSocialAccountDoubleListClass
                                )}
                            >
                                {social.providers.map(p => (
-                                    <li key={p.providerId} className={cx(kcProps.kcFormSocialAccountListLinkClass)}>
-                                        <a href={p.loginUrl} id={`zocial-${p.alias}`} className={cx("zocial", p.providerId)}>
+                                    <li key={p.providerId} className={clsx(kcProps.kcFormSocialAccountListLinkClass)}>
+                                        <a href={p.loginUrl} id={`zocial-${p.alias}`} className={clsx("zocial", p.providerId)}>
                                            <span>{p.displayName}</span>
                                        </a>
                                    </li>
--- a/src/lib/components/LogoutConfirm.tsx
+++ b/src/lib/components/LogoutConfirm.tsx
@ -1,5 +1,5 @@
 import React, { memo } from "react";
-import { useCssAndCx } from "../tools/useCssAndCx";
+import { clsx } from "../tools/clsx";
 import DefaultTemplate from "./Template";
 import type { TemplateProps } from "./Template";
 import type { KcProps } from "./KcProps";
@ -18,8 +18,6 @@ const LogoutConfirm = memo((props: LogoutConfirmProps) => {

    const { url, client, logoutConfirm } = kcContext;

-    const { cx } = useCssAndCx();
-
    const { msg, msgStr } = i18n;

    return (
@ -33,14 +31,14 @@ const LogoutConfirm = memo((props: LogoutConfirmProps) => {
                        <p className="instruction">{msg("logoutConfirmHeader")}</p>
                        <form className="form-actions" action={url.logoutConfirmAction} method="POST">
                            <input type="hidden" name="session_code" value={logoutConfirm.code} />
-                            <div className={cx(kcProps.kcFormGroupClass)}>
+                            <div className={clsx(kcProps.kcFormGroupClass)}>
                                <div id="kc-form-options">
-                                    <div className={cx(kcProps.kcFormOptionsWrapperClass)}></div>
+                                    <div className={clsx(kcProps.kcFormOptionsWrapperClass)}></div>
                                </div>
-                                <div id="kc-form-buttons" className={cx(kcProps.kcFormGroupClass)}>
+                                <div id="kc-form-buttons" className={clsx(kcProps.kcFormGroupClass)}>
                                    <input
                                        tabIndex={4}
-                                        className={cx(
+                                        className={clsx(
                                            kcProps.kcButtonClass,
                                            kcProps.kcButtonPrimaryClass,
                                            kcProps.kcButtonBlockClass,
--- a/src/lib/components/Register.tsx
+++ b/src/lib/components/Register.tsx
@ -3,7 +3,7 @@ import DefaultTemplate from "./Template";
 import type { TemplateProps } from "./Template";
 import type { KcProps } from "./KcProps";
 import type { KcContextBase } from "../getKcContext/KcContextBase";
-import { useCssAndCx } from "../tools/useCssAndCx";
+import { clsx } from "../tools/clsx";
 import type { I18n } from "../i18n";

 export type RegisterProps = KcProps & {
@ -20,59 +20,57 @@ const Register = memo((props: RegisterProps) => {

    const { msg, msgStr } = i18n;

-    const { cx } = useCssAndCx();
-
    return (
        <Template
            {...{ kcContext, i18n, doFetchDefaultThemeResources, ...kcProps }}
            headerNode={msg("registerTitle")}
            formNode={
-                <form id="kc-register-form" className={cx(kcProps.kcFormClass)} action={url.registrationAction} method="post">
-                    <div className={cx(kcProps.kcFormGroupClass, messagesPerField.printIfExists("firstName", kcProps.kcFormGroupErrorClass))}>
-                        <div className={cx(kcProps.kcLabelWrapperClass)}>
-                            <label htmlFor="firstName" className={cx(kcProps.kcLabelClass)}>
+                <form id="kc-register-form" className={clsx(kcProps.kcFormClass)} action={url.registrationAction} method="post">
+                    <div className={clsx(kcProps.kcFormGroupClass, messagesPerField.printIfExists("firstName", kcProps.kcFormGroupErrorClass))}>
+                        <div className={clsx(kcProps.kcLabelWrapperClass)}>
+                            <label htmlFor="firstName" className={clsx(kcProps.kcLabelClass)}>
                                {msg("firstName")}
                            </label>
                        </div>
-                        <div className={cx(kcProps.kcInputWrapperClass)}>
+                        <div className={clsx(kcProps.kcInputWrapperClass)}>
                            <input
                                type="text"
                                id="firstName"
-                                className={cx(kcProps.kcInputClass)}
+                                className={clsx(kcProps.kcInputClass)}
                                name="firstName"
                                defaultValue={register.formData.firstName ?? ""}
                            />
                        </div>
                    </div>

-                    <div className={cx(kcProps.kcFormGroupClass, messagesPerField.printIfExists("lastName", kcProps.kcFormGroupErrorClass))}>
-                        <div className={cx(kcProps.kcLabelWrapperClass)}>
-                            <label htmlFor="lastName" className={cx(kcProps.kcLabelClass)}>
+                    <div className={clsx(kcProps.kcFormGroupClass, messagesPerField.printIfExists("lastName", kcProps.kcFormGroupErrorClass))}>
+                        <div className={clsx(kcProps.kcLabelWrapperClass)}>
+                            <label htmlFor="lastName" className={clsx(kcProps.kcLabelClass)}>
                                {msg("lastName")}
                            </label>
                        </div>
-                        <div className={cx(kcProps.kcInputWrapperClass)}>
+                        <div className={clsx(kcProps.kcInputWrapperClass)}>
                            <input
                                type="text"
                                id="lastName"
-                                className={cx(kcProps.kcInputClass)}
+                                className={clsx(kcProps.kcInputClass)}
                                name="lastName"
                                defaultValue={register.formData.lastName ?? ""}
                            />
                        </div>
                    </div>

-                    <div className={cx(kcProps.kcFormGroupClass, messagesPerField.printIfExists("email", kcProps.kcFormGroupErrorClass))}>
-                        <div className={cx(kcProps.kcLabelWrapperClass)}>
-                            <label htmlFor="email" className={cx(kcProps.kcLabelClass)}>
+                    <div className={clsx(kcProps.kcFormGroupClass, messagesPerField.printIfExists("email", kcProps.kcFormGroupErrorClass))}>
+                        <div className={clsx(kcProps.kcLabelWrapperClass)}>
+                            <label htmlFor="email" className={clsx(kcProps.kcLabelClass)}>
                                {msg("email")}
                            </label>
                        </div>
-                        <div className={cx(kcProps.kcInputWrapperClass)}>
+                        <div className={clsx(kcProps.kcInputWrapperClass)}>
                            <input
                                type="text"
                                id="email"
-                                className={cx(kcProps.kcInputClass)}
+                                className={clsx(kcProps.kcInputClass)}
                                name="email"
                                defaultValue={register.formData.email ?? ""}
                                autoComplete="email"
@ -80,17 +78,17 @@ const Register = memo((props: RegisterProps) => {
                        </div>
                    </div>
                    {!realm.registrationEmailAsUsername && (
-                        <div className={cx(kcProps.kcFormGroupClass, messagesPerField.printIfExists("username", kcProps.kcFormGroupErrorClass))}>
-                            <div className={cx(kcProps.kcLabelWrapperClass)}>
-                                <label htmlFor="username" className={cx(kcProps.kcLabelClass)}>
+                        <div className={clsx(kcProps.kcFormGroupClass, messagesPerField.printIfExists("username", kcProps.kcFormGroupErrorClass))}>
+                            <div className={clsx(kcProps.kcLabelWrapperClass)}>
+                                <label htmlFor="username" className={clsx(kcProps.kcLabelClass)}>
                                    {msg("username")}
                                </label>
                            </div>
-                            <div className={cx(kcProps.kcInputWrapperClass)}>
+                            <div className={clsx(kcProps.kcInputWrapperClass)}>
                                <input
                                    type="text"
                                    id="username"
-                                    className={cx(kcProps.kcInputClass)}
+                                    className={clsx(kcProps.kcInputClass)}
                                    name="username"
                                    defaultValue={register.formData.username ?? ""}
                                    autoComplete="username"
@ -100,17 +98,19 @@ const Register = memo((props: RegisterProps) => {
                    )}
                    {passwordRequired && (
                        <>
-                            <div className={cx(kcProps.kcFormGroupClass, messagesPerField.printIfExists("password", kcProps.kcFormGroupErrorClass))}>
-                                <div className={cx(kcProps.kcLabelWrapperClass)}>
-                                    <label htmlFor="password" className={cx(kcProps.kcLabelClass)}>
+                            <div
+                                className={clsx(kcProps.kcFormGroupClass, messagesPerField.printIfExists("password", kcProps.kcFormGroupErrorClass))}
+                            >
+                                <div className={clsx(kcProps.kcLabelWrapperClass)}>
+                                    <label htmlFor="password" className={clsx(kcProps.kcLabelClass)}>
                                        {msg("password")}
                                    </label>
                                </div>
-                                <div className={cx(kcProps.kcInputWrapperClass)}>
+                                <div className={clsx(kcProps.kcInputWrapperClass)}>
                                    <input
                                        type="password"
                                        id="password"
-                                        className={cx(kcProps.kcInputClass)}
+                                        className={clsx(kcProps.kcInputClass)}
                                        name="password"
                                        autoComplete="new-password"
                                    />
@ -118,41 +118,41 @@ const Register = memo((props: RegisterProps) => {
                            </div>

                            <div
-                                className={cx(
+                                className={clsx(
                                    kcProps.kcFormGroupClass,
                                    messagesPerField.printIfExists("password-confirm", kcProps.kcFormGroupErrorClass)
                                )}
                            >
-                                <div className={cx(kcProps.kcLabelWrapperClass)}>
-                                    <label htmlFor="password-confirm" className={cx(kcProps.kcLabelClass)}>
+                                <div className={clsx(kcProps.kcLabelWrapperClass)}>
+                                    <label htmlFor="password-confirm" className={clsx(kcProps.kcLabelClass)}>
                                        {msg("passwordConfirm")}
                                    </label>
                                </div>
-                                <div className={cx(kcProps.kcInputWrapperClass)}>
-                                    <input type="password" id="password-confirm" className={cx(kcProps.kcInputClass)} name="password-confirm" />
+                                <div className={clsx(kcProps.kcInputWrapperClass)}>
+                                    <input type="password" id="password-confirm" className={clsx(kcProps.kcInputClass)} name="password-confirm" />
                                </div>
                            </div>
                        </>
                    )}
                    {recaptchaRequired && (
                        <div className="form-group">
-                            <div className={cx(kcProps.kcInputWrapperClass)}>
+                            <div className={clsx(kcProps.kcInputWrapperClass)}>
                                <div className="g-recaptcha" data-size="compact" data-sitekey={recaptchaSiteKey}></div>
                            </div>
                        </div>
                    )}
-                    <div className={cx(kcProps.kcFormGroupClass)}>
-                        <div id="kc-form-options" className={cx(kcProps.kcFormOptionsClass)}>
-                            <div className={cx(kcProps.kcFormOptionsWrapperClass)}>
+                    <div className={clsx(kcProps.kcFormGroupClass)}>
+                        <div id="kc-form-options" className={clsx(kcProps.kcFormOptionsClass)}>
+                            <div className={clsx(kcProps.kcFormOptionsWrapperClass)}>
                                <span>
                                    <a href={url.loginUrl}>{msg("backToLogin")}</a>
                                </span>
                            </div>
                        </div>

-                        <div id="kc-form-buttons" className={cx(kcProps.kcFormButtonsClass)}>
+                        <div id="kc-form-buttons" className={clsx(kcProps.kcFormButtonsClass)}>
                            <input
-                                className={cx(
+                                className={clsx(
                                    kcProps.kcButtonClass,
                                    kcProps.kcButtonPrimaryClass,
                                    kcProps.kcButtonBlockClass,
--- a/src/lib/components/RegisterUserProfile.tsx
+++ b/src/lib/components/RegisterUserProfile.tsx
@ -1,9 +1,9 @@
-import React, { useMemo, memo, useState } from "react";
+import React, { memo, useState } from "react";
 import DefaultTemplate from "./Template";
 import type { TemplateProps } from "./Template";
 import type { KcProps } from "./KcProps";
 import type { KcContextBase } from "../getKcContext/KcContextBase";
-import { useCssAndCx } from "../tools/useCssAndCx";
+import { clsx } from "../tools/clsx";
 import type { I18n } from "../i18n";
 import { UserProfileFormFields } from "./shared/UserProfileCommons";

@ -15,22 +15,12 @@ export type RegisterUserProfileProps = KcProps & {
 };

 const RegisterUserProfile = memo((props: RegisterUserProfileProps) => {
-    const { kcContext, i18n, doFetchDefaultThemeResources = true, Template = DefaultTemplate, ...kcProps_ } = props;
+    const { kcContext, i18n, doFetchDefaultThemeResources = true, Template = DefaultTemplate, ...kcProps } = props;

    const { url, messagesPerField, recaptchaRequired, recaptchaSiteKey } = kcContext;

    const { msg, msgStr } = i18n;

-    const { cx, css } = useCssAndCx();
-
-    const kcProps = useMemo(
-        () => ({
-            ...kcProps_,
-            "kcFormGroupClass": cx(kcProps_.kcFormGroupClass, css({ "marginBottom": 20 }))
-        }),
-        [cx, css]
-    );
-
    const [isFomSubmittable, setIsFomSubmittable] = useState(false);

    return (
@ -40,27 +30,27 @@ const RegisterUserProfile = memo((props: RegisterUserProfileProps) => {
            displayRequiredFields={true}
            headerNode={msg("registerTitle")}
            formNode={
-                <form id="kc-register-form" className={cx(kcProps.kcFormClass)} action={url.registrationAction} method="post">
+                <form id="kc-register-form" className={clsx(kcProps.kcFormClass)} action={url.registrationAction} method="post">
                    <UserProfileFormFields kcContext={kcContext} onIsFormSubmittableValueChange={setIsFomSubmittable} i18n={i18n} {...kcProps} />
                    {recaptchaRequired && (
                        <div className="form-group">
-                            <div className={cx(kcProps.kcInputWrapperClass)}>
+                            <div className={clsx(kcProps.kcInputWrapperClass)}>
                                <div className="g-recaptcha" data-size="compact" data-sitekey={recaptchaSiteKey} />
                            </div>
                        </div>
                    )}
-                    <div className={cx(kcProps.kcFormGroupClass)}>
-                        <div id="kc-form-options" className={cx(kcProps.kcFormOptionsClass)}>
-                            <div className={cx(kcProps.kcFormOptionsWrapperClass)}>
+                    <div className={clsx(kcProps.kcFormGroupClass)} style={{ "marginBottom": 30 }}>
+                        <div id="kc-form-options" className={clsx(kcProps.kcFormOptionsClass)}>
+                            <div className={clsx(kcProps.kcFormOptionsWrapperClass)}>
                                <span>
                                    <a href={url.loginUrl}>{msg("backToLogin")}</a>
                                </span>
                            </div>
                        </div>

-                        <div id="kc-form-buttons" className={cx(kcProps.kcFormButtonsClass)}>
+                        <div id="kc-form-buttons" className={clsx(kcProps.kcFormButtonsClass)}>
                            <input
-                                className={cx(
+                                className={clsx(
                                    kcProps.kcButtonClass,
                                    kcProps.kcButtonPrimaryClass,
                                    kcProps.kcButtonBlockClass,
--- a/src/lib/components/Template.tsx
+++ b/src/lib/components/Template.tsx
@ -7,7 +7,7 @@ import { headInsert } from "../tools/headInsert";
 import { pathJoin } from "../../bin/tools/pathJoin";
 import { useConstCallback } from "powerhooks/useConstCallback";
 import type { KcTemplateProps } from "./KcProps";
-import { useCssAndCx } from "../tools/useCssAndCx";
+import { clsx } from "../tools/clsx";
 import type { I18n } from "../i18n";

 export type TemplateProps = {
@ -42,8 +42,6 @@ const Template = memo((props: TemplateProps) => {
        doFetchDefaultThemeResources
    } = props;

-    const { cx } = useCssAndCx();
-
    const { msg, changeLocale, labelBySupportedLanguageTag, currentLanguageTag } = i18n;

    const onChangeLanguageClickFactory = useCallbackFactory(([kcLanguageTag]: [string]) => changeLocale(kcLanguageTag));
@ -96,7 +94,7 @@ const Template = memo((props: TemplateProps) => {
        if (props.kcHtmlClass !== undefined) {
            const htmlClassList = document.getElementsByTagName("html")[0].classList;

-            const tokens = cx(props.kcHtmlClass).split(" ");
+            const tokens = clsx(props.kcHtmlClass).split(" ");

            htmlClassList.add(...tokens);

@ -115,18 +113,18 @@ const Template = memo((props: TemplateProps) => {
    }

    return (
-        <div className={cx(props.kcLoginClass)}>
-            <div id="kc-header" className={cx(props.kcHeaderClass)}>
-                <div id="kc-header-wrapper" className={cx(props.kcHeaderWrapperClass)}>
+        <div className={clsx(props.kcLoginClass)}>
+            <div id="kc-header" className={clsx(props.kcHeaderClass)}>
+                <div id="kc-header-wrapper" className={clsx(props.kcHeaderWrapperClass)}>
                    {msg("loginTitleHtml", realm.displayNameHtml)}
                </div>
            </div>

-            <div className={cx(props.kcFormCardClass, displayWide && props.kcFormCardAccountClass)}>
-                <header className={cx(props.kcFormHeaderClass)}>
+            <div className={clsx(props.kcFormCardClass, displayWide && props.kcFormCardAccountClass)}>
+                <header className={clsx(props.kcFormHeaderClass)}>
                    {realm.internationalizationEnabled && (assert(locale !== undefined), true) && locale.supported.length > 1 && (
                        <div id="kc-locale">
-                            <div id="kc-locale-wrapper" className={cx(props.kcLocaleWrapperClass)}>
+                            <div id="kc-locale-wrapper" className={clsx(props.kcLocaleWrapperClass)}>
                                <div className="kc-dropdown" id="kc-locale-dropdown">
                                    <a href="#" id="kc-current-locale-link">
                                        {labelBySupportedLanguageTag[currentLanguageTag]}
@ -146,8 +144,8 @@ const Template = memo((props: TemplateProps) => {
                    )}
                    {!(auth !== undefined && auth.showUsername && !auth.showResetCredentials) ? (
                        displayRequiredFields ? (
-                            <div className={cx(props.kcContentWrapperClass)}>
-                                <div className={cx(props.kcLabelWrapperClass, "subtitle")}>
+                            <div className={clsx(props.kcContentWrapperClass)}>
+                                <div className={clsx(props.kcLabelWrapperClass, "subtitle")}>
                                    <span className="subtitle">
                                        <span className="required">*</span>
                                        {msg("requiredFields")}
@ -161,20 +159,20 @@ const Template = memo((props: TemplateProps) => {
                            <h1 id="kc-page-title">{headerNode}</h1>
                        )
                    ) : displayRequiredFields ? (
-                        <div className={cx(props.kcContentWrapperClass)}>
-                            <div className={cx(props.kcLabelWrapperClass, "subtitle")}>
+                        <div className={clsx(props.kcContentWrapperClass)}>
+                            <div className={clsx(props.kcLabelWrapperClass, "subtitle")}>
                                <span className="subtitle">
                                    <span className="required">*</span> {msg("requiredFields")}
                                </span>
                            </div>
                            <div className="col-md-10">
                                {showUsernameNode}
-                                <div className={cx(props.kcFormGroupClass)}>
+                                <div className={clsx(props.kcFormGroupClass)}>
                                    <div id="kc-username">
                                        <label id="kc-attempted-username">{auth?.attemptedUsername}</label>
                                        <a id="reset-login" href={url.loginRestartFlowUrl}>
                                            <div className="kc-login-tooltip">
-                                                <i className={cx(props.kcResetFlowIcon)}></i>
+                                                <i className={clsx(props.kcResetFlowIcon)}></i>
                                                <span className="kc-tooltip-text">{msg("restartLoginTooltip")}</span>
                                            </div>
                                        </a>
@ -185,12 +183,12 @@ const Template = memo((props: TemplateProps) => {
                    ) : (
                        <>
                            {showUsernameNode}
-                            <div className={cx(props.kcFormGroupClass)}>
+                            <div className={clsx(props.kcFormGroupClass)}>
                                <div id="kc-username">
                                    <label id="kc-attempted-username">{auth?.attemptedUsername}</label>
                                    <a id="reset-login" href={url.loginRestartFlowUrl}>
                                        <div className="kc-login-tooltip">
-                                            <i className={cx(props.kcResetFlowIcon)}></i>
+                                            <i className={clsx(props.kcResetFlowIcon)}></i>
                                            <span className="kc-tooltip-text">{msg("restartLoginTooltip")}</span>
                                        </div>
                                    </a>
@ -203,11 +201,11 @@ const Template = memo((props: TemplateProps) => {
                    <div id="kc-content-wrapper">
                        {/* App-initiated actions should not see warning messages about the need to complete the action during login. */}
                        {displayMessage && message !== undefined && (message.type !== "warning" || !isAppInitiatedAction) && (
-                            <div className={cx("alert", `alert-${message.type}`)}>
-                                {message.type === "success" && <span className={cx(props.kcFeedbackSuccessIcon)}></span>}
-                                {message.type === "warning" && <span className={cx(props.kcFeedbackWarningIcon)}></span>}
-                                {message.type === "error" && <span className={cx(props.kcFeedbackErrorIcon)}></span>}
-                                {message.type === "info" && <span className={cx(props.kcFeedbackInfoIcon)}></span>}
+                            <div className={clsx("alert", `alert-${message.type}`)}>
+                                {message.type === "success" && <span className={clsx(props.kcFeedbackSuccessIcon)}></span>}
+                                {message.type === "warning" && <span className={clsx(props.kcFeedbackWarningIcon)}></span>}
+                                {message.type === "error" && <span className={clsx(props.kcFeedbackErrorIcon)}></span>}
+                                {message.type === "info" && <span className={clsx(props.kcFeedbackInfoIcon)}></span>}
                                <span
                                    className="kc-feedback-text"
                                    dangerouslySetInnerHTML={{
@ -222,10 +220,10 @@ const Template = memo((props: TemplateProps) => {
                                id="kc-select-try-another-way-form"
                                action={url.loginAction}
                                method="post"
-                                className={cx(displayWide && props.kcContentWrapperClass)}
+                                className={clsx(displayWide && props.kcContentWrapperClass)}
                            >
-                                <div className={cx(displayWide && [props.kcFormSocialAccountContentClass, props.kcFormSocialAccountClass])}>
-                                    <div className={cx(props.kcFormGroupClass)}>
+                                <div className={clsx(displayWide && [props.kcFormSocialAccountContentClass, props.kcFormSocialAccountClass])}>
+                                    <div className={clsx(props.kcFormGroupClass)}>
                                        <input type="hidden" name="tryAnotherWay" value="on" />
                                        <a href="#" id="try-another-way" onClick={onTryAnotherWayClick}>
                                            {msg("doTryAnotherWay")}
@ -235,8 +233,8 @@ const Template = memo((props: TemplateProps) => {
                            </form>
                        )}
                        {displayInfo && (
-                            <div id="kc-info" className={cx(props.kcSignUpClass)}>
-                                <div id="kc-info-wrapper" className={cx(props.kcInfoAreaWrapperClass)}>
+                            <div id="kc-info" className={clsx(props.kcSignUpClass)}>
+                                <div id="kc-info-wrapper" className={clsx(props.kcInfoAreaWrapperClass)}>
                                    {infoNode}
                                </div>
                            </div>
--- a/src/lib/components/Terms.tsx
+++ b/src/lib/components/Terms.tsx
@ -3,7 +3,7 @@ import DefaultTemplate from "./Template";
 import type { TemplateProps } from "./Template";
 import type { KcProps } from "./KcProps";
 import type { KcContextBase } from "../getKcContext/KcContextBase";
-import { useCssAndCx } from "../tools/useCssAndCx";
+import { clsx } from "../tools/clsx";
 import { Evt } from "evt";
 import { useRerenderOnStateChange } from "evt/hooks";
 import { assert } from "tsafe/assert";
@ -70,8 +70,6 @@ const Terms = memo((props: TermsProps) => {

    useRerenderOnStateChange(evtTermMarkdown);

-    const { cx } = useCssAndCx();
-
    const { url } = kcContext;

    if (evtTermMarkdown.state === undefined) {
@ -88,7 +86,7 @@ const Terms = memo((props: TermsProps) => {
                    <div id="kc-terms-text">{evtTermMarkdown.state && <Markdown>{evtTermMarkdown.state}</Markdown>}</div>
                    <form className="form-actions" action={url.loginAction} method="POST">
                        <input
-                            className={cx(
+                            className={clsx(
                                kcProps.kcButtonClass,
                                kcProps.kcButtonClass,
                                kcProps.kcButtonClass,
@ -101,7 +99,7 @@ const Terms = memo((props: TermsProps) => {
                            value={msgStr("doAccept")}
                        />
                        <input
-                            className={cx(kcProps.kcButtonClass, kcProps.kcButtonDefaultClass, kcProps.kcButtonLargeClass)}
+                            className={clsx(kcProps.kcButtonClass, kcProps.kcButtonDefaultClass, kcProps.kcButtonLargeClass)}
                            name="cancel"
                            id="kc-decline"
                            type="submit"
--- a/src/lib/components/UpdateUserProfile.tsx
+++ b/src/lib/components/UpdateUserProfile.tsx
@ -3,7 +3,7 @@ import DefaultTemplate from "./Template";
 import type { TemplateProps } from "./Template";
 import type { KcProps } from "./KcProps";
 import type { KcContextBase } from "../getKcContext/KcContextBase";
-import { useCssAndCx } from "../tools/useCssAndCx";
+import { clsx } from "../tools/clsx";
 import type { I18n } from "../i18n";
 import { UserProfileFormFields } from "./shared/UserProfileCommons";

@ -17,8 +17,6 @@ export type UpdateUserProfileProps = KcProps & {
 const UpdateUserProfile = memo((props: UpdateUserProfileProps) => {
    const { kcContext, i18n, doFetchDefaultThemeResources = true, Template = DefaultTemplate, ...kcProps } = props;

-    const { cx } = useCssAndCx();
-
    const { msg, msgStr } = i18n;

    const { url, isAppInitiatedAction } = kcContext;
@ -30,24 +28,24 @@ const UpdateUserProfile = memo((props: UpdateUserProfileProps) => {
            {...{ kcContext, i18n, doFetchDefaultThemeResources, ...kcProps }}
            headerNode={msg("loginProfileTitle")}
            formNode={
-                <form id="kc-update-profile-form" className={cx(kcProps.kcFormClass)} action={url.loginAction} method="post">
+                <form id="kc-update-profile-form" className={clsx(kcProps.kcFormClass)} action={url.loginAction} method="post">
                    <UserProfileFormFields kcContext={kcContext} onIsFormSubmittableValueChange={setIsFomSubmittable} i18n={i18n} {...kcProps} />

-                    <div className={cx(kcProps.kcFormGroupClass)}>
-                        <div id="kc-form-options" className={cx(kcProps.kcFormOptionsClass)}>
-                            <div className={cx(kcProps.kcFormOptionsWrapperClass)}></div>
+                    <div className={clsx(kcProps.kcFormGroupClass)}>
+                        <div id="kc-form-options" className={clsx(kcProps.kcFormOptionsClass)}>
+                            <div className={clsx(kcProps.kcFormOptionsWrapperClass)}></div>
                        </div>

-                        <div id="kc-form-buttons" className={cx(kcProps.kcFormButtonsClass)}>
+                        <div id="kc-form-buttons" className={clsx(kcProps.kcFormButtonsClass)}>
                            {isAppInitiatedAction ? (
                                <>
                                    <input
-                                        className={cx(kcProps.kcButtonClass, kcProps.kcButtonPrimaryClass, kcProps.kcButtonLargeClass)}
+                                        className={clsx(kcProps.kcButtonClass, kcProps.kcButtonPrimaryClass, kcProps.kcButtonLargeClass)}
                                        type="submit"
                                        value={msgStr("doSubmit")}
                                    />
                                    <button
-                                        className={cx(kcProps.kcButtonClass, kcProps.kcButtonDefaultClass, kcProps.kcButtonLargeClass)}
+                                        className={clsx(kcProps.kcButtonClass, kcProps.kcButtonDefaultClass, kcProps.kcButtonLargeClass)}
                                        type="submit"
                                        name="cancel-aia"
                                        value="true"
@ -58,7 +56,7 @@ const UpdateUserProfile = memo((props: UpdateUserProfileProps) => {
                                </>
                            ) : (
                                <input
-                                    className={cx(
+                                    className={clsx(
                                        kcProps.kcButtonClass,
                                        kcProps.kcButtonPrimaryClass,
                                        kcProps.kcButtonBlockClass,
--- a/src/lib/components/WebauthnAuthenticate.tsx
+++ b/src/lib/components/WebauthnAuthenticate.tsx
@ -3,7 +3,7 @@ import DefaultTemplate from "./Template";
 import type { TemplateProps } from "./Template";
 import type { KcProps } from "./KcProps";
 import type { KcContextBase } from "../getKcContext/KcContextBase";
-import { useCssAndCx } from "../tools/useCssAndCx";
+import { clsx } from "../tools/clsx";
 import type { I18n, MessageKeyBase } from "../i18n";
 import { base64url } from "rfc4648";
 import { useConstCallback } from "powerhooks/useConstCallback";
@ -26,8 +26,6 @@ const WebauthnAuthenticate = memo((props: WebauthnAuthenticateProps) => {
    const createTimeout = Number(kcContext.createTimeout);
    const isUserIdentified = kcContext.isUserIdentified == "true";

-    const { cx } = useCssAndCx();
-
    const webAuthnAuthenticate = useConstCallback(async () => {
        if (!isUserIdentified) {
            return;
@ -102,7 +100,7 @@ const WebauthnAuthenticate = memo((props: WebauthnAuthenticateProps) => {
            {...{ kcContext, i18n, doFetchDefaultThemeResources, ...kcProps }}
            headerNode={msg("webauthn-login-title")}
            formNode={
-                <div id="kc-form-webauthn" className={cx(kcProps.kcFormClass)}>
+                <div id="kc-form-webauthn" className={clsx(kcProps.kcFormClass)}>
                    <form id="webauth" action={url.loginAction} ref={webAuthForm} method="post">
                        <input type="hidden" id="clientDataJSON" name="clientDataJSON" value={clientDataJSON} />
                        <input type="hidden" id="authenticatorData" name="authenticatorData" value={authenticatorData} />
@ -111,10 +109,10 @@ const WebauthnAuthenticate = memo((props: WebauthnAuthenticateProps) => {
                        <input type="hidden" id="userHandle" name="userHandle" value={userHandle} />
                        <input type="hidden" id="error" name="error" value={error} />
                    </form>
-                    <div className={cx(kcProps.kcFormGroupClass)}>
+                    <div className={clsx(kcProps.kcFormGroupClass)}>
                        {authenticators &&
                            (() => (
-                                <form id="authn_select" className={cx(kcProps.kcFormClass)}>
+                                <form id="authn_select" className={clsx(kcProps.kcFormClass)}>
                                    {authenticators.authenticators.map(authenticator => (
                                        <input
                                            type="hidden"
@ -130,23 +128,23 @@ const WebauthnAuthenticate = memo((props: WebauthnAuthenticateProps) => {
                            (() => (
                                <>
                                    {authenticators.authenticators.length > 1 && (
-                                        <p className={cx(kcProps.kcSelectAuthListItemTitle)}>{msg("webauthn-available-authenticators")}</p>
+                                        <p className={clsx(kcProps.kcSelectAuthListItemTitle)}>{msg("webauthn-available-authenticators")}</p>
                                    )}
-                                    <div className={cx(kcProps.kcFormClass)}>
+                                    <div className={clsx(kcProps.kcFormClass)}>
                                        {authenticators.authenticators.map(authenticator => (
-                                            <div id="kc-webauthn-authenticator" className={cx(kcProps.kcSelectAuthListItemClass)}>
-                                                <div className={cx(kcProps.kcSelectAuthListItemIconClass)}>
+                                            <div id="kc-webauthn-authenticator" className={clsx(kcProps.kcSelectAuthListItemClass)}>
+                                                <div className={clsx(kcProps.kcSelectAuthListItemIconClass)}>
                                                    <i
-                                                        className={cx(
+                                                        className={clsx(
                                                            kcProps[authenticator.transports.iconClass] ?? kcProps.kcWebAuthnDefaultIcon,
                                                            kcProps.kcSelectAuthListItemIconPropertyClass
                                                        )}
                                                    />
                                                </div>
-                                                <div className={cx(kcProps.kcSelectAuthListItemBodyClass)}>
+                                                <div className={clsx(kcProps.kcSelectAuthListItemBodyClass)}>
                                                    <div
                                                        id="kc-webauthn-authenticator-label"
-                                                        className={cx(kcProps.kcSelectAuthListItemHeadingClass)}
+                                                        className={clsx(kcProps.kcSelectAuthListItemHeadingClass)}
                                                    >
                                                        {authenticator.label}
                                                    </div>
@ -154,7 +152,7 @@ const WebauthnAuthenticate = memo((props: WebauthnAuthenticateProps) => {
                                                    {authenticator.transports && authenticator.transports.displayNameProperties.length && (
                                                        <div
                                                            id="kc-webauthn-authenticator-transport"
-                                                            className={cx(kcProps.kcSelectAuthListItemDescriptionClass)}
+                                                            className={clsx(kcProps.kcSelectAuthListItemDescriptionClass)}
                                                        >
                                                            {authenticator.transports.displayNameProperties.map(
                                                                (transport: MessageKeyBase, index: number) => (
@ -169,25 +167,25 @@ const WebauthnAuthenticate = memo((props: WebauthnAuthenticateProps) => {
                                                        </div>
                                                    )}

-                                                    <div className={cx(kcProps.kcSelectAuthListItemDescriptionClass)}>
+                                                    <div className={clsx(kcProps.kcSelectAuthListItemDescriptionClass)}>
                                                        <span id="kc-webauthn-authenticator-created-label">{msg("webauthn-createdAt-label")}</span>
                                                        <span id="kc-webauthn-authenticator-created">{authenticator.createdAt}</span>
                                                    </div>
                                                </div>
-                                                <div className={cx(kcProps.kcSelectAuthListItemFillClass)} />
+                                                <div className={clsx(kcProps.kcSelectAuthListItemFillClass)} />
                                            </div>
                                        ))}
                                    </div>
                                </>
                            ))()}
-                        <div id="kc-form-buttons" className={cx(kcProps.kcFormButtonsClass)}>
+                        <div id="kc-form-buttons" className={clsx(kcProps.kcFormButtonsClass)}>
                            <input
                                id="authenticateWebAuthnButton"
                                type="button"
                                onClick={webAuthnAuthenticate}
                                autoFocus={true}
                                value={msgStr("webauthn-doAuthenticate")}
-                                className={cx(
+                                className={clsx(
                                    kcProps.kcButtonClass,
                                    kcProps.kcButtonPrimaryClass,
                                    kcProps.kcButtonBlockClass,
--- a/src/lib/components/shared/UserProfileCommons.tsx
+++ b/src/lib/components/shared/UserProfileCommons.tsx
@ -1,7 +1,7 @@
 import React, { memo, useEffect, Fragment } from "react";
 import type { KcProps } from "../KcProps";
 import type { Attribute } from "../../getKcContext/KcContextBase";
-import { useCssAndCx } from "../../tools/useCssAndCx";
+import { clsx } from "../../tools/clsx";
 import type { ReactComponent } from "../../tools/ReactComponent";
 import { useCallbackFactory } from "powerhooks/useCallbackFactory";
 import { useFormValidationSlice } from "../../useFormValidationSlice";
@ -18,8 +18,6 @@ export type UserProfileFormFieldsProps = {

 export const UserProfileFormFields = memo(
    ({ kcContext, onIsFormSubmittableValueChange, i18n, BeforeField, AfterField, ...props }: UserProfileFormFieldsProps) => {
-        const { cx, css } = useCssAndCx();
-
        const { advancedMsg } = i18n;

        const {
@ -67,20 +65,20 @@ export const UserProfileFormFields = memo(

                    const { value, displayableErrors } = fieldStateByAttributeName[attribute.name];

-                    const formGroupClassName = cx(props.kcFormGroupClass, displayableErrors.length !== 0 && props.kcFormGroupErrorClass);
+                    const formGroupClassName = clsx(props.kcFormGroupClass, displayableErrors.length !== 0 && props.kcFormGroupErrorClass);

                    return (
                        <Fragment key={i}>
                            {group !== currentGroup && (currentGroup = group) !== "" && (
                                <div className={formGroupClassName}>
-                                    <div className={cx(props.kcContentWrapperClass)}>
-                                        <label id={`header-${group}`} className={cx(props.kcFormGroupHeader)}>
+                                    <div className={clsx(props.kcContentWrapperClass)}>
+                                        <label id={`header-${group}`} className={clsx(props.kcFormGroupHeader)}>
                                            {advancedMsg(groupDisplayHeader) || currentGroup}
                                        </label>
                                    </div>
                                    {groupDisplayDescription !== "" && (
-                                        <div className={cx(props.kcLabelWrapperClass)}>
-                                            <label id={`description-${group}`} className={`${cx(props.kcLabelClass)}`}>
+                                        <div className={clsx(props.kcLabelWrapperClass)}>
+                                            <label id={`description-${group}`} className={`${clsx(props.kcLabelClass)}`}>
                                                {advancedMsg(groupDisplayDescription)}
                                            </label>
                                        </div>
@ -91,13 +89,13 @@ export const UserProfileFormFields = memo(
                            {BeforeField && <BeforeField attribute={attribute} />}

                            <div className={formGroupClassName}>
-                                <div className={cx(props.kcLabelWrapperClass)}>
-                                    <label htmlFor={attribute.name} className={cx(props.kcLabelClass)}>
+                                <div className={clsx(props.kcLabelWrapperClass)}>
+                                    <label htmlFor={attribute.name} className={clsx(props.kcLabelClass)}>
                                        {advancedMsg(attribute.displayName ?? "")}
                                    </label>
                                    {attribute.required && <>*</>}
                                </div>
-                                <div className={cx(props.kcInputWrapperClass)}>
+                                <div className={clsx(props.kcInputWrapperClass)}>
                                    {(() => {
                                        const { options } = attribute.validators;

@ -134,7 +132,7 @@ export const UserProfileFormFields = memo(
                                                name={attribute.name}
                                                value={value}
                                                onChange={onChangeFactory(attribute.name)}
-                                                className={cx(props.kcInputClass)}
+                                                className={clsx(props.kcInputClass)}
                                                aria-invalid={displayableErrors.length !== 0}
                                                disabled={attribute.readOnly}
                                                autoComplete={attribute.autocomplete}
@ -142,21 +140,26 @@ export const UserProfileFormFields = memo(
                                            />
                                        );
                                    })()}
-                                    {displayableErrors.length !== 0 && (
-                                        <span
-                                            id={`input-error-${attribute.name}`}
-                                            className={cx(
-                                                props.kcInputErrorMessageClass,
-                                                css({
-                                                    "position": displayableErrors.length === 1 ? "absolute" : undefined,
-                                                    "& > span": { "display": "block" }
-                                                })
-                                            )}
-                                            aria-live="polite"
-                                        >
-                                            {displayableErrors.map(({ errorMessage }) => errorMessage)}
-                                        </span>
-                                    )}
+                                    {displayableErrors.length !== 0 &&
+                                        (() => {
+                                            const divId = `input-error-${attribute.name}`;
+
+                                            return (
+                                                <>
+                                                    <style>{`#${divId} > span: { display: block; }`}</style>
+                                                    <span
+                                                        id={divId}
+                                                        className={clsx(props.kcInputErrorMessageClass)}
+                                                        style={{
+                                                            "position": displayableErrors.length === 1 ? "absolute" : undefined
+                                                        }}
+                                                        aria-live="polite"
+                                                    >
+                                                        {displayableErrors.map(({ errorMessage }) => errorMessage)}
+                                                    </span>
+                                                </>
+                                            );
+                                        })()}
                                </div>
                            </div>

--- a/src/lib/tools/clsx.ts
+++ b/src/lib/tools/clsx.ts
@ -0,0 +1,7 @@
+import { classnames } from "tss-react/tools/classnames";
+import type { Cx } from "tss-react";
+
+/** Drop in replacement for https://www.npmjs.com/package/clsx */
+export const clsx: Cx = (...args) => {
+    return classnames(args);
+};
--- a/src/lib/tools/useCssAndCx.ts
+++ b/src/lib/tools/useCssAndCx.ts
@ -1,11 +1,12 @@
-import { createMakeStyles } from "tss-react";
-
-const { useStyles } = createMakeStyles({
-    "useTheme": () => ({})
-});
+import { clsx as cx } from "./clsx";

+/**
+ * @deprecated: Use clsx instead.
+ * import { clsx } from "keycloakify/lib/tools/clsx";
+ * You can use clsx as cx.
+ * If you where using the css() function you can import
+ * it from @emotion/css: https://emotion.sh/docs/@emotion/css
+ */
 export function useCssAndCx() {
-    const { css, cx } = useStyles();
-
-    return { css, cx };
+    return { cx };
 }
--- a/yarn.lock
+++ b/yarn.lock
@ -104,9 +104,9 @@
    "@babel/types" "^7.19.0"

 "@babel/helper-plugin-utils@^7.18.6":
-  version "7.18.9"
-  resolved "https://registry.yarnpkg.com/@babel/helper-plugin-utils/-/helper-plugin-utils-7.18.9.tgz#4b8aea3b069d8cb8a72cdfe28ddf5ceca695ef2f"
-  integrity sha512-aBXPT3bmtLryXaoJLyYPXPlSD4p1ld9aYeR+sJNOZjJJGiOpb+fKfh3NkcCu7J54nUJwCERPBExCCpyCOHnu/w==
+  version "7.19.0"
+  resolved "https://registry.yarnpkg.com/@babel/helper-plugin-utils/-/helper-plugin-utils-7.19.0.tgz#4796bb14961521f0f8715990bee2fb6e51ce21bf"
+  integrity sha512-40Ryx7I8mT+0gaNxm8JGTZFUITNqdLAgdg0hXzeVZxVD6nFsdhQvip6v8dqkRHzsz1VFpFAaOCHNn0vKBL7Czw==

 "@babel/helper-simple-access@^7.18.6":
  version "7.18.6"
@ -173,9 +173,9 @@
    "@babel/helper-plugin-utils" "^7.18.6"

 "@babel/runtime@^7.12.5", "@babel/runtime@^7.18.3":
-  version "7.18.9"
-  resolved "https://registry.yarnpkg.com/@babel/runtime/-/runtime-7.18.9.tgz#b4fcfce55db3d2e5e080d2490f608a3b9f407f4a"
-  integrity sha512-lkqXDcvlFT5rvEjiu6+QYO+1GXrEHRo2LOtS7E4GtX5ESIZOgepqsZBVIj6Pv+a6zqsya9VCgiK1KAK4BvJDAw==
+  version "7.19.4"
+  resolved "https://registry.yarnpkg.com/@babel/runtime/-/runtime-7.19.4.tgz#a42f814502ee467d55b38dd1c256f53a7b885c78"
+  integrity sha512-EXpLCrk55f+cYqmHsSR+yD/0gAIMxxA9QK9lnQWzhMCvt+YmoBN7Zx94s++Kv0+unHk39vxNO8t+CMA2WSS3wA==
  dependencies:
    regenerator-runtime "^0.13.4"

@ -240,7 +240,7 @@
    source-map "^0.5.7"
    stylis "4.0.13"

-"@emotion/cache@*", "@emotion/cache@^11.10.0":
+"@emotion/cache@^11.10.0":
  version "11.10.3"
  resolved "https://registry.yarnpkg.com/@emotion/cache/-/cache-11.10.3.tgz#c4f67904fad10c945fea5165c3a5a0583c164b87"
  integrity sha512-Psmp/7ovAa8appWh3g51goxu/z3iVms7JXOreq136D8Bbn6dYraPnmL6mdM8GThEx9vwSn92Fz+mGSjBzN8UPQ==
@ -261,7 +261,7 @@
  resolved "https://registry.yarnpkg.com/@emotion/memoize/-/memoize-0.8.0.tgz#f580f9beb67176fa57aae70b08ed510e1b18980f"
  integrity sha512-G/YwXTkv7Den9mXDO7AhLWkE3q+I92B+VqAE+dYG4NGPaHZGvt3G8Q0p9vmE+sq7rTGphUbAvmQ9YpbfMQGGlA==

-"@emotion/react@^11.4.1":
+"@emotion/react@^11.10.4":
  version "11.10.4"
  resolved "https://registry.yarnpkg.com/@emotion/react/-/react-11.10.4.tgz#9dc6bccbda5d70ff68fdb204746c0e8b13a79199"
  integrity sha512-j0AkMpr6BL8gldJZ6XQsQ8DnS9TxEQu1R+OGmDZiWjBAJtCcbt0tS3I/YffoqHXxH6MjgI7KdMbYKw3MEiU9eA==
@ -275,7 +275,7 @@
    "@emotion/weak-memoize" "^0.3.0"
    hoist-non-react-statics "^3.3.1"

-"@emotion/serialize@*", "@emotion/serialize@^1.1.0":
+"@emotion/serialize@^1.1.0":
  version "1.1.0"
  resolved "https://registry.yarnpkg.com/@emotion/serialize/-/serialize-1.1.0.tgz#b1f97b1011b09346a40e9796c37a3397b4ea8ea8"
  integrity sha512-F1ZZZW51T/fx+wKbVlwsfchr5q97iW8brAnXmsskz4d0hVB4O3M/SiA3SaeH06x02lSNzkkQv+n3AX3kCXKSFA==
@ -301,7 +301,7 @@
  resolved "https://registry.yarnpkg.com/@emotion/use-insertion-effect-with-fallbacks/-/use-insertion-effect-with-fallbacks-1.0.0.tgz#ffadaec35dbb7885bd54de3fa267ab2f860294df"
  integrity sha512-1eEgUGmkaljiBnRMTdksDV1W4kUnmwgp7X9G8B++9GYwl1lUdqSndSriIrTJ0N7LQaoauY9JJ2yhiOYK5+NI4A==

-"@emotion/utils@*", "@emotion/utils@^1.2.0":
+"@emotion/utils@^1.2.0":
  version "1.2.0"
  resolved "https://registry.yarnpkg.com/@emotion/utils/-/utils-1.2.0.tgz#9716eaccbc6b5ded2ea5a90d65562609aab0f561"
  integrity sha512-sn3WH53Kzpw8oQ5mgMmIzzyAaH2ZqFEbozVVBSYp538E06OSE6ytOp7pRAjNQR+Q/orwqdQYJSe2m3hCOeznkw==
@ -763,7 +763,12 @@ concat-map@0.0.1:
  resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b"
  integrity sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==

-convert-source-map@^1.5.0, convert-source-map@^1.7.0:
+convert-source-map@^1.5.0:
+  version "1.9.0"
+  resolved "https://registry.yarnpkg.com/convert-source-map/-/convert-source-map-1.9.0.tgz#7faae62353fb4213366d0ca98358d22e8368b05f"
+  integrity sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==
+
+convert-source-map@^1.7.0:
  version "1.8.0"
  resolved "https://registry.yarnpkg.com/convert-source-map/-/convert-source-map-1.8.0.tgz#f3373c32d21b4d780dd8004514684fb791ca4369"
  integrity sha512-+OQdjP49zViI/6i7nIJpA8rAl4sV/JdPfU9nZs3VqOwGIgizICvuN2ru6fMd+4llL0tar18UYJXfZ/TWtmhUjA==
@ -967,14 +972,14 @@ event-emitter@^0.3.5:
    d "1"
    es5-ext "~0.10.14"

-evt@^2.4.6:
-  version "2.4.6"
-  resolved "https://registry.yarnpkg.com/evt/-/evt-2.4.6.tgz#79e242cd2f84c2ec0b8119478712f7af80368832"
-  integrity sha512-4kSu9YVklCeddEAu/UCzIISrxc5SAD82hX7gXjBox4yyrPNblYrmJr4GgTOOQpNXTGYci+UIpFUYikgZa9fyTQ==
+evt@^2.4.13:
+  version "2.4.13"
+  resolved "https://registry.yarnpkg.com/evt/-/evt-2.4.13.tgz#5ef873159ce62e099d58801a3e4b8e0f5b648017"
+  integrity sha512-haTVOsmjzk+28zpzvVwan9Zw2rLQF2izgi7BKjAPRzZAfcv+8scL0TpM8MzvGNKFYHiy+Bq3r6FYIIUPl9kt3A==
  dependencies:
    minimal-polyfills "^2.2.2"
-    run-exclusive "^2.2.16"
-    tsafe "^1.1.3"
+    run-exclusive "^2.2.18"
+    tsafe "^1.4.1"

 execa@^5.1.1:
  version "5.1.1"
@ -1634,15 +1639,15 @@ please-upgrade-node@^3.2.0:
  dependencies:
    semver-compare "^1.0.0"

-powerhooks@^0.20.23:
-  version "0.20.23"
-  resolved "https://registry.yarnpkg.com/powerhooks/-/powerhooks-0.20.23.tgz#52619405f63bf621c52f0cb944c58414734b618f"
-  integrity sha512-+44ltLJmvti6XZJuaRlfMbjX/2ZkJBw8CybkwDIh/GntOtyertWhbYa1k9QBy2deLKTcBj39Tx86/exIHoCcFA==
+powerhooks@^0.26.0:
+  version "0.26.0"
+  resolved "https://registry.yarnpkg.com/powerhooks/-/powerhooks-0.26.0.tgz#260f8e5c019ea117911c880bf3b371ecd09786df"
+  integrity sha512-FvoEuj340Jm9HPGV98gjDVVdlolaIYXvQ4Xg7fiNtYdeClAJk264uFHAwFo9isXP92OW2ksvy9wVMCwMhFUGGQ==
  dependencies:
-    evt "^2.4.6"
+    evt "^2.4.13"
    memoizee "^0.4.15"
    resize-observer-polyfill "^1.5.1"
-    tsafe "^1.1.3"
+    tsafe "^1.4.2"

 prettier@^2.3.0:
  version "2.7.1"
@ -1722,9 +1727,9 @@ readable-stream@~2.3.6:
    util-deprecate "~1.0.1"

 regenerator-runtime@^0.13.4:
-  version "0.13.9"
-  resolved "https://registry.yarnpkg.com/regenerator-runtime/-/regenerator-runtime-0.13.9.tgz#8925742a98ffd90814988d7566ad30ca3b263b52"
-  integrity sha512-p3VT+cOEgxFsRRA9X4lkI1E+k2/CtnKtU4gcxyaCUreilL/vqI6CdZ3wxVUx3UOUg+gnUOQQcRI7BmSI656MYA==
+  version "0.13.10"
+  resolved "https://registry.yarnpkg.com/regenerator-runtime/-/regenerator-runtime-0.13.10.tgz#ed07b19616bcbec5da6274ebc75ae95634bfc2ee"
+  integrity sha512-KepLsg4dU12hryUO7bp/axHAKvwGOCV0sGloQtpagJ12ai+ojVDqkeGSiRX1zlq+kjIMZ1t7gpze+26QqtdGqw==

 remark-parse@^9.0.0:
  version "9.0.0"
@ -1782,10 +1787,10 @@ rimraf@^3.0.2:
  dependencies:
    glob "^7.1.3"

-run-exclusive@^2.2.16:
-  version "2.2.16"
-  resolved "https://registry.yarnpkg.com/run-exclusive/-/run-exclusive-2.2.16.tgz#8fa30a23037760af296c47872a5f6b38f25accf0"
-  integrity sha512-cdYv2LDvaBCRnrqXrwDFs1SgzGTx0EIsiEReTpsprEDR6hRUVlSyjoMYu+rez4S1gpz6YbOQxcmYFMXJQknVnQ==
+run-exclusive@^2.2.18:
+  version "2.2.18"
+  resolved "https://registry.yarnpkg.com/run-exclusive/-/run-exclusive-2.2.18.tgz#ec930edc3a7044750dc827df9372bde8f610f586"
+  integrity sha512-TXr1Gkl1iEAOCCpBTRm/2m0+1KGjORcWpZZ+VGGTe7dYX8E4y8/fMvrHk0zf+kclec2R//tpvdBxgG0bDgaJfw==
  dependencies:
    minimal-polyfills "^2.2.1"

@ -1992,24 +1997,25 @@ trough@^1.0.0:
  resolved "https://registry.yarnpkg.com/trough/-/trough-1.0.5.tgz#b8b639cefad7d0bb2abd37d433ff8293efa5f406"
  integrity sha512-rvuRbTarPXmMb79SmzEp8aqXNKcK+y0XaB298IXueQ8I2PsrATcPBCSPyK/dDNa2iWOhKlfNnOjdAOTBU/nkFA==

-tsafe@^1.1.3:
-  version "1.1.3"
-  resolved "https://registry.yarnpkg.com/tsafe/-/tsafe-1.1.3.tgz#fa7c2ae7da689884292b70ee30febbca5c665d03"
-  integrity sha512-QQQoed5Acb7Qe/sjMwE/qg57mxD5MXqY5HcGN4i3QyhJiplpo79ABEZiOBvL1cRTOYIzeryWvWQ3xsotTA49MQ==
+tsafe@^1.4.1:
+  version "1.4.1"
+  resolved "https://registry.yarnpkg.com/tsafe/-/tsafe-1.4.1.tgz#59cdad8ac41babf88e56dcd1a683ae2fb145d059"
+  integrity sha512-3IDBalvf6SyvHFS14UiwCWzqdSdo+Q0k2J7DZyJYaHW/iraW9DJpaBKDJpry3yQs3o/t/A+oGaRW3iVt2lKxzA==
+
+tsafe@^1.4.2:
+  version "1.4.2"
+  resolved "https://registry.yarnpkg.com/tsafe/-/tsafe-1.4.2.tgz#1cc597f6e286ef8a64b918a0a6284bd04347e11f"
+  integrity sha512-KfP0PYzRjl1LY1DnJPNlD4a0tZSg4uUuZxI4aG04T+j7WJvKZbh1zpaukphhSmtoJMgX1RV8eZVKTEiH8wOGbA==

 tslib@^2.1.0:
  version "2.4.0"
  resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.4.0.tgz#7cecaa7f073ce680a05847aa77be941098f36dc3"
  integrity sha512-d6xOpEDfsi2CZVlPQzGeux8XMwLT9hssAsaPYExaQMuYskwb+x1x7J371tWlbBdWHroy99KnVB6qIkUbs5X3UQ==

-tss-react@^4.3.4:
-  version "4.3.4"
-  resolved "https://registry.yarnpkg.com/tss-react/-/tss-react-4.3.4.tgz#1e6d67f963562f4c232ec28ca4d90c8aac3a728b"
-  integrity sha512-PAEB9NxGtW2nEuPDm90WISi4nb9O+bmY/XyDKp17/CoPsoaW3UqaEi+gTjBmA/P65GCRuZhpZniTOkhLcTDQqg==
-  dependencies:
-    "@emotion/cache" "*"
-    "@emotion/serialize" "*"
-    "@emotion/utils" "*"
+tss-react@4.4.1-rc.0:
+  version "4.4.1-rc.0"
+  resolved "https://registry.yarnpkg.com/tss-react/-/tss-react-4.4.1-rc.0.tgz#96f9c2edcb9208ae39e845e6bafc9a50c9b96c66"
+  integrity sha512-ozltdpdDrB/6Ml6UpaL/eGwGZzTXXcHnJxwwO7mxcFaZnLaetbbbQHNUerRmqr21i9vgA6HFBAzOv9pa2PUsww==

 type-fest@^0.21.3:
  version "0.21.3"
Author	SHA1	Message	Date
renovate[bot]	516e84182f	fix(deps): update dependency powerhooks to ^0.26.0	2023-02-05 15:10:42 +00:00
garronej	a3a9853e18	bump version	2023-02-05 14:58:53 +01:00
garronej	08e26600fd	Use keycloakify as bundler by default	2023-02-05 14:58:38 +01:00
Joseph Garrone	7793c2c6ba	Update package.json	2023-02-05 14:41:32 +01:00
Joseph Garrone	9e826d16dd	Merge pull request #241 from lordvlad/mvn-begone Mvn begone addendum	2023-02-05 14:41:13 +01:00
Waldemar Reusch	80618bbd9c	Merge branch 'main' into mvn-begone	2023-02-05 13:36:52 +01:00
Waldemar Reusch	38ad47ea75	use hand-crafted promise, pipeline does not resolve properly	2023-02-05 13:32:24 +01:00
Waldemar Reusch	45ed359bef	fix keycloak theme source path for internal bundler	2023-02-05 13:31:34 +01:00
Waldemar Reusch	fcc26c3e7a	now that main is a promise, we shuold catch errors	2023-02-05 13:31:03 +01:00
Waldemar Reusch	d4ff6b1f40	fix: bundler fix missing directory	2023-02-05 12:59:05 +01:00
Waldemar Reusch	557de34eea	fix: bundler fix missing change	2023-02-05 12:56:01 +01:00
Waldemar Reusch	e034dc4d90	Merge branch 'mvn-begone' of github.com:lordvlad/keycloakify into mvn-begone * 'mvn-begone' of github.com:lordvlad/keycloakify: fix(deps): update garronej_modules_update Update README.md Rollback via update Bump version keycloak test script: use env to launch bash fix(deps): update dependency powerhooks to ^0.22.0 Update dependency powerhooks to ^0.21.0 Relase candidate fmt Update README.md Bump version Update src/bin/tools/downloadAndUnzip.ts Bump version #232 Bump version keycloak test script: use env to launch bash fix(deps): update dependency powerhooks to ^0.22.0 Update dependency powerhooks to ^0.21.0	2023-02-05 12:35:15 +01:00
Waldemar Reusch	cfbd1e5e4b	fix(bundler): fix type mismatch introduced in last-minute 'fixes'	2023-02-05 12:34:48 +01:00
garronej	0df661819f	Bump version	2023-02-04 20:51:06 +01:00
garronej	1a9f6d10d4	Actually run the top level await	2023-02-04 20:50:53 +01:00
garronej	a787215c95	Bump version	2023-02-04 20:39:38 +01:00
garronej	64ab400af5	Temporarly restore mvn as default bundler	2023-02-04 20:38:50 +01:00
garronej	a463878bf2	Bump version	2023-02-04 20:22:45 +01:00
Joseph Garrone	9f72024c61	Merge pull request #240 from InseeFrLab/mvn-begone Mvn begone	2023-02-04 19:47:36 +01:00
garronej	243fbd4dc9	Set the artifactId name in the build option	2023-02-04 19:36:42 +01:00
garronej	4e6a290693	Make new node based bundler the default	2023-02-04 18:02:39 +01:00
garronej	ac05d529ca	Minor fixes	2023-02-04 17:44:02 +01:00
Waldemar Reusch	b38d79004a	Merge branch 'main' into mvn-begone	2023-02-03 14:42:05 +01:00
Waldemar Reusch	f4a547df11	introduce options to choose a bundle strategy Pick from 'none', 'keycloakify' or 'mvn', default to 'mvn'. 'none' will not create a jar, 'keycloakify' will create a jar file using only tools available to native nodejs, no additional system library required. Choosing 'mvn' will behave as before, starting maven in a subprocess. The bundler can be chosen in `package.json` or via `KEYCLOAKIFY_BUNDLER` env var. This commit also adds `KEYCLOAKIFY_GROUP_ID` and `KEYCLOAKIFY_ARTIFACT_ID` env vars, which will be used to define group id and artifact id in pom.xml and pom.properties, if given.	2023-02-03 14:28:06 +01:00
Waldemar Reusch	2b87c35058	introduce utils for creating a jar archive	2023-02-03 14:06:24 +01:00
Waldemar Reusch	b11833e450	fix typo	2023-02-03 13:48:32 +01:00
renovate[bot]	fa8e119514	fix(deps): update garronej_modules_update	2023-02-01 15:16:03 +00:00
Joseph Garrone	677cb5c330	Update README.md	2023-01-27 15:46:30 +01:00
Joseph Garrone	6e74c79bfe	Merge pull request #233 from InseeFrLab/windows_compat Windows compat	2023-01-27 15:45:31 +01:00
Joseph Garrone	54474f5908	Merge branch 'main' into windows_compat	2023-01-27 15:45:25 +01:00
garronej	99cc0f519b	Rollback via update	2023-01-27 01:13:16 +01:00
Joseph Garrone	92a01f89ef	Bump version	2023-01-27 01:12:46 +01:00
rome-user	fd83a0c743	keycloak test script: use env to launch bash This minor change allows users to use the latest version of `bash` on Mac OS. `/bin/bash` is very old on Mac OS, and many users will have `bash` from MacPorts or Homebrew. This change allows such users to be able to use the newer `bash` installation.	2023-01-27 01:12:46 +01:00
renovate[bot]	988e46c875	fix(deps): update dependency powerhooks to ^0.22.0	2023-01-27 01:12:46 +01:00
renovate[bot]	f081c2fc20	Update dependency powerhooks to ^0.21.0	2023-01-27 01:12:46 +01:00
garronej	b4b376a1a5	Relase candidate	2023-01-27 01:09:11 +01:00
garronej	0db4179d47	fmt	2023-01-27 00:32:41 +01:00
Joseph Garrone	795b7c6234	Update README.md	2023-01-27 00:27:46 +01:00
Joseph Garrone	091b9a57f5	Bump version	2023-01-27 00:22:28 +01:00
Joseph Garrone	564e1422ac	Merge pull request #226 from lordvlad/fix-win-build windows compatibility	2023-01-27 00:20:12 +01:00
Waldemar Reusch	8ed4ed3fc4	Update src/bin/tools/downloadAndUnzip.ts	2023-01-26 22:29:51 +01:00
Waldemar Reusch	29fe4566a7	style: remove unused variable	2023-01-26 22:20:16 +01:00
Waldemar Reusch	ae3bfb28ed	refactor: follow suggesion to make methods read a bit more sync	2023-01-26 22:00:31 +01:00
garronej	14aab97d8a	Merge branch 'main' of https://github.com/InseeFrLab/keycloakify	2023-01-26 10:50:01 +01:00
garronej	52d7a47cd7	Bump version	2023-01-26 10:48:57 +01:00
garronej	f338dcbeed	#232	2023-01-26 10:48:24 +01:00
Joseph Garrone	dcec058a22	Bump version	2023-01-23 02:57:12 +01:00
Joseph Garrone	2bdc6b156b	Merge pull request #231 from rome-user/patch-1 keycloak test script: use env to launch bash	2023-01-23 02:56:32 +01:00
rome-user	84ca9e6b81	keycloak test script: use env to launch bash This minor change allows users to use the latest version of `bash` on Mac OS. `/bin/bash` is very old on Mac OS, and many users will have `bash` from MacPorts or Homebrew. This change allows such users to be able to use the newer `bash` installation.	2023-01-22 17:28:27 -08:00
Joseph Garrone	11cb0fd2db	Merge pull request #230 from InseeFrLab/renovate_main-garronej_modules_update Update dependency powerhooks to ^0.22.0 (main)	2023-01-18 00:58:38 +01:00
renovate[bot]	3f620ffb6f	fix(deps): update dependency powerhooks to ^0.22.0	2023-01-16 18:23:50 +00:00
Waldemar Reusch	1a0e05d073	rewrite download and unzip to use nodejs native methods	2023-01-16 14:42:20 +01:00
renovate[bot]	a4d2de23a1	Update dependency powerhooks to ^0.21.0	2023-01-16 02:38:07 +00:00
Waldemar Reusch	85cecc9811	fix(build): _properly_ fix bin paths	2023-01-12 22:56:02 +01:00
Waldemar Reusch	9899f742a8	fix(build): also rewrite bin paths in dist/package.json	2023-01-12 22:51:48 +01:00
Waldemar Reusch	b5484740b7	fix(build): remove dependency on *nix chown	2023-01-12 22:27:22 +01:00
garronej	016b15b437	Bump version	2023-01-10 09:05:33 +01:00
garronej	6fb936798e	https://github.com/InseeFrLab/keycloakify/issues/217#issuecomment-1376849781	2023-01-10 09:05:19 +01:00
garronej	a692b87843	Bump version	2023-01-08 15:01:12 +01:00
Joseph Garrone	19663885a4	Merge pull request #222 from InseeFrLab/pr/lordvlad/221 Pr/lordvlad/221	2023-01-08 14:59:22 +01:00
garronej	49b87777f9	Fmt	2023-01-08 14:57:18 +01:00
Waldemar Reusch	d4523bb1e6	Merge branch 'main' into patch-1	2023-01-08 12:22:14 +01:00
Waldemar Reusch	e3200899e2	fix: replace rm system calls with nodejs native functions; closes #219	2023-01-08 12:19:41 +01:00
garronej	36c7a1ab9e	Bump version	2023-01-08 00:14:01 +01:00
Joseph Garrone	c54fbd5eca	Merge pull request #218 from pedrodsRocha1/improve-secure-login-flow fix - handle username and password login errors the same way	2023-01-08 00:03:16 +01:00
Pedro Dos Santos	bbe828071e	fix - handle username and password login errors the same	2023-01-06 15:41:01 +01:00
renovate[bot]	23f6c7db00	Update garronej_modules_update	2022-11-29 18:31:14 +00:00
renovate[bot]	b1ea9e7a71	Update dependency powerhooks to ^0.20.27	2022-11-16 05:21:45 +00:00
renovate[bot]	fb71d0e272	Update dependency powerhooks to ^0.20.26	2022-11-13 22:11:59 +00:00
garronej	fa72a29999	Bump version	2022-11-11 15:49:05 +01:00
garronej	af77b31d54	Update default test container to Keycloak 20.0.1	2022-11-11 15:48:32 +01:00
renovate[bot]	8280dace26	Update garronej_modules_update	2022-10-25 03:18:01 +00:00
garronej	ecaf1c7b7c	Bump version	2022-10-16 00:51:11 +02:00
garronej	8702ec29a8	Drop dependency to @emotion/react	2022-10-16 00:49:49 +02:00
garronej	d8206434bc	Bump version	2022-10-15 15:39:56 +02:00
garronej	c71c2a8710	Fix breaking change of 6.8	2022-10-15 15:39:32 +02:00