keycloakify 11.7.4 → 11.8.0

package/bin/97.index.js

@@ -3,30 +3,162 @@ exports.id = 97;
 exports.ids = [97];
 exports.modules = {
 
-/***/ 98097:
+/***/ 64097:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
+// ESM COMPAT FLAG
 __webpack_require__.r(__webpack_exports__);
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   "command": () => (/* binding */ command)
-/* harmony export */ });
-/* harmony import */ var _tools_getThisCodebaseRootDirPath__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(58822);
-/* harmony import */ var cli_select__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(99398);
-/* harmony import */ var cli_select__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(cli_select__WEBPACK_IMPORTED_MODULE_1__);
-/* harmony import */ var _shared_constants__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(173);
-/* harmony import */ var tsafe_capitalize__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(14899);
-/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(57147);
-/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(fs__WEBPACK_IMPORTED_MODULE_3__);
-/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(71017);
-/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_4__);
-/* harmony import */ var _tools_kebabCaseToSnakeCase__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(17192);
-/* harmony import */ var tsafe_assert__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(29041);
-/* harmony import */ var chalk__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(78818);
-/* harmony import */ var chalk__WEBPACK_IMPORTED_MODULE_6___default = /*#__PURE__*/__webpack_require__.n(chalk__WEBPACK_IMPORTED_MODULE_6__);
-/* harmony import */ var _tools_runPrettier__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(48433);
-/* harmony import */ var _shared_customHandler_delegate__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(72138);
 
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "command": () => (/* reexport */ command)
+});
 
+// EXTERNAL MODULE: ./node_modules/tsafe/esm/exclude.mjs
+var exclude = __webpack_require__(83101);
+// EXTERNAL MODULE: ./dist/bin/shared/constants.js
+var constants = __webpack_require__(173);
+// EXTERNAL MODULE: ./dist/bin/tools/SemVer.js
+var SemVer = __webpack_require__(12171);
+// EXTERNAL MODULE: ./node_modules/tsafe/esm/assert.mjs + 1 modules
+var assert = __webpack_require__(29041);
+// EXTERNAL MODULE: external "fs"
+var external_fs_ = __webpack_require__(57147);
+var external_fs_default = /*#__PURE__*/__webpack_require__.n(external_fs_);
+// EXTERNAL MODULE: external "path"
+var external_path_ = __webpack_require__(71017);
+// EXTERNAL MODULE: external "child_process"
+var external_child_process_ = __webpack_require__(32081);
+var external_child_process_default = /*#__PURE__*/__webpack_require__.n(external_child_process_);
+// EXTERNAL MODULE: ./node_modules/chalk/source/index.js
+var source = __webpack_require__(78818);
+var source_default = /*#__PURE__*/__webpack_require__.n(source);
+// EXTERNAL MODULE: ./node_modules/chokidar/index.js
+var chokidar = __webpack_require__(42677);
+// EXTERNAL MODULE: ./node_modules/powerhooks/tools/waitForDebounce.js
+var tools_waitForDebounce = __webpack_require__(18721);
+// EXTERNAL MODULE: ./dist/bin/tools/getThisCodebaseRootDirPath.js
+var getThisCodebaseRootDirPath = __webpack_require__(58822);
+// EXTERNAL MODULE: ./dist/bin/tools/getAbsoluteAndInOsFormatPath.js
+var getAbsoluteAndInOsFormatPath = __webpack_require__(84794);
+// EXTERNAL MODULE: ./node_modules/cli-select/dist/index.js
+var dist = __webpack_require__(99398);
+var dist_default = /*#__PURE__*/__webpack_require__.n(dist);
+// EXTERNAL MODULE: ./node_modules/run-exclusive/lib/runExclusive.js
+var runExclusive = __webpack_require__(81708);
+// EXTERNAL MODULE: external "fs/promises"
+var promises_ = __webpack_require__(73292);
+var promises_default = /*#__PURE__*/__webpack_require__.n(promises_);
+// EXTERNAL MODULE: ./node_modules/yauzl/index.js
+var yauzl = __webpack_require__(78781);
+// EXTERNAL MODULE: external "stream"
+var external_stream_ = __webpack_require__(12781);
+var external_stream_default = /*#__PURE__*/__webpack_require__.n(external_stream_);
+// EXTERNAL MODULE: ./node_modules/evt/tools/Deferred.js
+var Deferred = __webpack_require__(50689);
+// EXTERNAL MODULE: ./dist/bin/tools/fs.existsAsync.js
+var fs_existsAsync = __webpack_require__(43765);
+;// CONCATENATED MODULE: ./dist/bin/tools/extractArchive.js
+
+
+
+
+
+
+
+async function extractArchive(params) {
+    const { archiveFilePath, onArchiveFile } = params;
+    const zipFile = await new Promise((resolve, reject) => {
+        yauzl.open(archiveFilePath, { lazyEntries: true }, async (error, zipFile) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve(zipFile);
+        });
+    });
+    const dDone = new Deferred.Deferred();
+    zipFile.once("end", () => {
+        zipFile.close();
+        dDone.resolve();
+    });
+    const writeFile = async (entry, params) => {
+        const { filePath, modifiedData } = params;
+        {
+            const dirPath = (0,external_path_.dirname)(filePath);
+            if (!(await (0,fs_existsAsync/* existsAsync */.o)(dirPath))) {
+                await promises_default().mkdir(dirPath, { recursive: true });
+            }
+        }
+        if (modifiedData !== undefined) {
+            await promises_default().writeFile(filePath, modifiedData);
+            return;
+        }
+        const readStream = await new Promise(resolve => zipFile.openReadStream(entry, async (error, readStream) => {
+            if (error) {
+                dDone.reject(error);
+                return;
+            }
+            resolve(readStream);
+        }));
+        const dDoneWithFile = new Deferred.Deferred();
+        external_stream_default().pipeline(readStream, external_fs_default().createWriteStream(filePath), error => {
+            if (error) {
+                dDone.reject(error);
+                return;
+            }
+            dDoneWithFile.resolve();
+        });
+        await dDoneWithFile.pr;
+    };
+    const readFile = (entry) => new Promise(resolve => zipFile.openReadStream(entry, async (error, readStream) => {
+        if (error) {
+            dDone.reject(error);
+            return;
+        }
+        const chunks = [];
+        readStream.on("data", chunk => {
+            chunks.push(chunk);
+        });
+        readStream.on("end", () => {
+            resolve(Buffer.concat(chunks));
+        });
+        readStream.on("error", error => {
+            dDone.reject(error);
+        });
+    }));
+    zipFile.on("entry", async (entry) => {
+        handle_file: {
+            // NOTE: Skip directories
+            if (entry.fileName.endsWith("/")) {
+                break handle_file;
+            }
+            let hasEarlyExitBeenCalled = false;
+            await onArchiveFile({
+                relativeFilePathInArchive: entry.fileName.split("/").join(external_path_.sep),
+                readFile: () => readFile(entry),
+                writeFile: params => writeFile(entry, params),
+                earlyExit: () => {
+                    hasEarlyExitBeenCalled = true;
+                }
+            });
+            if (hasEarlyExitBeenCalled) {
+                zipFile.close();
+                dDone.resolve();
+                return;
+            }
+        }
+        zipFile.readEntry();
+    });
+    zipFile.readEntry();
+    await dDone.pr;
+}
+//# sourceMappingURL=extractArchive.js.map
+// EXTERNAL MODULE: ./node_modules/tsafe/esm/id.mjs
+var id = __webpack_require__(38469);
+// EXTERNAL MODULE: ./node_modules/zod/lib/index.mjs
+var lib = __webpack_require__(52300);
+;// CONCATENATED MODULE: ./dist/bin/start-keycloak/appBuild.js
 
 
 
@@ -36,188 +168,1982 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
-async function command(params) {
+
+(0,assert/* assert */.h)();
+async function appBuild(params) {
+    var _a;
+    const { buildContext } = params;
+    const { parsedPackageJson } = (() => {
+        const zParsedPackageJson = (() => {
+            const zTargetType = lib.z.object({
+                scripts: lib.z.record(lib.z.string()).optional()
+            });
+            (0,assert/* assert */.h)();
+            return (0,id.id)(zTargetType);
+        })();
+        const parsedPackageJson = JSON.parse(external_fs_.readFileSync(buildContext.packageJsonFilePath).toString("utf8"));
+        zParsedPackageJson.parse(parsedPackageJson);
+        (0,assert/* assert */.h)((0,assert.is)(parsedPackageJson));
+        return { parsedPackageJson };
+    })();
+    const entries = Object.entries((_a = parsedPackageJson.scripts) !== null && _a !== void 0 ? _a : {}).filter(([, scriptCommand]) => scriptCommand.includes("keycloakify build"));
+    if (entries.length === 0) {
+        console.log(source_default().red([
+            `You should have a script in your package.json at ${(0,external_path_.relative)(process.cwd(), (0,external_path_.dirname)(buildContext.packageJsonFilePath))}`,
+            `that includes the 'keycloakify build' command`
+        ].join(" ")));
+        process.exit(-1);
+    }
+    const entry = entries.length === 1
+        ? entries[0]
+        : entries.find(([scriptName]) => scriptName === "build-keycloak-theme");
+    if (entry === undefined) {
+        console.log(source_default().red("There's multiple candidate script for building your app, name one 'build-keycloak-theme'"));
+        process.exit(-1);
+    }
+    const [scriptName, scriptCommand] = entry;
+    const { appBuildSubCommands } = (() => {
+        const appBuildSubCommands = [];
+        for (const subCmd of scriptCommand.split("&&").map(s => s.trim())) {
+            if (subCmd.includes("keycloakify build")) {
+                break;
+            }
+            appBuildSubCommands.push(subCmd);
+        }
+        return { appBuildSubCommands };
+    })();
+    if (appBuildSubCommands.length === 0) {
+        console.log(source_default().red(`Your ${scriptName} script should look like "... && keycloakify build ..."`));
+        process.exit(-1);
+    }
+    common_case: {
+        if (appBuildSubCommands.length !== 1) {
+            break common_case;
+        }
+        const [appBuildSubCommand] = appBuildSubCommands;
+        const isNpmRunBuild = (() => {
+            for (const packageManager of ["npm", "yarn", "pnpm", "bun", "deno"]) {
+                for (const doUseRun of [true, false]) {
+                    if (`${packageManager}${doUseRun ? " run " : " "}build` ===
+                        appBuildSubCommand) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        })();
+        if (!isNpmRunBuild) {
+            break common_case;
+        }
+        const { scripts } = parsedPackageJson;
+        (0,assert/* assert */.h)(scripts !== undefined);
+        const buildCmd = scripts.build;
+        if (buildCmd !== "tsc && vite build") {
+            break common_case;
+        }
+        if (scripts.prebuild !== undefined) {
+            break common_case;
+        }
+        if (scripts.postbuild !== undefined) {
+            break common_case;
+        }
+        const dIsSuccess = new Deferred.Deferred();
+        console.log(source_default().blue("$ npx vite build"));
+        const child = external_child_process_.spawn("npx", ["vite", "build"], {
+            cwd: buildContext.projectDirPath,
+            shell: true
+        });
+        child.stdout.on("data", data => {
+            if (data.toString("utf8").includes("gzip:")) {
+                return;
+            }
+            process.stdout.write(data);
+        });
+        child.stderr.on("data", data => process.stderr.write(data));
+        child.on("exit", code => dIsSuccess.resolve(code === 0));
+        const isSuccess = await dIsSuccess.pr;
+        return { isAppBuildSuccess: isSuccess };
+    }
+    let commandCwd = (0,external_path_.dirname)(buildContext.packageJsonFilePath);
+    for (const subCommand of appBuildSubCommands) {
+        const dIsSuccess = new Deferred.Deferred();
+        const [command, ...args] = subCommand.split(" ");
+        if (command === "cd") {
+            const [pathIsh] = args;
+            commandCwd = (0,getAbsoluteAndInOsFormatPath/* getAbsoluteAndInOsFormatPath */.c)({
+                pathIsh,
+                cwd: commandCwd
+            });
+            continue;
+        }
+        console.log(source_default().blue(`$ ${subCommand}`));
+        const child = external_child_process_.spawn(command, args, {
+            cwd: commandCwd,
+            env: Object.assign(Object.assign({}, process.env), { PATH: (() => {
+                    var _a;
+                    const separator = external_path_.sep === "/" ? ":" : ";";
+                    return [
+                        (0,external_path_.join)((0,external_path_.dirname)(buildContext.packageJsonFilePath), "node_modules", ".bin"),
+                        ...((_a = process.env.PATH) !== null && _a !== void 0 ? _a : "").split(separator)
+                    ].join(separator);
+                })() }),
+            shell: true
+        });
+        child.stdout.on("data", data => process.stdout.write(data));
+        child.stderr.on("data", data => process.stderr.write(data));
+        child.on("exit", code => dIsSuccess.resolve(code === 0));
+        const isSuccess = await dIsSuccess.pr;
+        if (!isSuccess) {
+            return { isAppBuildSuccess: false };
+        }
+    }
+    return { isAppBuildSuccess: true };
+}
+//# sourceMappingURL=appBuild.js.map
+;// CONCATENATED MODULE: ./dist/bin/start-keycloak/keycloakifyBuild.js
+
+
+
+
+
+(0,assert/* assert */.h)();
+async function keycloakifyBuild(params) {
+    const { buildForKeycloakMajorVersionNumber, buildContext } = params;
+    const dResult = new Deferred.Deferred();
+    console.log(source_default().blue("$ npx keycloakify build"));
+    const child = external_child_process_.spawn("npx", ["keycloakify", "build"], {
+        cwd: buildContext.projectDirPath,
+        env: Object.assign(Object.assign({}, process.env), { [constants/* BUILD_FOR_KEYCLOAK_MAJOR_VERSION_ENV_NAME */.ac]: `${buildForKeycloakMajorVersionNumber}` }),
+        shell: true
+    });
+    child.stdout.on("data", data => process.stdout.write(data));
+    child.stderr.on("data", data => process.stderr.write(data));
+    child.on("exit", code => dResult.resolve({ isSuccess: code === 0 }));
+    const { isSuccess } = await dResult.pr;
+    return { isKeycloakifyBuildSuccess: isSuccess };
+}
+//# sourceMappingURL=keycloakifyBuild.js.map
+// EXTERNAL MODULE: ./dist/bin/tools/isInside.js
+var isInside = __webpack_require__(90665);
+;// CONCATENATED MODULE: ./dist/bin/tools/fs.rm.js
+
+
+
+/**
+ * Polyfill of fs.rm(dirPath, { "recursive": true })
+ * For older version of Node
+ */
+async function rm(dirPath, options) {
+    if (SemVer/* SemVer.compare */.h.compare(SemVer/* SemVer.parse */.h.parse(process.version), SemVer/* SemVer.parse */.h.parse("14.14.0")) > 0) {
+        return promises_.rm(dirPath, options);
+    }
+    const { force = true } = options;
+    if (force && !(await checkDirExists(dirPath))) {
+        return;
+    }
+    const removeDir_rec = async (dirPath) => Promise.all((await promises_.readdir(dirPath)).map(async (basename) => {
+        const fileOrDirpath = (0,external_path_.join)(dirPath, basename);
+        if ((await promises_.lstat(fileOrDirpath)).isDirectory()) {
+            await removeDir_rec(fileOrDirpath);
+        }
+        else {
+            await promises_.unlink(fileOrDirpath);
+        }
+    }));
+    await removeDir_rec(dirPath);
+}
+async function checkDirExists(dirPath) {
+    try {
+        await promises_.access(dirPath, promises_.constants.F_OK);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+//# sourceMappingURL=fs.rm.js.map
+// EXTERNAL MODULE: ./node_modules/make-fetch-happen/lib/index.js
+var make_fetch_happen_lib = __webpack_require__(9525);
+var lib_default = /*#__PURE__*/__webpack_require__.n(make_fetch_happen_lib);
+// EXTERNAL MODULE: external "crypto"
+var external_crypto_ = __webpack_require__(6113);
+;// CONCATENATED MODULE: ./dist/bin/tools/downloadAndExtractArchive.js
+
+
+
+
+
+
+
+
+async function downloadAndExtractArchive(params) {
+    var _a;
+    const { url, uniqueIdOfOnArchiveFile, onArchiveFile, cacheDirPath, fetchOptions } = params;
+    const archiveFileBasename = url.split("?")[0].split("/").reverse()[0];
+    const archiveFilePath = (0,external_path_.join)(cacheDirPath, archiveFileBasename);
+    download: {
+        await (0,promises_.mkdir)((0,external_path_.dirname)(archiveFilePath), { recursive: true });
+        if (await (0,fs_existsAsync/* existsAsync */.o)(archiveFilePath)) {
+            const isDownloaded = await SuccessTracker.getIsDownloaded({
+                cacheDirPath,
+                archiveFileBasename
+            });
+            if (isDownloaded) {
+                break download;
+            }
+            await (0,promises_.unlink)(archiveFilePath);
+            await SuccessTracker.removeFromDownloaded({
+                cacheDirPath,
+                archiveFileBasename
+            });
+        }
+        const response = await lib_default()(url, fetchOptions);
+        (_a = response.body) === null || _a === void 0 ? void 0 : _a.setMaxListeners(Number.MAX_VALUE);
+        (0,assert/* assert */.h)(typeof response.body !== "undefined" && response.body != null);
+        await (0,promises_.writeFile)(archiveFilePath, response.body);
+        await SuccessTracker.markAsDownloaded({
+            cacheDirPath,
+            archiveFileBasename
+        });
+    }
+    const extractDirBasename = `${archiveFileBasename.replace(/\.([^.]+)$/, (...[, ext]) => `_${ext}`)}_${uniqueIdOfOnArchiveFile}_${external_crypto_.createHash("sha256")
+        .update(onArchiveFile.toString())
+        .digest("hex")
+        .substring(0, 5)}`;
+    await Promise.all((await (0,promises_.readdir)(cacheDirPath))
+        .filter((() => {
+        const prefix = extractDirBasename
+            .split("_")
+            .reverse()
+            .slice(1)
+            .reverse()
+            .join("_");
+        return basename => basename !== extractDirBasename && basename.startsWith(prefix);
+    })())
+        .map(async (extractDirBasename) => {
+        await rm((0,external_path_.join)(cacheDirPath, extractDirBasename), {
+            recursive: true
+        });
+        await SuccessTracker.removeFromExtracted({
+            cacheDirPath,
+            extractDirBasename
+        });
+    }));
+    const extractedDirPath = (0,external_path_.join)(cacheDirPath, extractDirBasename);
+    extract_and_transform: {
+        if (await (0,fs_existsAsync/* existsAsync */.o)(extractedDirPath)) {
+            const isExtracted = await SuccessTracker.getIsExtracted({
+                cacheDirPath,
+                extractDirBasename
+            });
+            if (isExtracted) {
+                break extract_and_transform;
+            }
+            await rm(extractedDirPath, { recursive: true });
+            await SuccessTracker.removeFromExtracted({
+                cacheDirPath,
+                extractDirBasename
+            });
+        }
+        await extractArchive({
+            archiveFilePath,
+            onArchiveFile: async ({ relativeFilePathInArchive, readFile, writeFile }) => onArchiveFile({
+                fileRelativePath: relativeFilePathInArchive,
+                readFile,
+                writeFile: ({ fileRelativePath, modifiedData }) => writeFile({
+                    filePath: (0,external_path_.join)(extractedDirPath, fileRelativePath),
+                    modifiedData
+                })
+            })
+        });
+        await SuccessTracker.markAsExtracted({
+            cacheDirPath,
+            extractDirBasename
+        });
+    }
+    return { extractedDirPath, archiveFilePath };
+}
+var SuccessTracker;
+(function (SuccessTracker) {
+    async function read(params) {
+        const { cacheDirPath } = params;
+        const filePath = (0,external_path_.join)(cacheDirPath, "downloadAndExtractArchive.json");
+        if (!(await (0,fs_existsAsync/* existsAsync */.o)(filePath))) {
+            return { archiveFileBasenames: [], extractDirBasenames: [] };
+        }
+        return JSON.parse((await (0,promises_.readFile)(filePath)).toString("utf8"));
+    }
+    async function write(params) {
+        const { cacheDirPath, successTracker } = params;
+        const filePath = (0,external_path_.join)(cacheDirPath, "downloadAndExtractArchive.json");
+        {
+            const dirPath = (0,external_path_.dirname)(filePath);
+            if (!(await (0,fs_existsAsync/* existsAsync */.o)(dirPath))) {
+                await (0,promises_.mkdir)(dirPath, { recursive: true });
+            }
+        }
+        await (0,promises_.writeFile)(filePath, JSON.stringify(successTracker));
+    }
+    async function markAsDownloaded(params) {
+        const { cacheDirPath, archiveFileBasename } = params;
+        const successTracker = await read({ cacheDirPath });
+        successTracker.archiveFileBasenames.push(archiveFileBasename);
+        await write({ cacheDirPath, successTracker });
+    }
+    SuccessTracker.markAsDownloaded = markAsDownloaded;
+    async function getIsDownloaded(params) {
+        const { cacheDirPath, archiveFileBasename } = params;
+        const successTracker = await read({ cacheDirPath });
+        return successTracker.archiveFileBasenames.includes(archiveFileBasename);
+    }
+    SuccessTracker.getIsDownloaded = getIsDownloaded;
+    async function removeFromDownloaded(params) {
+        const { cacheDirPath, archiveFileBasename } = params;
+        const successTracker = await read({ cacheDirPath });
+        successTracker.archiveFileBasenames = successTracker.archiveFileBasenames.filter(basename => basename !== archiveFileBasename);
+        await write({ cacheDirPath, successTracker });
+    }
+    SuccessTracker.removeFromDownloaded = removeFromDownloaded;
+    async function markAsExtracted(params) {
+        const { cacheDirPath, extractDirBasename } = params;
+        const successTracker = await read({ cacheDirPath });
+        successTracker.extractDirBasenames.push(extractDirBasename);
+        await write({ cacheDirPath, successTracker });
+    }
+    SuccessTracker.markAsExtracted = markAsExtracted;
+    async function getIsExtracted(params) {
+        const { cacheDirPath, extractDirBasename } = params;
+        const successTracker = await read({ cacheDirPath });
+        return successTracker.extractDirBasenames.includes(extractDirBasename);
+    }
+    SuccessTracker.getIsExtracted = getIsExtracted;
+    async function removeFromExtracted(params) {
+        const { cacheDirPath, extractDirBasename } = params;
+        const successTracker = await read({ cacheDirPath });
+        successTracker.extractDirBasenames = successTracker.extractDirBasenames.filter(basename => basename !== extractDirBasename);
+        await write({ cacheDirPath, successTracker });
+    }
+    SuccessTracker.removeFromExtracted = removeFromExtracted;
+})(SuccessTracker || (SuccessTracker = {}));
+//# sourceMappingURL=downloadAndExtractArchive.js.map
+;// CONCATENATED MODULE: ./dist/bin/start-keycloak/startViteDevServer.js
+
+
+
+
+
+(0,assert/* assert */.h)();
+function startViteDevServer(params) {
+    const { buildContext } = params;
+    console.log(source_default().blue(`$ npx vite dev`));
+    const child = external_child_process_.spawn("npx", ["vite", "dev"], {
+        cwd: buildContext.projectDirPath,
+        env: Object.assign(Object.assign({}, process.env), { [constants/* VITE_PLUGIN_SUB_SCRIPTS_ENV_NAMES.READ_KC_CONTEXT_FROM_URL */.TE.READ_KC_CONTEXT_FROM_URL]: "true" }),
+        shell: true
+    });
+    child.stdout.on("data", data => {
+        if (!data.toString("utf8").includes("[vite] hmr")) {
+            return;
+        }
+        process.stdout.write(data);
+    });
+    child.stderr.on("data", data => process.stderr.write(data));
+    const dPort = new Deferred.Deferred();
+    {
+        const onData = (data) => {
+            //Local:   http://localhost:8083/
+            const match = data
+                .toString("utf8")
+                .replace(/\x1b[[0-9;]*m/g, "")
+                .match(/Local:\s*http:\/\/(?:localhost|127\.0\.0\.1):(\d+)\//);
+            if (match === null) {
+                return;
+            }
+            child.stdout.off("data", onData);
+            const port = parseInt(match[1]);
+            (0,assert/* assert */.h)(!isNaN(port));
+            dPort.resolve(port);
+        };
+        child.stdout.on("data", onData);
+    }
+    return dPort.pr.then(port => ({ port }));
+}
+//# sourceMappingURL=startViteDevServer.js.map
+// EXTERNAL MODULE: ./node_modules/tsafe/esm/is.mjs
+var is = __webpack_require__(16453);
+;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/ParsedRealmJson/ParsedRealmJson.js
+
+
+
+const zParsedRealmJson = (() => {
+    const zTargetType = lib.z.object({
+        realm: lib.z.string(),
+        loginTheme: lib.z.string().optional(),
+        accountTheme: lib.z.string().optional(),
+        adminTheme: lib.z.string().optional(),
+        emailTheme: lib.z.string().optional(),
+        eventsListeners: lib.z.array(lib.z.string()),
+        users: lib.z.array(lib.z.object({
+            id: lib.z.string(),
+            email: lib.z.string(),
+            username: lib.z.string(),
+            credentials: lib.z.array(lib.z.object({
+                type: lib.z.string()
+            })),
+            clientRoles: lib.z.record(lib.z.array(lib.z.string())).optional()
+        })),
+        roles: lib.z.object({
+            client: lib.z.record(lib.z.array(lib.z.object({
+                name: lib.z.string(),
+                containerId: lib.z.string()
+            })))
+        }),
+        clients: lib.z.array(lib.z.object({
+            id: lib.z.string(),
+            clientId: lib.z.string(),
+            baseUrl: lib.z.string().optional(),
+            redirectUris: lib.z.array(lib.z.string()).optional(),
+            webOrigins: lib.z.array(lib.z.string()).optional(),
+            attributes: lib.z.object({
+                "post.logout.redirect.uris": lib.z.string().optional()
+            })
+                .optional(),
+            protocol: lib.z.string().optional(),
+            protocolMappers: lib.z.array(lib.z.object({
+                id: lib.z.string(),
+                name: lib.z.string(),
+                protocol: lib.z.string(),
+                protocolMapper: lib.z.string(),
+                consentRequired: lib.z.boolean(),
+                config: lib.z.record(lib.z.string()).optional()
+            }))
+                .optional()
+        }))
+    });
+    assert/* assert */.h;
+    return (0,id.id)(zTargetType);
+})();
+//# sourceMappingURL=ParsedRealmJson.js.map
+;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/ParsedRealmJson/readRealmJsonFile.js
+
+
+
+
+function readRealmJsonFile(params) {
+    const { realmJsonFilePath } = params;
+    const parsedRealmJson = JSON.parse(external_fs_.readFileSync(realmJsonFilePath).toString("utf8"));
+    zParsedRealmJson.parse(parsedRealmJson);
+    (0,assert/* assert */.h)((0,is.is)(parsedRealmJson));
+    return parsedRealmJson;
+}
+//# sourceMappingURL=readRealmJsonFile.js.map
+;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/defaultConfig/defaultConfig.js
+
+
+
+
+
+
+function getDefaultRealmJsonFilePath(params) {
+    const { keycloakMajorVersionNumber } = params;
+    return (0,external_path_.join)((0,getThisCodebaseRootDirPath/* getThisCodebaseRootDirPath */.e)(), "src", "bin", "start-keycloak", "realmConfig", "defaultConfig", `realm-kc-${keycloakMajorVersionNumber}.json`);
+}
+const { getSupportedKeycloakMajorVersions } = (() => {
+    let cache = undefined;
+    function getSupportedKeycloakMajorVersions() {
+        if (cache !== undefined) {
+            return cache;
+        }
+        cache = external_fs_.readdirSync((0,external_path_.dirname)(getDefaultRealmJsonFilePath({ keycloakMajorVersionNumber: 0 })))
+            .map(fileBasename => {
+            const match = fileBasename.match(/^realm-kc-(\d+)\.json$/);
+            if (match === null) {
+                return undefined;
+            }
+            const n = parseInt(match[1]);
+            (0,assert/* assert */.h)(!isNaN(n));
+            return n;
+        })
+            .filter((0,exclude/* exclude */.D)(undefined))
+            .sort((a, b) => b - a);
+        return cache;
+    }
+    return { getSupportedKeycloakMajorVersions };
+})();
+function getDefaultConfig(params) {
+    const { keycloakMajorVersionNumber } = params;
+    (0,assert/* assert */.h)(getSupportedKeycloakMajorVersions().includes(keycloakMajorVersionNumber), `We do not have a default config for Keycloak ${keycloakMajorVersionNumber}`);
+    return readRealmJsonFile({
+        realmJsonFilePath: getDefaultRealmJsonFilePath({
+            keycloakMajorVersionNumber
+        })
+    });
+}
+//# sourceMappingURL=defaultConfig.js.map
+;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/defaultConfig/index.js
+
+//# sourceMappingURL=index.js.map
+// EXTERNAL MODULE: ./dist/bin/tools/readThisNpmPackageVersion.js
+var readThisNpmPackageVersion = __webpack_require__(64795);
+;// CONCATENATED MODULE: ./dist/bin/start-keycloak/getSupportedDockerImageTags.js
+
+
+
+
+
+
+
+
+
+
+
+assert/* assert */.h;
+async function getSupportedDockerImageTags(params) {
     const { buildContext } = params;
-    const { hasBeenHandled } = (0,_shared_customHandler_delegate__WEBPACK_IMPORTED_MODULE_8__/* .maybeDelegateCommandToCustomHandler */ .q)({
-        commandName: "add-story",
+    {
+        const result = await getCachedValue({ cacheDirPath: buildContext.cacheDirPath });
+        if (result !== undefined) {
+            return result;
+        }
+    }
+    const tags_queryResponse = [];
+    await (async function callee(url) {
+        const r = await lib_default()(url, buildContext.fetchOptions);
+        await Promise.all([
+            (async () => {
+                tags_queryResponse.push(...lib.z.object({
+                    tags: lib.z.array(lib.z.string())
+                })
+                    .parse(await r.json()).tags);
+            })(),
+            (async () => {
+                const link = r.headers.get("link");
+                if (link === null) {
+                    return;
+                }
+                const split = link.split(";").map(s => s.trim());
+                (0,assert/* assert */.h)(split.length === 2);
+                (0,assert/* assert */.h)(split[1] === 'rel="next"');
+                const match = split[0].match(/^<(.+)>$/);
+                (0,assert/* assert */.h)(match !== null);
+                const nextUrl = new URL(url).origin + match[1];
+                await callee(nextUrl);
+            })()
+        ]);
+    })("https://quay.io/v2/keycloak/keycloak/tags/list");
+    const supportedKeycloakMajorVersions = getSupportedKeycloakMajorVersions();
+    const allSupportedTags_withVersion = tags_queryResponse
+        .map(tag => ({
+        tag,
+        version: (() => {
+            if (tag.includes("-")) {
+                return undefined;
+            }
+            let version;
+            try {
+                version = SemVer/* SemVer.parse */.h.parse(tag);
+            }
+            catch (_a) {
+                return undefined;
+            }
+            if (tag.split(".").length !== 3) {
+                return undefined;
+            }
+            if (!supportedKeycloakMajorVersions.includes(version.major)) {
+                return undefined;
+            }
+            return version;
+        })()
+    }))
+        .map(({ tag, version }) => (version === undefined ? undefined : { tag, version }))
+        .filter((0,exclude/* exclude */.D)(undefined))
+        .sort(({ version: a }, { version: b }) => SemVer/* SemVer.compare */.h.compare(b, a));
+    const latestTagByMajor = {};
+    for (const { version } of allSupportedTags_withVersion) {
+        const version_current = latestTagByMajor[version.major];
+        if (version_current === undefined ||
+            SemVer/* SemVer.compare */.h.compare(version_current, version) === -1) {
+            latestTagByMajor[version.major] = version;
+        }
+    }
+    const latestMajorTags = Object.entries(latestTagByMajor)
+        .sort(([a], [b]) => parseInt(b) - parseInt(a))
+        .map(([, version]) => version)
+        .map(version => {
+        (0,assert/* assert */.h)(version !== undefined);
+        if (!supportedKeycloakMajorVersions.includes(version.major)) {
+            return undefined;
+        }
+        return SemVer/* SemVer.stringify */.h.stringify(version);
+    })
+        .filter((0,exclude/* exclude */.D)(undefined));
+    const allSupportedTags = allSupportedTags_withVersion.map(({ tag }) => tag);
+    const result = {
+        latestMajorTags,
+        allSupportedTags
+    };
+    await setCachedValue({ cacheDirPath: buildContext.cacheDirPath, result });
+    return result;
+}
+const { getCachedValue, setCachedValue } = (() => {
+    const zResult = (() => {
+        const zTargetType = lib.z.object({
+            allSupportedTags: lib.z.array(lib.z.string()),
+            latestMajorTags: lib.z.array(lib.z.string())
+        });
+        assert/* assert */.h;
+        return (0,id.id)(zTargetType);
+    })();
+    const zCache = (() => {
+        const zTargetType = lib.z.object({
+            keycloakifyVersion: lib.z.string(),
+            time: lib.z.number(),
+            result: zResult
+        });
+        assert/* assert */.h;
+        return (0,id.id)(zTargetType);
+    })();
+    let inMemoryCachedResult = undefined;
+    function getCacheFilePath(params) {
+        const { cacheDirPath } = params;
+        return (0,external_path_.join)(cacheDirPath, "supportedDockerImageTags.json");
+    }
+    async function getCachedValue(params) {
+        const { cacheDirPath } = params;
+        if (inMemoryCachedResult !== undefined) {
+            return inMemoryCachedResult;
+        }
+        const cacheFilePath = getCacheFilePath({ cacheDirPath });
+        if (!(await (0,fs_existsAsync/* existsAsync */.o)(cacheFilePath))) {
+            return undefined;
+        }
+        let cache;
+        try {
+            cache = zCache.parse(JSON.parse(await promises_.readFile(cacheFilePath, "utf8")));
+        }
+        catch (_a) {
+            return undefined;
+        }
+        if (cache.keycloakifyVersion !== (0,readThisNpmPackageVersion/* readThisNpmPackageVersion */.K)()) {
+            return undefined;
+        }
+        if (Date.now() - cache.time > 3600 * 24) {
+            return undefined;
+        }
+        inMemoryCachedResult = cache.result;
+        return cache.result;
+    }
+    async function setCachedValue(params) {
+        const { cacheDirPath, result } = params;
+        inMemoryCachedResult = result;
+        const cacheFilePath = getCacheFilePath({ cacheDirPath });
+        {
+            const dirPath = (0,external_path_.dirname)(cacheFilePath);
+            if (!(await (0,fs_existsAsync/* existsAsync */.o)(dirPath))) {
+                await promises_.mkdir(dirPath, { recursive: true });
+            }
+        }
+        await promises_.writeFile(cacheFilePath, JSON.stringify(zCache.parse({
+            keycloakifyVersion: (0,readThisNpmPackageVersion/* readThisNpmPackageVersion */.K)(),
+            time: Date.now(),
+            result
+        }), null, 2));
+    }
+    return {
+        getCachedValue,
+        setCachedValue
+    };
+})();
+//# sourceMappingURL=getSupportedDockerImageTags.js.map
+// EXTERNAL MODULE: ./node_modules/tsafe/esm/objectKeys.mjs
+var objectKeys = __webpack_require__(23483);
+// EXTERNAL MODULE: ./node_modules/evt/tools/inDepth/same.js
+var same = __webpack_require__(33805);
+;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/prepareRealmConfig.js
+
+
+
+
+
+assert/* assert */.h;
+function prepareRealmConfig(params) {
+    const { parsedRealmJson, keycloakMajorVersionNumber, buildContext } = params;
+    const { username } = addOrEditTestUser({
+        parsedRealmJson,
+        keycloakMajorVersionNumber
+    });
+    const { clientId } = addOrEditClient({
+        parsedRealmJson,
+        keycloakMajorVersionNumber
+    });
+    editAccountConsoleAndSecurityAdminConsole({ parsedRealmJson });
+    enableCustomThemes({
+        parsedRealmJson,
+        themeName: buildContext.themeNames[0],
+        implementedThemeTypes: buildContext.implementedThemeTypes
+    });
+    enable_custom_events_listeners: {
+        const name = "keycloakify-logging";
+        if (parsedRealmJson.eventsListeners.includes(name)) {
+            break enable_custom_events_listeners;
+        }
+        parsedRealmJson.eventsListeners.push(name);
+        parsedRealmJson.eventsListeners.sort();
+    }
+    return {
+        realmName: parsedRealmJson.realm,
+        clientName: clientId,
+        username
+    };
+}
+function enableCustomThemes(params) {
+    const { parsedRealmJson, themeName, implementedThemeTypes } = params;
+    for (const themeType of (0,objectKeys/* objectKeys */.Y)(implementedThemeTypes)) {
+        if (!implementedThemeTypes[themeType].isImplemented) {
+            continue;
+        }
+        parsedRealmJson[`${themeType}Theme`] = themeName;
+    }
+}
+function addOrEditTestUser(params) {
+    var _a, _b, _c, _d;
+    const { parsedRealmJson, keycloakMajorVersionNumber } = params;
+    const parsedRealmJson_default = getDefaultConfig({ keycloakMajorVersionNumber });
+    const [defaultUser_default] = parsedRealmJson_default.users;
+    (0,assert/* assert */.h)(defaultUser_default !== undefined);
+    const defaultUser_preexisting = parsedRealmJson.users.find(user => user.username === defaultUser_default.username);
+    const newUser = structuredClone((_a = defaultUser_preexisting !== null && defaultUser_preexisting !== void 0 ? defaultUser_preexisting : (() => {
+        const firstUser = parsedRealmJson.users[0];
+        if (firstUser === undefined) {
+            return undefined;
+        }
+        const firstUserCopy = structuredClone(firstUser);
+        firstUserCopy.id = defaultUser_default.id;
+        return firstUserCopy;
+    })()) !== null && _a !== void 0 ? _a : defaultUser_default);
+    newUser.username = defaultUser_default.username;
+    newUser.email = defaultUser_default.email;
+    delete_existing_password_credential_if_any: {
+        const i = newUser.credentials.findIndex(credential => credential.type === "password");
+        if (i === -1) {
+            break delete_existing_password_credential_if_any;
+        }
+        newUser.credentials.splice(i, 1);
+    }
+    {
+        const credential = defaultUser_default.credentials.find(credential => credential.type === "password");
+        (0,assert/* assert */.h)(credential !== undefined);
+        newUser.credentials.push(credential);
+    }
+    {
+        const nameByClientId = Object.fromEntries(parsedRealmJson.clients.map(client => [client.id, client.clientId]));
+        const newClientRoles = {};
+        for (const clientRole of Object.values(parsedRealmJson.roles.client).flat()) {
+            const clientName = nameByClientId[clientRole.containerId];
+            (0,assert/* assert */.h)(clientName !== undefined);
+            ((_b = newClientRoles[clientName]) !== null && _b !== void 0 ? _b : (newClientRoles[clientName] = [])).push(clientRole.name);
+        }
+        const { same: sameSet } = (0,same.sameFactory)({
+            takeIntoAccountArraysOrdering: false
+        });
+        for (const [clientName, roles] of Object.entries(newClientRoles)) {
+            keep_previous_ordering_if_possible: {
+                const roles_previous = (_c = newUser.clientRoles) === null || _c === void 0 ? void 0 : _c[clientName];
+                if (roles_previous === undefined) {
+                    break keep_previous_ordering_if_possible;
+                }
+                if (!sameSet(roles_previous, roles)) {
+                    break keep_previous_ordering_if_possible;
+                }
+                continue;
+            }
+            ((_d = newUser.clientRoles) !== null && _d !== void 0 ? _d : (newUser.clientRoles = {}))[clientName] = roles;
+        }
+    }
+    if (defaultUser_preexisting === undefined) {
+        parsedRealmJson.users.push(newUser);
+    }
+    else {
+        const i = parsedRealmJson.users.indexOf(defaultUser_preexisting);
+        (0,assert/* assert */.h)(i !== -1);
+        parsedRealmJson.users[i] = newUser;
+    }
+    return { username: newUser.username };
+}
+function addOrEditClient(params) {
+    var _a;
+    const { parsedRealmJson, keycloakMajorVersionNumber } = params;
+    const parsedRealmJson_default = getDefaultConfig({ keycloakMajorVersionNumber });
+    const testClient_default = (() => {
+        const clients = parsedRealmJson_default.clients.filter(client => {
+            return JSON.stringify(client).includes(constants/* TEST_APP_URL */.jp);
+        });
+        (0,assert/* assert */.h)(clients.length === 1);
+        return clients[0];
+    })();
+    const clientIds_builtIn = parsedRealmJson_default.clients
+        .map(client => client.clientId)
+        .filter(clientId => clientId !== testClient_default.clientId);
+    const testClient_preexisting = (() => {
+        const clients = parsedRealmJson.clients
+            .filter(client => !clientIds_builtIn.includes(client.clientId))
+            .filter(client => client.protocol === "openid-connect");
+        {
+            const client = clients.find(client => client.clientId === testClient_default.clientId);
+            if (client !== undefined) {
+                return client;
+            }
+        }
+        {
+            const client = clients.find(client => {
+                var _a;
+                return ((_a = client.redirectUris) === null || _a === void 0 ? void 0 : _a.find(redirectUri => redirectUri.startsWith(constants/* TEST_APP_URL */.jp))) !== undefined;
+            });
+            if (client !== undefined) {
+                return client;
+            }
+        }
+        const [client] = clients;
+        if (client === undefined) {
+            return undefined;
+        }
+        return client;
+    })();
+    let testClient;
+    if (testClient_preexisting !== undefined) {
+        testClient = testClient_preexisting;
+    }
+    else {
+        testClient = structuredClone(testClient_default);
+        delete testClient.protocolMappers;
+        parsedRealmJson.clients.push(testClient);
+    }
+    testClient.redirectUris = [
+        `${constants/* TEST_APP_URL */.jp}/*`,
+        "http://localhost*",
+        "http://127.0.0.1*"
+    ]
+        .sort()
+        .reverse();
+    ((_a = testClient.attributes) !== null && _a !== void 0 ? _a : (testClient.attributes = {}))["post.logout.redirect.uris"] = "+";
+    testClient.webOrigins = ["*"];
+    return { clientId: testClient.clientId };
+}
+function editAccountConsoleAndSecurityAdminConsole(params) {
+    var _a, _b, _c, _d, _e;
+    const { parsedRealmJson } = params;
+    for (const clientId of ["account-console", "security-admin-console"]) {
+        const client = parsedRealmJson.clients.find(client => client.clientId === clientId);
+        (0,assert/* assert */.h)(client !== undefined);
+        {
+            const arr = ((_a = client.redirectUris) !== null && _a !== void 0 ? _a : (client.redirectUris = []));
+            for (const value of ["http://localhost*", "http://127.0.0.1*"]) {
+                if (!arr.includes(value)) {
+                    arr.push(value);
+                }
+            }
+            (_b = client.redirectUris) === null || _b === void 0 ? void 0 : _b.sort().reverse();
+        }
+        ((_c = client.attributes) !== null && _c !== void 0 ? _c : (client.attributes = {}))["post.logout.redirect.uris"] = "+";
+        client.webOrigins = ["*"];
+        admin_specific: {
+            if (clientId !== "security-admin-console") {
+                break admin_specific;
+            }
+            const protocolMapper_preexisting = (_d = client.protocolMappers) === null || _d === void 0 ? void 0 : _d.find(protocolMapper => {
+                if (protocolMapper.protocolMapper !== "oidc-hardcoded-claim-mapper") {
+                    return false;
+                }
+                if (protocolMapper.protocol !== "openid-connect") {
+                    return false;
+                }
+                if (protocolMapper.config === undefined) {
+                    return false;
+                }
+                if (protocolMapper.config["claim.name"] !== "allowed-origins") {
+                    return false;
+                }
+                return true;
+            });
+            let protocolMapper;
+            const config = {
+                "introspection.token.claim": "true",
+                "claim.value": '["*"]',
+                "userinfo.token.claim": "true",
+                "id.token.claim": "false",
+                "lightweight.claim": "true",
+                "access.token.claim": "true",
+                "claim.name": "allowed-origins",
+                "jsonType.label": "JSON",
+                "access.tokenResponse.claim": "false"
+            };
+            if (protocolMapper_preexisting !== undefined) {
+                protocolMapper = protocolMapper_preexisting;
+            }
+            else {
+                protocolMapper = {
+                    id: "8fd0d584-7052-4d04-a615-d18a71050873",
+                    name: "allowed-origins",
+                    protocol: "openid-connect",
+                    protocolMapper: "oidc-hardcoded-claim-mapper",
+                    consentRequired: false,
+                    config
+                };
+                ((_e = client.protocolMappers) !== null && _e !== void 0 ? _e : (client.protocolMappers = [])).push(protocolMapper);
+            }
+            (0,assert/* assert */.h)(protocolMapper.config !== undefined);
+            if (config !== protocolMapper.config) {
+                Object.assign(protocolMapper.config, config);
+            }
+        }
+    }
+}
+//# sourceMappingURL=prepareRealmConfig.js.map
+// EXTERNAL MODULE: ./dist/bin/tools/runPrettier.js
+var runPrettier = __webpack_require__(48433);
+;// CONCATENATED MODULE: ./dist/bin/tools/Stringifyable.js
+
+
+
+
+const zStringifyableAtomic = (() => {
+    const zTargetType = lib.z.union([lib.z.string(), lib.z.number(), lib.z.boolean(), lib.z["null"]()]);
+    (0,assert/* assert */.h)();
+    return (0,id.id)(zTargetType);
+})();
+const zStringifyable = lib.z.any()
+    .superRefine((val, ctx) => {
+    const isStringifyable = (0,same.same)(JSON.parse(JSON.stringify(val)), val);
+    if (!isStringifyable) {
+        ctx.addIssue({
+            code: lib.z.ZodIssueCode.custom,
+            message: "Not stringifyable"
+        });
+    }
+});
+function getIsAtomic(stringifyable) {
+    return (["string", "number", "boolean"].includes(typeof stringifyable) ||
+        stringifyable === null);
+}
+const { getValueAtPath } = (() => {
+    function getValueAtPath_rec(stringifyable, path) {
+        if (path.length === 0) {
+            return stringifyable;
+        }
+        if (getIsAtomic(stringifyable)) {
+            return undefined;
+        }
+        const [first, ...rest] = path;
+        let dereferenced;
+        if (stringifyable instanceof Array) {
+            if (typeof first !== "number") {
+                return undefined;
+            }
+            dereferenced = stringifyable[first];
+        }
+        else {
+            if (typeof first !== "string") {
+                return undefined;
+            }
+            dereferenced = stringifyable[first];
+        }
+        if (dereferenced === undefined) {
+            return undefined;
+        }
+        return getValueAtPath_rec(dereferenced, rest);
+    }
+    function getValueAtPath(stringifyableObjectOrArray, path) {
+        return getValueAtPath_rec(stringifyableObjectOrArray, path);
+    }
+    return { getValueAtPath };
+})();
+//# sourceMappingURL=Stringifyable.js.map
+;// CONCATENATED MODULE: ./dist/bin/tools/canonicalStringify.js
+
+function canonicalStringify(params) {
+    const { data, referenceData } = params;
+    return JSON.stringify(makeDeterministicCopy({
+        path: [],
+        data,
+        getCanonicalKeys: path => {
+            const referenceValue = (() => {
+                const path_patched = [];
+                for (let i = 0; i < path.length; i++) {
+                    let value_i = getValueAtPath(referenceData, [
+                        ...path_patched,
+                        path[i]
+                    ]);
+                    if (value_i !== undefined) {
+                        path_patched.push(path[i]);
+                        continue;
+                    }
+                    if (typeof path[i] !== "number") {
+                        return undefined;
+                    }
+                    value_i = getValueAtPath(referenceData, [...path_patched, 0]);
+                    if (value_i !== undefined) {
+                        path_patched.push(0);
+                        continue;
+                    }
+                    return undefined;
+                }
+                return getValueAtPath(referenceData, path_patched);
+            })();
+            if (referenceValue === undefined) {
+                return undefined;
+            }
+            if (getIsAtomic(referenceValue)) {
+                return undefined;
+            }
+            if (referenceValue instanceof Array) {
+                return undefined;
+            }
+            return Object.keys(referenceValue);
+        }
+    }), null, 2);
+}
+function makeDeterministicCopy(params) {
+    const { path, data, getCanonicalKeys } = params;
+    if (getIsAtomic(data)) {
+        return data;
+    }
+    if (data instanceof Array) {
+        return makeDeterministicCopy_array({
+            path,
+            data,
+            getCanonicalKeys
+        });
+    }
+    return makeDeterministicCopy_record({
+        path,
+        data,
+        getCanonicalKeys
+    });
+}
+function makeDeterministicCopy_record(params) {
+    const { path, data, getCanonicalKeys } = params;
+    const keysOfAtomicValues = [];
+    const keysOfNonAtomicValues = [];
+    for (const [key, value] of Object.entries(data)) {
+        if (getIsAtomic(value)) {
+            keysOfAtomicValues.push(key);
+        }
+        else {
+            keysOfNonAtomicValues.push(key);
+        }
+    }
+    keysOfAtomicValues.sort();
+    keysOfNonAtomicValues.sort();
+    const keys = [...keysOfAtomicValues, ...keysOfNonAtomicValues];
+    reorder_according_to_canonical: {
+        const canonicalKeys = getCanonicalKeys(path);
+        if (canonicalKeys === undefined) {
+            break reorder_according_to_canonical;
+        }
+        const keys_toPrepend = [];
+        for (const key of canonicalKeys) {
+            const indexOfKey = keys.indexOf(key);
+            if (indexOfKey === -1) {
+                continue;
+            }
+            keys.splice(indexOfKey, 1);
+            keys_toPrepend.push(key);
+        }
+        keys.unshift(...keys_toPrepend);
+    }
+    const result = {};
+    for (const key of keys) {
+        result[key] = makeDeterministicCopy({
+            path: [...path, key],
+            data: data[key],
+            getCanonicalKeys
+        });
+    }
+    return result;
+}
+function makeDeterministicCopy_array(params) {
+    const { path, data, getCanonicalKeys } = params;
+    return [...data].map((entry, i) => makeDeterministicCopy({
+        path: [...path, i],
+        data: entry,
+        getCanonicalKeys
+    }));
+}
+//# sourceMappingURL=canonicalStringify.js.map
+;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/ParsedRealmJson/writeRealmJsonFile.js
+
+
+
+
+async function writeRealmJsonFile(params) {
+    const { realmJsonFilePath, parsedRealmJson, keycloakMajorVersionNumber } = params;
+    let sourceCode = canonicalStringify({
+        data: parsedRealmJson,
+        referenceData: getDefaultConfig({
+            keycloakMajorVersionNumber
+        })
+    });
+    if (await (0,runPrettier/* getIsPrettierAvailable */.MT)()) {
+        sourceCode = await (0,runPrettier/* runPrettier */.eY)({
+            sourceCode: sourceCode,
+            filePath: realmJsonFilePath
+        });
+    }
+    await promises_.writeFile(realmJsonFilePath, Buffer.from(sourceCode, "utf8"));
+}
+//# sourceMappingURL=writeRealmJsonFile.js.map
+;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/ParsedRealmJson/index.js
+
+
+//# sourceMappingURL=index.js.map
+;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/dumpContainerConfig.js
+
+
+
+
+
+
+
+(0,assert/* assert */.h)();
+async function dumpContainerConfig(params) {
+    const { realmName, keycloakMajorVersionNumber, buildContext } = params;
+    // https://github.com/keycloak/keycloak/issues/33800
+    const doesUseLockedH2Database = keycloakMajorVersionNumber >= 25;
+    if (doesUseLockedH2Database) {
+        const dCompleted = new Deferred.Deferred();
+        const cmd = `docker exec ${constants/* CONTAINER_NAME */.sv} sh -c "cp -rp /opt/keycloak/data/h2 /tmp"`;
+        external_child_process_default().exec(cmd, error => {
+            if (error !== null) {
+                dCompleted.reject(error);
+                return;
+            }
+            dCompleted.resolve();
+        });
+        try {
+            await dCompleted.pr;
+        }
+        catch (error) {
+            (0,assert/* assert */.h)((0,assert.is)(error));
+            console.log(source_default().red(`Docker command failed: ${cmd}`));
+            console.log(source_default().red(error.message));
+            throw error;
+        }
+    }
+    {
+        const dCompleted = new Deferred.Deferred();
+        const child = external_child_process_default().spawn("docker", [
+            ...["exec", constants/* CONTAINER_NAME */.sv],
+            ...["/opt/keycloak/bin/kc.sh", "export"],
+            ...["--dir", "/tmp"],
+            ...["--realm", realmName],
+            ...["--users", "realm_file"],
+            ...(!doesUseLockedH2Database
+                ? []
+                : [
+                    ...["--db", "dev-file"],
+                    ...[
+                        "--db-url",
+                        '"jdbc:h2:file:/tmp/h2/keycloakdb;NON_KEYWORDS=VALUE"'
+                    ]
+                ])
+        ], { shell: true });
+        let output = "";
+        const onExit = (code) => {
+            dCompleted.reject(new Error(`docker exec kc.sh export command failed with code ${code}`));
+        };
+        child.once("exit", onExit);
+        child.stdout.on("data", data => {
+            const outputStr = data.toString("utf8");
+            if (outputStr.includes("Export finished successfully")) {
+                child.removeListener("exit", onExit);
+                // NOTE: On older Keycloak versions the process keeps running after the export is done.
+                const timer = setTimeout(() => {
+                    child.removeListener("exit", onExit2);
+                    child.kill();
+                    dCompleted.resolve();
+                }, 1500);
+                const onExit2 = () => {
+                    clearTimeout(timer);
+                    dCompleted.resolve();
+                };
+                child.once("exit", onExit2);
+            }
+            output += outputStr;
+        });
+        child.stderr.on("data", data => (output += source_default().red(data.toString("utf8"))));
+        try {
+            await dCompleted.pr;
+        }
+        catch (error) {
+            (0,assert/* assert */.h)((0,assert.is)(error));
+            console.log(source_default().red(error.message));
+            console.log(output);
+            throw error;
+        }
+    }
+    if (doesUseLockedH2Database) {
+        const dCompleted = new Deferred.Deferred();
+        const cmd = `docker exec ${constants/* CONTAINER_NAME */.sv} sh -c "rm -rf /tmp/h2"`;
+        external_child_process_default().exec(cmd, error => {
+            if (error !== null) {
+                dCompleted.reject(error);
+                return;
+            }
+            dCompleted.resolve();
+        });
+        try {
+            await dCompleted.pr;
+        }
+        catch (error) {
+            (0,assert/* assert */.h)((0,assert.is)(error));
+            console.log(source_default().red(`Docker command failed: ${cmd}`));
+            console.log(source_default().red(error.message));
+            throw error;
+        }
+    }
+    const targetRealmConfigJsonFilePath_tmp = (0,external_path_.join)(buildContext.cacheDirPath, "realm.json");
+    {
+        const dCompleted = new Deferred.Deferred();
+        const cmd = `docker cp ${constants/* CONTAINER_NAME */.sv}:/tmp/${realmName}-realm.json ${(0,external_path_.basename)(targetRealmConfigJsonFilePath_tmp)}`;
+        external_child_process_default().exec(cmd, {
+            cwd: (0,external_path_.dirname)(targetRealmConfigJsonFilePath_tmp)
+        }, error => {
+            if (error !== null) {
+                dCompleted.reject(error);
+                return;
+            }
+            dCompleted.resolve();
+        });
+        try {
+            await dCompleted.pr;
+        }
+        catch (error) {
+            (0,assert/* assert */.h)((0,assert.is)(error));
+            console.log(source_default().red(`Docker command failed: ${cmd}`));
+            console.log(source_default().red(error.message));
+            throw error;
+        }
+    }
+    return readRealmJsonFile({
+        realmJsonFilePath: targetRealmConfigJsonFilePath_tmp
+    });
+}
+//# sourceMappingURL=dumpContainerConfig.js.map
+;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/realmConfig.js
+
+
+
+
+
+
+
+
+
+
+
+assert/* assert */.h;
+async function getRealmConfig(params) {
+    const { keycloakMajorVersionNumber, realmJsonFilePath_userProvided, buildContext } = params;
+    const realmJsonFilePath = (0,external_path_.join)(buildContext.projectDirPath, ".keycloakify", `realm-kc-${keycloakMajorVersionNumber}.json`);
+    const parsedRealmJson = await (async () => {
+        if (realmJsonFilePath_userProvided !== undefined) {
+            return readRealmJsonFile({
+                realmJsonFilePath: realmJsonFilePath_userProvided
+            });
+        }
+        if (await (0,fs_existsAsync/* existsAsync */.o)(realmJsonFilePath)) {
+            return readRealmJsonFile({
+                realmJsonFilePath
+            });
+        }
+        return getDefaultConfig({ keycloakMajorVersionNumber });
+    })();
+    const { clientName, realmName, username } = prepareRealmConfig({
+        parsedRealmJson,
+        buildContext,
+        keycloakMajorVersionNumber
+    });
+    {
+        const dirPath = (0,external_path_.dirname)(realmJsonFilePath);
+        if (!(await (0,fs_existsAsync/* existsAsync */.o)(dirPath))) {
+            external_fs_.mkdirSync(dirPath, { recursive: true });
+        }
+    }
+    await writeRealmJsonFile({
+        realmJsonFilePath,
+        parsedRealmJson,
+        keycloakMajorVersionNumber
+    });
+    const { onRealmConfigChange } = (() => {
+        const run = runExclusive.build(async () => {
+            const start = Date.now();
+            console.log(source_default().grey(`Changes detected to the '${realmName}' config, backing up...`));
+            let parsedRealmJson;
+            try {
+                parsedRealmJson = await dumpContainerConfig({
+                    buildContext,
+                    realmName,
+                    keycloakMajorVersionNumber
+                });
+            }
+            catch (error) {
+                console.log(source_default().red(`Failed to backup '${realmName}' config:`));
+                return;
+            }
+            await writeRealmJsonFile({
+                realmJsonFilePath,
+                parsedRealmJson,
+                keycloakMajorVersionNumber
+            });
+            console.log([
+                source_default().grey(`Save changed to \`.${external_path_.sep}${(0,external_path_.relative)(buildContext.projectDirPath, realmJsonFilePath)}\``),
+                source_default().grey(`Next time you'll be running \`keycloakify start-keycloak\`, the realm '${realmName}' will be restored to this state.`),
+                source_default().green(`✓ '${realmName}' config backed up completed in ${Date.now() - start}ms`)
+            ].join("\n"));
+        });
+        const { waitForDebounce } = (0,tools_waitForDebounce/* waitForDebounceFactory */.z)({
+            delay: 1000
+        });
+        async function onRealmConfigChange() {
+            await waitForDebounce();
+            run();
+        }
+        return { onRealmConfigChange };
+    })();
+    return {
+        realmJsonFilePath,
+        clientName,
+        realmName,
+        username,
+        onRealmConfigChange
+    };
+}
+//# sourceMappingURL=realmConfig.js.map
+;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/index.js
+
+//# sourceMappingURL=index.js.map
+;// CONCATENATED MODULE: ./dist/bin/start-keycloak/start-keycloak.js
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+async function command(params) {
+    var _a, _b, _c, _d, _e;
+    exit_if_docker_not_installed: {
+        let commandOutput = undefined;
+        try {
+            commandOutput = (_a = external_child_process_.execSync("docker --version", {
+                stdio: ["ignore", "pipe", "ignore"]
+            })) === null || _a === void 0 ? void 0 : _a.toString("utf8");
+        }
+        catch (_f) { }
+        if ((commandOutput === null || commandOutput === void 0 ? void 0 : commandOutput.includes("Docker")) || (commandOutput === null || commandOutput === void 0 ? void 0 : commandOutput.includes("podman"))) {
+            break exit_if_docker_not_installed;
+        }
+        console.log([
+            `${source_default().red("Docker required.")}`,
+            `Install it with Docker Desktop: ${source_default().bold.underline("https://www.docker.com/products/docker-desktop/")}`,
+            `(or any other way)`
+        ].join(" "));
+        process.exit(1);
+    }
+    exit_if_docker_not_running: {
+        let isDockerRunning;
+        try {
+            external_child_process_.execSync("docker info", { stdio: "ignore" });
+            isDockerRunning = true;
+        }
+        catch (_g) {
+            isDockerRunning = false;
+        }
+        if (isDockerRunning) {
+            break exit_if_docker_not_running;
+        }
+        console.log([
+            `${source_default().red("Docker daemon is not running.")}`,
+            `Please start Docker Desktop and try again.`
+        ].join(" "));
+        process.exit(1);
+    }
+    const { cliCommandOptions, buildContext } = params;
+    const { allSupportedTags, latestMajorTags } = await getSupportedDockerImageTags({
         buildContext
     });
-    if (hasBeenHandled) {
-        return;
-    }
-    console.log(chalk__WEBPACK_IMPORTED_MODULE_6___default().cyan("Theme type:"));
-    const themeType = await (async () => {
-        const values = _shared_constants__WEBPACK_IMPORTED_MODULE_2__/* .THEME_TYPES.filter */ .Jh.filter(themeType => {
-            switch (themeType) {
-                case "account":
-                    return buildContext.implementedThemeTypes.account.isImplemented;
-                case "login":
-                    return buildContext.implementedThemeTypes.login.isImplemented;
-                case "admin":
-                    return buildContext.implementedThemeTypes.admin.isImplemented;
-            }
-            (0,tsafe_assert__WEBPACK_IMPORTED_MODULE_5__/* .assert */ .h)(false);
-        });
-        (0,tsafe_assert__WEBPACK_IMPORTED_MODULE_5__/* .assert */ .h)(values.length > 0, "No theme is implemented in this project");
-        if (values.length === 1) {
-            return values[0];
-        }
-        const { value } = await cli_select__WEBPACK_IMPORTED_MODULE_1___default()({
-            values
-        }).catch(() => {
-            process.exit(-1);
-        });
-        return value;
+    const { dockerImageTag } = await (async () => {
+        if (cliCommandOptions.keycloakVersion !== undefined) {
+            const cliCommandOptions_keycloakVersion = cliCommandOptions.keycloakVersion;
+            const tag = allSupportedTags.find(tag => tag.startsWith(cliCommandOptions_keycloakVersion));
+            if (tag === undefined) {
+                console.log(source_default().red([
+                    `We could not find a Keycloak Docker image for ${cliCommandOptions_keycloakVersion}`,
+                    `Example of valid values: --keycloak-version 26, --keycloak-version 26.0.7`
+                ].join("\n")));
+                process.exit(1);
+            }
+            return { dockerImageTag: tag };
+        }
+        if (buildContext.startKeycloakOptions.dockerImage !== undefined) {
+            return {
+                dockerImageTag: buildContext.startKeycloakOptions.dockerImage.tag
+            };
+        }
+        console.log([
+            source_default().cyan("On which version of Keycloak do you want to test your theme?"),
+            source_default().gray("You can also explicitly provide the version with `npx keycloakify start-keycloak --keycloak-version 26` (or any other version)")
+        ].join("\n"));
+        const tag_userSelected = await (async () => {
+            let tag;
+            let latestMajorTags_copy = [...latestMajorTags];
+            while (true) {
+                const { value } = await dist_default()({
+                    values: latestMajorTags_copy
+                }).catch(() => {
+                    process.exit(-1);
+                });
+                tag = value;
+                {
+                    const doImplementAccountMpa = buildContext.implementedThemeTypes.account.isImplemented &&
+                        buildContext.implementedThemeTypes.account.type === "Multi-Page";
+                    if (doImplementAccountMpa && tag.startsWith("22.")) {
+                        console.log(source_default().yellow(`You are implementing a Multi-Page Account theme. Keycloak 22 is not supported, select another version`));
+                        latestMajorTags_copy = latestMajorTags_copy.filter(tag => !tag.startsWith("22."));
+                        continue;
+                    }
+                }
+                const readMajor = (tag) => {
+                    const major = parseInt(tag.split(".")[0]);
+                    (0,assert/* assert */.h)(!isNaN(major));
+                    return major;
+                };
+                {
+                    const major = readMajor(tag);
+                    const doImplementAdminTheme = buildContext.implementedThemeTypes.admin.isImplemented;
+                    const getIsSupported = (major) => major >= 23;
+                    if (doImplementAdminTheme && !getIsSupported(major)) {
+                        console.log(source_default().yellow(`You are implementing an Admin theme. Only Keycloak 23 and later are supported, select another version`));
+                        latestMajorTags_copy = latestMajorTags_copy.filter(tag => getIsSupported(readMajor(tag)));
+                        continue;
+                    }
+                }
+                {
+                    const doImplementAccountSpa = buildContext.implementedThemeTypes.account.isImplemented &&
+                        buildContext.implementedThemeTypes.account.type === "Single-Page";
+                    const major = readMajor(tag);
+                    const getIsSupported = (major) => major >= 19;
+                    if (doImplementAccountSpa && !getIsSupported(major)) {
+                        console.log(source_default().yellow(`You are implementing a Single-Page Account theme. Only Keycloak 19 and later are supported, select another version`));
+                        latestMajorTags_copy = latestMajorTags_copy.filter(tag => getIsSupported(readMajor(tag)));
+                        continue;
+                    }
+                }
+                break;
+            }
+            return tag;
+        })();
+        console.log(`→ ${tag_userSelected}`);
+        return { dockerImageTag: tag_userSelected };
     })();
-    if (themeType === "account" &&
-        ((0,tsafe_assert__WEBPACK_IMPORTED_MODULE_5__/* .assert */ .h)(buildContext.implementedThemeTypes.account.isImplemented),
-            buildContext.implementedThemeTypes.account.type === "Single-Page")) {
-        console.log(`${chalk__WEBPACK_IMPORTED_MODULE_6___default().red("✗")} Sorry, there is no Storybook support for Single-Page Account themes.`);
-        process.exit(0);
-        return;
-    }
-    if (themeType === "admin") {
-        console.log(`${chalk__WEBPACK_IMPORTED_MODULE_6___default().red("✗")} Sorry, there is no Storybook support for the Account UI.`);
-        process.exit(0);
-        return;
-    }
-    console.log(`→ ${themeType}`);
-    console.log(chalk__WEBPACK_IMPORTED_MODULE_6___default().cyan("Select the page you want to create a Storybook for:"));
-    const { value: pageId } = await cli_select__WEBPACK_IMPORTED_MODULE_1___default()({
-        values: (() => {
-            switch (themeType) {
-                case "login":
-                    return [..._shared_constants__WEBPACK_IMPORTED_MODULE_2__/* .LOGIN_THEME_PAGE_IDS */ .XV];
-                case "account":
-                    return [..._shared_constants__WEBPACK_IMPORTED_MODULE_2__/* .ACCOUNT_THEME_PAGE_IDS */ .yV];
-            }
-            (0,tsafe_assert__WEBPACK_IMPORTED_MODULE_5__/* .assert */ .h)(false);
-        })()
-    }).catch(() => {
-        process.exit(-1);
+    const keycloakMajorVersionNumber = (() => {
+        const [wrap] = getSupportedKeycloakMajorVersions()
+            .map(majorVersionNumber => ({
+            majorVersionNumber,
+            index: dockerImageTag.indexOf(`${majorVersionNumber}`)
+        }))
+            .filter(({ index }) => index !== -1)
+            .sort((a, b) => a.index - b.index);
+        if (wrap === undefined) {
+            try {
+                const version = SemVer/* SemVer.parse */.h.parse(dockerImageTag);
+                console.error(source_default().yellow(`Keycloak version ${version.major} is not supported, supported versions are ${getSupportedKeycloakMajorVersions().join(", ")}`));
+                process.exit(1);
+            }
+            catch (_a) {
+                // NOTE: Latest version
+                const [n] = getSupportedKeycloakMajorVersions();
+                console.warn(source_default().yellow(`Could not determine the major Keycloak version number from the docker image tag ${dockerImageTag}. Assuming ${n}`));
+                return n;
+            }
+        }
+        return wrap.majorVersionNumber;
+    })();
+    const { clientName, onRealmConfigChange, realmJsonFilePath, realmName, username } = await getRealmConfig({
+        keycloakMajorVersionNumber,
+        realmJsonFilePath_userProvided: await (async () => {
+            if (cliCommandOptions.realmJsonFilePath !== undefined) {
+                return (0,getAbsoluteAndInOsFormatPath/* getAbsoluteAndInOsFormatPath */.c)({
+                    pathIsh: cliCommandOptions.realmJsonFilePath,
+                    cwd: process.cwd()
+                });
+            }
+            if (buildContext.startKeycloakOptions.realmJsonFilePath !== undefined) {
+                (0,assert/* assert */.h)(await (0,fs_existsAsync/* existsAsync */.o)(buildContext.startKeycloakOptions.realmJsonFilePath), `${(0,external_path_.relative)(process.cwd(), buildContext.startKeycloakOptions.realmJsonFilePath)} does not exist`);
+                return buildContext.startKeycloakOptions.realmJsonFilePath;
+            }
+            return undefined;
+        })(),
+        buildContext
     });
-    console.log(`→ ${pageId}`);
-    const componentBasename = (0,tsafe_capitalize__WEBPACK_IMPORTED_MODULE_9__/* .capitalize */ .k)((0,_tools_kebabCaseToSnakeCase__WEBPACK_IMPORTED_MODULE_10__/* .kebabCaseToCamelCase */ .A)(pageId)).replace(/ftl$/, "stories.tsx");
-    const targetFilePath = (0,path__WEBPACK_IMPORTED_MODULE_4__.join)(buildContext.themeSrcDirPath, themeType, "pages", componentBasename);
-    if (fs__WEBPACK_IMPORTED_MODULE_3__.existsSync(targetFilePath)) {
-        console.log(`${(0,path__WEBPACK_IMPORTED_MODULE_4__.relative)(process.cwd(), targetFilePath)} already exists`);
-        process.exit(-1);
-    }
-    let sourceCode = fs__WEBPACK_IMPORTED_MODULE_3__.readFileSync((0,path__WEBPACK_IMPORTED_MODULE_4__.join)((0,_tools_getThisCodebaseRootDirPath__WEBPACK_IMPORTED_MODULE_0__/* .getThisCodebaseRootDirPath */ .e)(), "stories", themeType, "pages", componentBasename))
-        .toString("utf8")
-        .replace('import React from "react";\n', "")
-        .replace(/from "[./]+dist\//, 'from "keycloakify/');
-    run_prettier: {
-        if (!(await (0,_tools_runPrettier__WEBPACK_IMPORTED_MODULE_7__/* .getIsPrettierAvailable */ .MT)())) {
-            break run_prettier;
+    {
+        const { isAppBuildSuccess } = await appBuild({
+            buildContext
+        });
+        if (!isAppBuildSuccess) {
+            console.log(source_default().red(`App build failed, exiting. Try building your app (e.g 'npm run build') and see what's wrong.`));
+            process.exit(1);
         }
-        sourceCode = await (0,_tools_runPrettier__WEBPACK_IMPORTED_MODULE_7__/* .runPrettier */ .eY)({
-            filePath: targetFilePath,
-            sourceCode: sourceCode
+        const { isKeycloakifyBuildSuccess } = await keycloakifyBuild({
+            buildForKeycloakMajorVersionNumber: keycloakMajorVersionNumber,
+            buildContext
+        });
+        if (!isKeycloakifyBuildSuccess) {
+            console.log(source_default().red(`Keycloakify build failed, exiting. Try running 'npx keycloakify build' and see what's wrong.`));
+            process.exit(1);
+        }
+    }
+    const jarFilePath = external_fs_.readdirSync(buildContext.keycloakifyBuildDirPath)
+        .filter(fileBasename => fileBasename.endsWith(".jar"))
+        .map(fileBasename => (0,external_path_.join)(buildContext.keycloakifyBuildDirPath, fileBasename))
+        .sort((a, b) => external_fs_.statSync(b).mtimeMs - external_fs_.statSync(a).mtimeMs)[0];
+    (0,assert/* assert */.h)(jarFilePath !== undefined);
+    const extensionJarFilePaths = [
+        ...(keycloakMajorVersionNumber <= 20
+            ? (console.log(source_default().yellow("WARNING: With older version of keycloak your changes to the realm configuration are not persisted")),
+                [])
+            : [
+                (0,external_path_.join)((0,getThisCodebaseRootDirPath/* getThisCodebaseRootDirPath */.e)(), "src", "bin", "start-keycloak", constants/* KEYCLOAKIFY_LOGIN_JAR_BASENAME */.Tr)
+            ]),
+        ...(await Promise.all(buildContext.startKeycloakOptions.extensionJars.map(async (extensionJar) => {
+            switch (extensionJar.type) {
+                case "path": {
+                    (0,assert/* assert */.h)(await (0,fs_existsAsync/* existsAsync */.o)(extensionJar.path), `${extensionJar.path} does not exist`);
+                    return extensionJar.path;
+                }
+                case "url": {
+                    const { archiveFilePath } = await downloadAndExtractArchive({
+                        cacheDirPath: buildContext.cacheDirPath,
+                        fetchOptions: buildContext.fetchOptions,
+                        url: extensionJar.url,
+                        uniqueIdOfOnArchiveFile: "no extraction",
+                        onArchiveFile: async () => { }
+                    });
+                    return archiveFilePath;
+                }
+            }
+            (0,assert/* assert */.h)(false);
+        })))
+    ];
+    async function extractThemeResourcesFromJar() {
+        await extractArchive({
+            archiveFilePath: jarFilePath,
+            onArchiveFile: async ({ relativeFilePathInArchive, writeFile }) => {
+                if ((0,isInside/* isInside */.V)({ dirPath: "theme", filePath: relativeFilePathInArchive })) {
+                    await writeFile({
+                        filePath: (0,external_path_.join)(buildContext.keycloakifyBuildDirPath, relativeFilePathInArchive)
+                    });
+                }
+            }
         });
     }
     {
-        const targetDirPath = (0,path__WEBPACK_IMPORTED_MODULE_4__.dirname)(targetFilePath);
-        if (!fs__WEBPACK_IMPORTED_MODULE_3__.existsSync(targetDirPath)) {
-            fs__WEBPACK_IMPORTED_MODULE_3__.mkdirSync(targetDirPath, { recursive: true });
+        const destDirPath = (0,external_path_.join)(buildContext.keycloakifyBuildDirPath, "theme");
+        if (await (0,fs_existsAsync/* existsAsync */.o)(destDirPath)) {
+            await rm(destDirPath, { recursive: true });
+        }
+    }
+    await extractThemeResourcesFromJar();
+    const jarFilePath_cacheDir = (0,external_path_.join)(buildContext.cacheDirPath, (0,external_path_.basename)(jarFilePath));
+    external_fs_.copyFileSync(jarFilePath, jarFilePath_cacheDir);
+    try {
+        external_child_process_.execSync(`docker rm --force ${constants/* CONTAINER_NAME */.sv}`, {
+            stdio: "ignore"
+        });
+    }
+    catch (_h) { }
+    const port = (_c = (_b = cliCommandOptions.port) !== null && _b !== void 0 ? _b : buildContext.startKeycloakOptions.port) !== null && _c !== void 0 ? _c : 8080;
+    const doStartDevServer = (() => {
+        const hasSpaUi = buildContext.implementedThemeTypes.admin.isImplemented ||
+            (buildContext.implementedThemeTypes.account.isImplemented &&
+                buildContext.implementedThemeTypes.account.type === "Single-Page");
+        if (!hasSpaUi) {
+            return false;
+        }
+        if (buildContext.bundler !== "vite") {
+            console.log(source_default().yellow([
+                `WARNING: Since you are using ${buildContext.bundler} instead of Vite,`,
+                `you'll have to wait serval seconds for the changes you made on your account or admin theme to be reflected in the browser.\n`,
+                `For a better development experience, consider migrating to Vite.`
+            ].join(" ")));
+            return false;
+        }
+        if (keycloakMajorVersionNumber < 25) {
+            console.log(source_default().yellow([
+                `WARNING: Your account or admin theme can't be tested with hot module replacement on Keycloak ${keycloakMajorVersionNumber}.`,
+                `This mean that you'll have to wait serval seconds for the changes to be reflected in the browser.`,
+                `For a better development experience, select a more recent version of Keycloak.`
+            ].join("\n")));
+            return false;
         }
+        return true;
+    })();
+    let devServerPort = undefined;
+    if (doStartDevServer) {
+        const { port } = await startViteDevServer({ buildContext });
+        devServerPort = port;
+    }
+    const SPACE_PLACEHOLDER = "SPACE_PLACEHOLDER_xKLmdPd";
+    const dockerRunArgs = [
+        `-p${SPACE_PLACEHOLDER}${port}:8080`,
+        `--name${SPACE_PLACEHOLDER}${constants/* CONTAINER_NAME */.sv}`,
+        ...(keycloakMajorVersionNumber >= 26
+            ? [
+                `-e${SPACE_PLACEHOLDER}KC_BOOTSTRAP_ADMIN_USERNAME=admin`,
+                `-e${SPACE_PLACEHOLDER}KC_BOOTSTRAP_ADMIN_PASSWORD=admin`
+            ]
+            : [
+                `-e${SPACE_PLACEHOLDER}KEYCLOAK_ADMIN=admin`,
+                `-e${SPACE_PLACEHOLDER}KEYCLOAK_ADMIN_PASSWORD=admin`
+            ]),
+        ...(devServerPort === undefined
+            ? []
+            : [
+                `-e${SPACE_PLACEHOLDER}${constants/* KEYCLOAKIFY_SPA_DEV_SERVER_PORT */.Sz}=${devServerPort}`
+            ]),
+        ...(buildContext.startKeycloakOptions.dockerExtraArgs.length === 0
+            ? []
+            : [
+                buildContext.startKeycloakOptions.dockerExtraArgs.join(SPACE_PLACEHOLDER)
+            ]),
+        ...(realmJsonFilePath === undefined
+            ? []
+            : [
+                `-v${SPACE_PLACEHOLDER}"${realmJsonFilePath}":/opt/keycloak/data/import/${realmName}-realm.json`
+            ]),
+        `-v${SPACE_PLACEHOLDER}"${jarFilePath_cacheDir}":/opt/keycloak/providers/keycloak-theme.jar`,
+        ...extensionJarFilePaths.map(jarFilePath => `-v${SPACE_PLACEHOLDER}"${jarFilePath}":/opt/keycloak/providers/${(0,external_path_.basename)(jarFilePath)}`),
+        ...(keycloakMajorVersionNumber <= 20
+            ? [`-e${SPACE_PLACEHOLDER}JAVA_OPTS=-Dkeycloak.profile=preview`]
+            : []),
+        ...[
+            ...buildContext.themeNames,
+            ...(external_fs_.existsSync((0,external_path_.join)(buildContext.keycloakifyBuildDirPath, "theme", "account-v1"))
+                ? ["account-v1"]
+                : [])
+        ]
+            .map(themeName => ({
+            localDirPath: (0,external_path_.join)(buildContext.keycloakifyBuildDirPath, "theme", themeName),
+            containerDirPath: `/opt/keycloak/themes/${themeName}`
+        }))
+            .map(({ localDirPath, containerDirPath }) => `-v${SPACE_PLACEHOLDER}"${localDirPath}":${containerDirPath}:rw`),
+        ...buildContext.environmentVariables
+            .map(({ name }) => ({ name, envValue: process.env[name] }))
+            .map(({ name, envValue }) => envValue === undefined ? undefined : { name, envValue })
+            .filter((0,exclude/* exclude */.D)(undefined))
+            .map(({ name, envValue }) => `--env${SPACE_PLACEHOLDER}${name}='${envValue.replace(/'/g, "'\\''")}'`),
+        `${(_e = (_d = buildContext.startKeycloakOptions.dockerImage) === null || _d === void 0 ? void 0 : _d.reference) !== null && _e !== void 0 ? _e : "quay.io/keycloak/keycloak"}:${dockerImageTag}`,
+        "start-dev",
+        ...(21 <= keycloakMajorVersionNumber && keycloakMajorVersionNumber < 24
+            ? ["--features=declarative-user-profile"]
+            : []),
+        ...(realmJsonFilePath === undefined ? [] : ["--import-realm"]),
+        ...(buildContext.startKeycloakOptions.keycloakExtraArgs.length === 0
+            ? []
+            : [
+                buildContext.startKeycloakOptions.keycloakExtraArgs.join(SPACE_PLACEHOLDER)
+            ])
+    ];
+    console.log(source_default().blue([
+        `$ docker run \\`,
+        ...dockerRunArgs
+            .map(arg => arg.replace(new RegExp(SPACE_PLACEHOLDER, "g"), " "))
+            .map((line, i, arr) => `    ${line}${arr.length - 1 === i ? "" : " \\"}`)
+    ].join("\n")));
+    const child = external_child_process_.spawn("docker", ["run", ...dockerRunArgs.map(line => line.split(SPACE_PLACEHOLDER)).flat()], { shell: true });
+    child.stdout.on("data", async (data) => {
+        if (data.toString("utf8").includes("keycloakify-logging: REALM_CONFIG_CHANGED")) {
+            await onRealmConfigChange();
+            return;
+        }
+        process.stdout.write(data);
+    });
+    child.stderr.on("data", data => process.stderr.write(data));
+    child.on("exit", process.exit);
+    const srcDirPath = (0,external_path_.join)(buildContext.projectDirPath, "src");
+    {
+        const kcHttpRelativePath = (() => {
+            const match = buildContext.startKeycloakOptions.dockerExtraArgs
+                .join(" ")
+                .match(/KC_HTTP_RELATIVE_PATH=([^ ]+)/);
+            if (match === null) {
+                return undefined;
+            }
+            return match[1];
+        })();
+        const handler = async (data) => {
+            if (!data.toString("utf8").includes("Listening on: http://0.0.0.0:8080")) {
+                return;
+            }
+            child.stdout.off("data", handler);
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            console.log([
+                "",
+                `The ftl files from ${source_default().bold(`.${external_path_.sep}${(0,external_path_.relative)(process.cwd(), (0,external_path_.join)(buildContext.keycloakifyBuildDirPath, "theme"))}`)} are mounted in the Keycloak container.`,
+                "",
+                `Keycloak Admin console: ${source_default().cyan.bold(`http://localhost:${port}${kcHttpRelativePath !== null && kcHttpRelativePath !== void 0 ? kcHttpRelativePath : ""}`)}`,
+                `- user:     ${source_default().cyan.bold("admin")}`,
+                `- password: ${source_default().cyan.bold("admin")}`,
+                "",
+                "",
+                `${source_default().green("Your theme is accessible at:")}`,
+                `${source_default().green("➜")} ${source_default().cyan.bold((() => {
+                    const url = new URL(constants/* TEST_APP_URL */.jp);
+                    if (port !== 8080) {
+                        url.searchParams.set("port", `${port}`);
+                    }
+                    if (kcHttpRelativePath !== undefined) {
+                        url.searchParams.set("kcHttpRelativePath", kcHttpRelativePath);
+                    }
+                    if (realmName !== "myrealm") {
+                        url.searchParams.set("realm", realmName);
+                    }
+                    if (clientName !== "myclient") {
+                        url.searchParams.set("client", clientName);
+                    }
+                    return url.href;
+                })())}`,
+                "",
+                "You can login with the following credentials:",
+                `- username: ${source_default().cyan.bold(username)}`,
+                `- password: ${source_default().cyan.bold("password123")}`,
+                "",
+                `Watching for changes in ${source_default().bold(`.${external_path_.sep}${(0,external_path_.relative)(process.cwd(), buildContext.projectDirPath)}`)}`
+            ].join("\n"));
+        };
+        child.stdout.on("data", handler);
+    }
+    {
+        const runFullBuild = runExclusive.build(async () => {
+            console.log(source_default().cyan("Detected changes in the theme. Rebuilding ..."));
+            const { isAppBuildSuccess } = await appBuild({
+                buildContext
+            });
+            if (!isAppBuildSuccess) {
+                return;
+            }
+            const { isKeycloakifyBuildSuccess } = await keycloakifyBuild({
+                buildForKeycloakMajorVersionNumber: keycloakMajorVersionNumber,
+                buildContext
+            });
+            if (!isKeycloakifyBuildSuccess) {
+                return;
+            }
+            await extractThemeResourcesFromJar();
+            console.log(source_default().green("Theme rebuilt and updated in Keycloak."));
+        });
+        const { waitForDebounce } = (0,tools_waitForDebounce/* waitForDebounceFactory */.z)({ delay: 400 });
+        chokidar.watch([
+            srcDirPath,
+            buildContext.publicDirPath,
+            (0,external_path_.join)(buildContext.projectDirPath, "package.json"),
+            (0,external_path_.join)(buildContext.projectDirPath, "vite.config.ts"),
+            (0,external_path_.join)(buildContext.projectDirPath, "vite.config.js"),
+            (0,external_path_.join)(buildContext.projectDirPath, "index.html"),
+            (0,external_path_.join)((0,getThisCodebaseRootDirPath/* getThisCodebaseRootDirPath */.e)(), "src")
+        ], {
+            ignoreInitial: true
+        })
+            .on("all", async (...[, filePath]) => {
+            ignore_path_covered_by_hmr: {
+                if (filePath.endsWith(".properties")) {
+                    break ignore_path_covered_by_hmr;
+                }
+                if (!doStartDevServer) {
+                    break ignore_path_covered_by_hmr;
+                }
+                ignore_account_spa: {
+                    const doImplementAccountSpa = buildContext.implementedThemeTypes.account.isImplemented &&
+                        buildContext.implementedThemeTypes.account.type ===
+                            "Single-Page";
+                    if (!doImplementAccountSpa) {
+                        break ignore_account_spa;
+                    }
+                    if (!(0,isInside/* isInside */.V)({
+                        dirPath: (0,external_path_.join)(buildContext.themeSrcDirPath, "account"),
+                        filePath
+                    })) {
+                        break ignore_account_spa;
+                    }
+                    return;
+                }
+                ignore_admin: {
+                    if (!buildContext.implementedThemeTypes.admin.isImplemented) {
+                        break ignore_admin;
+                    }
+                    if (!(0,isInside/* isInside */.V)({
+                        dirPath: (0,external_path_.join)(buildContext.themeSrcDirPath, "admin"),
+                        filePath
+                    })) {
+                        break ignore_admin;
+                    }
+                    return;
+                }
+            }
+            console.log(`Detected changes in ${filePath}`);
+            await waitForDebounce();
+            runFullBuild();
+        });
     }
-    fs__WEBPACK_IMPORTED_MODULE_3__.writeFileSync(targetFilePath, Buffer.from(sourceCode, "utf8"));
-    console.log([
-        `${chalk__WEBPACK_IMPORTED_MODULE_6___default().green("✓")} ${chalk__WEBPACK_IMPORTED_MODULE_6___default().bold((0,path__WEBPACK_IMPORTED_MODULE_4__.join)(".", (0,path__WEBPACK_IMPORTED_MODULE_4__.relative)(process.cwd(), targetFilePath)))} copy pasted from the Keycloakify source code into your project`,
-        `You can start storybook with ${chalk__WEBPACK_IMPORTED_MODULE_6___default().bold("npm run storybook")}`
-    ].join("\n"));
 }
-//# sourceMappingURL=add-story.js.map
+//# sourceMappingURL=start-keycloak.js.map
+;// CONCATENATED MODULE: ./dist/bin/start-keycloak/index.js
+
+//# sourceMappingURL=index.js.map
 
 /***/ }),
 
-/***/ 72138:
+/***/ 12171:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "h": () => (/* binding */ SemVer)
+/* harmony export */ });
+var SemVer;
+(function (SemVer) {
+    const bumpTypes = ["major", "minor", "patch", "rc", "no bump"];
+    function parse(versionStr) {
+        const match = versionStr.match(/^v?([0-9]+)\.([0-9]+)(?:\.([0-9]+))?(?:-rc.([0-9]+))?$/);
+        if (!match) {
+            throw new Error(`${versionStr} is not a valid semantic version`);
+        }
+        const semVer = Object.assign({ major: parseInt(match[1]), minor: parseInt(match[2]), patch: (() => {
+                const str = match[3];
+                return str === undefined ? 0 : parseInt(str);
+            })() }, (() => {
+            const str = match[4];
+            return str === undefined ? {} : { rc: parseInt(str) };
+        })());
+        const initialStr = stringify(semVer);
+        Object.defineProperty(semVer, "parsedFrom", {
+            enumerable: true,
+            get: function () {
+                const currentStr = stringify(this);
+                if (currentStr !== initialStr) {
+                    throw new Error(`SemVer.parsedFrom can't be read anymore, the version have been modified from ${initialStr} to ${currentStr}`);
+                }
+                return versionStr;
+            }
+        });
+        return semVer;
+    }
+    SemVer.parse = parse;
+    function stringify(v) {
+        return `${v.major}.${v.minor}.${v.patch}${v.rc === undefined ? "" : `-rc.${v.rc}`}`;
+    }
+    SemVer.stringify = stringify;
+    /**
+     *
+     * v1  <  v2  => -1
+     * v1 === v2  => 0
+     * v1  >  v2  => 1
+     *
+     */
+    function compare(v1, v2) {
+        const sign = (diff) => (diff === 0 ? 0 : diff < 0 ? -1 : 1);
+        const noUndefined = (n) => n !== null && n !== void 0 ? n : Infinity;
+        for (const level of ["major", "minor", "patch", "rc"]) {
+            if (noUndefined(v1[level]) !== noUndefined(v2[level])) {
+                return sign(noUndefined(v1[level]) - noUndefined(v2[level]));
+            }
+        }
+        return 0;
+    }
+    SemVer.compare = compare;
+    /*
+    console.log(compare(parse("3.0.0-rc.3"), parse("3.0.0")) === -1 )
+    console.log(compare(parse("3.0.0-rc.3"), parse("3.0.0-rc.4")) === -1 )
+    console.log(compare(parse("3.0.0-rc.3"), parse("4.0.0")) === -1 )
+    */
+    function bumpType(params) {
+        const versionAhead = typeof params.versionAhead === "string"
+            ? parse(params.versionAhead)
+            : params.versionAhead;
+        const versionBehind = typeof params.versionBehind === "string"
+            ? parse(params.versionBehind)
+            : params.versionBehind;
+        if (compare(versionBehind, versionAhead) === 1) {
+            throw new Error(`Version regression ${stringify(versionBehind)} -> ${stringify(versionAhead)}`);
+        }
+        for (const level of ["major", "minor", "patch", "rc"]) {
+            if (versionBehind[level] !== versionAhead[level]) {
+                return level;
+            }
+        }
+        return "no bump";
+    }
+    SemVer.bumpType = bumpType;
+})(SemVer || (SemVer = {}));
+//# sourceMappingURL=SemVer.js.map
 
-// EXPORTS
-__webpack_require__.d(__webpack_exports__, {
-  "q": () => (/* binding */ maybeDelegateCommandToCustomHandler)
-});
-
-// EXTERNAL MODULE: ./node_modules/tsafe/esm/assert.mjs + 1 modules
-var esm_assert = __webpack_require__(29041);
-// EXTERNAL MODULE: ./dist/bin/shared/constants.js
-var constants = __webpack_require__(173);
-;// CONCATENATED MODULE: ./dist/bin/shared/customHandler.js
-
-
-const BIN_NAME = "_keycloakify-custom-handler";
-const NOT_IMPLEMENTED_EXIT_CODE = 78;
-function readParams(params) {
-    const { apiVersion } = params;
-    assert(apiVersion === "v1");
-    const commandName = (() => {
-        const envValue = process.env[CUSTOM_HANDLER_ENV_NAMES.COMMAND_NAME];
-        assert(envValue !== undefined);
-        return envValue;
-    })();
-    const buildContext = (() => {
-        const envValue = process.env[CUSTOM_HANDLER_ENV_NAMES.BUILD_CONTEXT];
-        assert(envValue !== undefined);
-        return JSON.parse(envValue);
-    })();
-    return { commandName, buildContext };
-}
-//# sourceMappingURL=customHandler.js.map
-// EXTERNAL MODULE: external "child_process"
-var external_child_process_ = __webpack_require__(32081);
-// EXTERNAL MODULE: ./dist/bin/tools/nodeModulesBinDirPath.js
-var tools_nodeModulesBinDirPath = __webpack_require__(73776);
-// EXTERNAL MODULE: external "fs"
-var external_fs_ = __webpack_require__(57147);
-;// CONCATENATED MODULE: ./dist/bin/shared/customHandler_delegate.js
-
-
-
+/***/ }),
 
+/***/ 43765:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "o": () => (/* binding */ existsAsync)
+/* harmony export */ });
+/* harmony import */ var fs_promises__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(73292);
+/* harmony import */ var fs_promises__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(fs_promises__WEBPACK_IMPORTED_MODULE_0__);
 
-(0,esm_assert/* assert */.h)();
-function maybeDelegateCommandToCustomHandler(params) {
-    const { commandName, buildContext } = params;
-    const nodeModulesBinDirPath = (0,tools_nodeModulesBinDirPath/* getNodeModulesBinDirPath */.K)();
-    if (!external_fs_.readdirSync(nodeModulesBinDirPath).includes(BIN_NAME)) {
-        return { hasBeenHandled: false };
-    }
+async function existsAsync(path) {
     try {
-        external_child_process_.execSync(`npx ${BIN_NAME}`, {
-            stdio: "inherit",
-            env: Object.assign(Object.assign({}, process.env), { [constants/* CUSTOM_HANDLER_ENV_NAMES.COMMAND_NAME */._S.COMMAND_NAME]: commandName, [constants/* CUSTOM_HANDLER_ENV_NAMES.BUILD_CONTEXT */._S.BUILD_CONTEXT]: JSON.stringify(buildContext) })
-        });
+        await fs_promises__WEBPACK_IMPORTED_MODULE_0__.stat(path);
+        return true;
     }
     catch (error) {
-        const status = error.status;
-        if (status === NOT_IMPLEMENTED_EXIT_CODE) {
-            return { hasBeenHandled: false };
-        }
-        process.exit(status);
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
     }
-    return { hasBeenHandled: true };
 }
-//# sourceMappingURL=customHandler_delegate.js.map
+//# sourceMappingURL=fs.existsAsync.js.map
 
 /***/ }),
 
-/***/ 17192:
+/***/ 90665:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   "A": () => (/* binding */ kebabCaseToCamelCase)
+/* harmony export */   "V": () => (/* binding */ isInside)
 /* harmony export */ });
-/* harmony import */ var tsafe_capitalize__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(14899);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(71017);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_0__);
 
-function kebabCaseToCamelCase(kebabCaseString) {
-    const [first, ...rest] = kebabCaseString.split("-");
-    return [first, ...rest.map(tsafe_capitalize__WEBPACK_IMPORTED_MODULE_0__/* .capitalize */ .k)].join("");
+function isInside(params) {
+    const { dirPath, filePath } = params;
+    return !(0,path__WEBPACK_IMPORTED_MODULE_0__.relative)(dirPath, filePath).startsWith("..");
 }
-//# sourceMappingURL=kebabCaseToSnakeCase.js.map
+//# sourceMappingURL=isInside.js.map
 
 /***/ }),
 
@@ -358,610 +2284,6 @@ async function runPrettier(params) {
 }
 //# sourceMappingURL=runPrettier.js.map
 
-/***/ }),
-
-/***/ 18512:
-/***/ ((module) => {
-
-
-const x = module.exports;
-const ESC = '\u001B[';
-const OSC = '\u001B]';
-const BEL = '\u0007';
-const SEP = ';';
-const isTerminalApp = process.env.TERM_PROGRAM === 'Apple_Terminal';
-
-x.cursorTo = (x, y) => {
-	if (typeof x !== 'number') {
-		throw new TypeError('The `x` argument is required');
-	}
-
-	if (typeof y !== 'number') {
-		return ESC + (x + 1) + 'G';
-	}
-
-	return ESC + (y + 1) + ';' + (x + 1) + 'H';
-};
-
-x.cursorMove = (x, y) => {
-	if (typeof x !== 'number') {
-		throw new TypeError('The `x` argument is required');
-	}
-
-	let ret = '';
-
-	if (x < 0) {
-		ret += ESC + (-x) + 'D';
-	} else if (x > 0) {
-		ret += ESC + x + 'C';
-	}
-
-	if (y < 0) {
-		ret += ESC + (-y) + 'A';
-	} else if (y > 0) {
-		ret += ESC + y + 'B';
-	}
-
-	return ret;
-};
-
-x.cursorUp = count => ESC + (typeof count === 'number' ? count : 1) + 'A';
-x.cursorDown = count => ESC + (typeof count === 'number' ? count : 1) + 'B';
-x.cursorForward = count => ESC + (typeof count === 'number' ? count : 1) + 'C';
-x.cursorBackward = count => ESC + (typeof count === 'number' ? count : 1) + 'D';
-
-x.cursorLeft = ESC + 'G';
-x.cursorSavePosition = ESC + (isTerminalApp ? '7' : 's');
-x.cursorRestorePosition = ESC + (isTerminalApp ? '8' : 'u');
-x.cursorGetPosition = ESC + '6n';
-x.cursorNextLine = ESC + 'E';
-x.cursorPrevLine = ESC + 'F';
-x.cursorHide = ESC + '?25l';
-x.cursorShow = ESC + '?25h';
-
-x.eraseLines = count => {
-	let clear = '';
-
-	for (let i = 0; i < count; i++) {
-		clear += x.eraseLine + (i < count - 1 ? x.cursorUp() : '');
-	}
-
-	if (count) {
-		clear += x.cursorLeft;
-	}
-
-	return clear;
-};
-
-x.eraseEndLine = ESC + 'K';
-x.eraseStartLine = ESC + '1K';
-x.eraseLine = ESC + '2K';
-x.eraseDown = ESC + 'J';
-x.eraseUp = ESC + '1J';
-x.eraseScreen = ESC + '2J';
-x.scrollUp = ESC + 'S';
-x.scrollDown = ESC + 'T';
-
-x.clearScreen = '\u001Bc';
-
-x.clearTerminal = process.platform === 'win32' ?
-	`${x.eraseScreen}${ESC}0f` :
-	// 1. Erases the screen (Only done in case `2` is not supported)
-	// 2. Erases the whole screen including scrollback buffer
-	// 3. Moves cursor to the top-left position
-	// More info: https://www.real-world-systems.com/docs/ANSIcode.html
-	`${x.eraseScreen}${ESC}3J${ESC}H`;
-
-x.beep = BEL;
-
-x.link = (text, url) => {
-	return [
-		OSC,
-		'8',
-		SEP,
-		SEP,
-		url,
-		BEL,
-		text,
-		OSC,
-		'8',
-		SEP,
-		SEP,
-		BEL
-	].join('');
-};
-
-x.image = (buf, opts) => {
-	opts = opts || {};
-
-	let ret = OSC + '1337;File=inline=1';
-
-	if (opts.width) {
-		ret += `;width=${opts.width}`;
-	}
-
-	if (opts.height) {
-		ret += `;height=${opts.height}`;
-	}
-
-	if (opts.preserveAspectRatio === false) {
-		ret += ';preserveAspectRatio=0';
-	}
-
-	return ret + ':' + buf.toString('base64') + BEL;
-};
-
-x.iTerm = {};
-
-x.iTerm.setCwd = cwd => OSC + '50;CurrentDir=' + (cwd || process.cwd()) + BEL;
-
-
-/***/ }),
-
-/***/ 39340:
-/***/ ((__unused_webpack_module, exports) => {
-
-
-
-Object.defineProperty(exports, "__esModule", ({
-  value: true
-}));
-exports.withPromise = exports.withCallback = void 0;
-
-/**
- * Open the input with a normal callback function
- *
- * @param {Input} input - input object
- * @param {function} valueMapper - function which maps the resulting id and value back to the expected format
- * @param {function} callback - callback function
- */
-const withCallback = (input, valueMapper, callback) => {
-  input.open();
-  input.onSelect((id, value) => callback(valueMapper(id, value)));
-};
-/**
- * Open the input with a promise
- *
- * @param {Input} input - input object
- * @param {function} valueMapper - function which maps the resulting id and value back to the expected format
- */
-
-
-exports.withCallback = withCallback;
-
-const withPromise = (input, valueMapper) => {
-  return new Promise((resolve, reject) => {
-    input.open();
-    input.onSelect((id, value) => {
-      if (id === null) {
-        reject();
-      } else {
-        resolve(valueMapper(id, value));
-      }
-    });
-  });
-};
-
-exports.withPromise = withPromise;
-
-/***/ }),
-
-/***/ 99398:
-/***/ ((module, exports, __webpack_require__) => {
-
-
-
-Object.defineProperty(exports, "__esModule", ({
-  value: true
-}));
-exports["default"] = void 0;
-
-var _input = _interopRequireDefault(__webpack_require__(25730));
-
-var _renderer = _interopRequireDefault(__webpack_require__(16059));
-
-var _callbackMappers = __webpack_require__(39340);
-
-var _valueMappers = __webpack_require__(26730);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-/**
- * Default options
- */
-const defaultOptions = {
-  outputStream: process.stdout,
-  inputStream: process.stdin,
-  values: [],
-  defaultValue: 0,
-  selected: '(x)',
-  unselected: '( )',
-  indentation: 0,
-  cleanup: true,
-  valueRenderer: value => value
-};
-/**
- * Create an instance of cli-select with the given options
- *
- * @param {object} options - options for cli-select
- * @param {function} callback - if specified, a callback will be used, otherwise a promise gets returned (optional)
- */
-
-const creator = (options, callback) => {
-  // merge options with default options
-  options = _objectSpread({}, defaultOptions, options); // create renderer and input instances
-
-  const renderer = new _renderer.default(options, options.outputStream);
-  const input = new _input.default(options.inputStream);
-  input.setDefaultValue(options.defaultValue);
-  input.attachRenderer(renderer); // handle array and object values
-
-  let valueMapper;
-
-  if (Array.isArray(options.values)) {
-    valueMapper = (0, _valueMappers.withArrayValues)(options);
-  } else {
-    valueMapper = (0, _valueMappers.withObjectValues)(options);
-  } // map values
-
-
-  options.values = valueMapper.input;
-  input.setValues(options.values); // handle different callback methods
-
-  if (typeof callback === 'function') {
-    return (0, _callbackMappers.withCallback)(input, valueMapper.output, callback);
-  } else {
-    return (0, _callbackMappers.withPromise)(input, valueMapper.output);
-  }
-};
-
-exports = module.exports = creator;
-Object.defineProperty(exports, "__esModule", ({
-  value: true
-}));
-var _default = creator;
-exports["default"] = _default;
-
-/***/ }),
-
-/***/ 25730:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-
-
-Object.defineProperty(exports, "__esModule", ({
-  value: true
-}));
-exports["default"] = void 0;
-
-var _readline = _interopRequireDefault(__webpack_require__(14521));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Handle cli input
- */
-class Input {
-  /**
-   * Input constructor
-   *
-   * @param {any} stream - stream to catch (optional)
-   */
-  constructor(stream = process.stdin) {
-    // set default values
-    this.stream = stream;
-    this.values = [];
-    this.selectedValue = 0;
-
-    this.onSelectListener = () => {};
-
-    this.onKeyPress = this.onKeyPress.bind(this);
-  }
-  /**
-   * Set the available values
-   *
-   * @param {array} values - all available values
-   */
-
-
-  setValues(values) {
-    this.values = values;
-
-    if (this.renderer) {
-      this.renderer.setValues(values);
-    }
-  }
-  /**
-   * Set the default value
-   *
-   * @param {number} defaultValue - default value id
-   */
-
-
-  setDefaultValue(defaultValue) {
-    this.selectedValue = defaultValue;
-  }
-  /**
-   * Attach a renderer to the input catcher
-   *
-   * @param {Renderer} renderer - renderer to use for rendering responses
-   */
-
-
-  attachRenderer(renderer) {
-    this.renderer = renderer;
-    this.renderer.setValues(this.values);
-  }
-  /**
-   * Register an on select listener
-   *
-   * @param {function} listener - listener function which receives two parameters: valueId and value
-   */
-
-
-  onSelect(listener) {
-    this.onSelectListener = listener;
-  }
-  /**
-   * Open the stream and listen for input
-   */
-
-
-  open() {
-    // register keypress event
-    _readline.default.emitKeypressEvents(this.stream); // handle keypress
-
-
-    this.stream.on('keypress', this.onKeyPress); // initially render the response
-
-    if (this.renderer) {
-      this.renderer.render(this.selectedValue);
-    } // hide pressed keys and start listening on input
-
-
-    this.stream.setRawMode(true);
-    this.stream.resume();
-  }
-  /**
-   * Close the stream
-   *
-   * @param {boolean} cancelled - true if no value was selected (optional)
-   */
-
-
-  close(cancelled = false) {
-    // reset stream properties
-    this.stream.setRawMode(false);
-    this.stream.pause(); // cleanup the output
-
-    if (this.renderer) {
-      this.renderer.cleanup();
-    } // call the on select listener
-
-
-    if (cancelled) {
-      this.onSelectListener(null);
-    } else {
-      this.onSelectListener(this.selectedValue, this.values[this.selectedValue]);
-    }
-
-    this.stream.removeListener('keypress', this.onKeyPress);
-  }
-  /**
-   * Render the response
-   */
-
-
-  render() {
-    if (!this.renderer) {
-      return;
-    }
-
-    this.renderer.render(this.selectedValue);
-  }
-  /**
-   * Handle key press event
-   *
-   * @param {string} string - input string
-   * @param {object} key - object containing information about the pressed key
-   */
-
-
-  onKeyPress(string, key) {
-    if (key) {
-      if (key.name === 'up' && this.selectedValue > 0) {
-        this.selectedValue--;
-        this.render();
-      } else if (key.name === 'down' && this.selectedValue + 1 < this.values.length) {
-        this.selectedValue++;
-        this.render();
-      } else if (key.name === 'return') {
-        this.close();
-      } else if (key.name === 'escape' || key.name === 'c' && key.ctrl) {
-        this.close(true);
-      }
-    }
-  }
-
-}
-
-exports["default"] = Input;
-
-/***/ }),
-
-/***/ 16059:
-/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
-
-
-
-Object.defineProperty(exports, "__esModule", ({
-  value: true
-}));
-exports["default"] = void 0;
-
-var _readline = _interopRequireDefault(__webpack_require__(14521));
-
-var _ansiEscapes = __webpack_require__(18512);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-/**
- * Response renderer
- */
-class Renderer {
-  /**
-   * Renderer constructor
-   *
-   * @param {object} options - renderer options
-   * @param {any} stream - stream to write to (optional)
-   */
-  constructor(options, stream = process.stdout) {
-    this.options = options;
-    this.stream = stream;
-    this.values = [];
-    this.initialRender = true;
-  }
-  /**
-   * Set the available values
-   *
-   * @param {array} values - all available values
-   */
-
-
-  setValues(values) {
-    this.values = values;
-  }
-  /**
-   * Render the values
-   *
-   * @param {number} selectedValue - selected value (optional)
-   */
-
-
-  render(selectedValue = 0) {
-    if (this.initialRender) {
-      // hide the cursor initially
-      this.initialRender = false;
-      this.stream.write(_ansiEscapes.cursorHide);
-    } else {
-      // remove previous lines and values
-      this.stream.write((0, _ansiEscapes.eraseLines)(this.values.length));
-    } // output the current values
-
-
-    this.values.forEach((value, index) => {
-      const symbol = selectedValue === index ? this.options.selected : this.options.unselected;
-      const indentation = ' '.repeat(this.options.indentation);
-      const renderedValue = this.options.valueRenderer(value, selectedValue === index);
-      const end = index !== this.values.length - 1 ? '\n' : '';
-      this.stream.write(indentation + symbol + ' ' + renderedValue + end);
-    });
-  }
-  /**
-   * Cleanup the console at the end
-   */
-
-
-  cleanup() {
-    this.stream.write((0, _ansiEscapes.eraseLines)(this.values.length));
-    this.stream.write(_ansiEscapes.cursorShow);
-  }
-
-}
-
-exports["default"] = Renderer;
-
-/***/ }),
-
-/***/ 26730:
-/***/ ((__unused_webpack_module, exports) => {
-
-
-
-Object.defineProperty(exports, "__esModule", ({
-  value: true
-}));
-exports.withObjectValues = exports.withArrayValues = void 0;
-
-/**
- * Map incoming and outgoing values if the initial values are an array
- *
- * @param {object} options - cli-select options
- */
-const withArrayValues = options => {
-  return {
-    input: options.values,
-    output: (id, value) => {
-      return {
-        id,
-        value
-      };
-    }
-  };
-};
-/**
- * Map incoming and outgoing values if the initial values are an object
- *
- * @param {object} options - cli-select options
- */
-
-
-exports.withArrayValues = withArrayValues;
-
-const withObjectValues = options => {
-  const originalValues = options.values;
-  return {
-    input: Object.values(originalValues),
-    output: (id, value) => {
-      return {
-        id: Object.keys(originalValues)[id],
-        value
-      };
-    }
-  };
-};
-
-exports.withObjectValues = withObjectValues;
-
-/***/ }),
-
-/***/ 14899:
-/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
-
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   "k": () => (/* binding */ capitalize)
-/* harmony export */ });
-/** @see <https://docs.tsafe.dev/capitalize> */
-function capitalize(str) {
-    return (str.charAt(0).toUpperCase() + str.slice(1));
-}
-
-
-//# sourceMappingURL=capitalize.mjs.map
-
-
-/***/ }),
-
-/***/ 76030:
-/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
-
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   "r": () => (/* binding */ symToStr)
-/* harmony export */ });
-/** @see <https://docs.tsafe.dev/main/symtostr> */
-function symToStr(wrap) {
-    // @ts-expect-error: We know better
-    return Object.keys(wrap)[0];
-}
-
-
-//# sourceMappingURL=symToStr.mjs.map
-
-
 /***/ })
 
 };