keycloakify 11.8.30 → 11.8.32

package/bin/97.index.js

@@ -3,1294 +3,101 @@ exports.id = 97;
 exports.ids = [97];
 exports.modules = {
 
-/***/ 64097:
+/***/ 77372:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
-// ESM COMPAT FLAG
-__webpack_require__.r(__webpack_exports__);
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
-  "command": () => (/* reexport */ command)
+  "x": () => (/* binding */ computeHash),
+  "f": () => (/* binding */ getExtensionModuleMetas)
 });
 
-// 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: ./node_modules/tsafe/esm/id.mjs
+var id = __webpack_require__(38469);
+// EXTERNAL MODULE: ./node_modules/zod/lib/index.mjs
+var lib = __webpack_require__(52300);
 // 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
-
-
-
+// EXTERNAL MODULE: ./dist/bin/tools/listInstalledModules.js
+var listInstalledModules = __webpack_require__(75564);
+;// CONCATENATED MODULE: ./dist/bin/tools/crawlAsync.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;
+/** List all files in a given directory return paths relative to the dir_path */
+async function crawlAsync(params) {
+    const { dirPath, returnedPathsType, onFileFound } = params;
+    await crawlAsyncRec({
+        dirPath,
+        onFileFound: async ({ filePath }) => {
+            switch (returnedPathsType) {
+                case "absolute":
+                    await onFileFound(filePath);
+                    return;
+                case "relative to dirPath":
+                    await onFileFound((0,external_path_.relative)(dirPath, filePath));
+                    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
-
-
-
-
-
-
-
-
-
-
-(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")) {
+async function crawlAsyncRec(params) {
+    const { dirPath, onFileFound } = params;
+    await Promise.all((await promises_.readdir(dirPath)).map(async (basename) => {
+        const fileOrDirPath = (0,external_path_.join)(dirPath, basename);
+        const isDirectory = await promises_.lstat(fileOrDirPath)
+            .then(stat => stat.isDirectory());
+        if (isDirectory) {
+            await crawlAsyncRec({ dirPath: fileOrDirPath, onFileFound });
             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
-        })
-    });
+        await onFileFound({ filePath: fileOrDirPath });
+    }));
 }
-//# sourceMappingURL=defaultConfig.js.map
-;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/defaultConfig/index.js
-
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=crawlAsync.js.map
+// EXTERNAL MODULE: ./dist/bin/tools/runPrettier.js
+var runPrettier = __webpack_require__(48433);
 // 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 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/evt/tools/inDepth/same.js
-var same = __webpack_require__(33805);
-;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/prepareRealmConfig.js
-
-
-
-
-function prepareRealmConfig(params) {
-    const { parsedRealmJson, keycloakMajorVersionNumber, parsedKeycloakThemesJsonEntry } = params;
-    const { username } = addOrEditTestUser({
-        parsedRealmJson,
-        keycloakMajorVersionNumber
-    });
-    const { clientId } = addOrEditClient({
-        parsedRealmJson,
-        keycloakMajorVersionNumber
-    });
-    editAccountConsoleAndSecurityAdminConsole({ parsedRealmJson });
-    enableCustomThemes({
-        parsedRealmJson,
-        parsedKeycloakThemesJsonEntry
-    });
-    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, parsedKeycloakThemesJsonEntry } = params;
-    for (const themeType of [...constants/* THEME_TYPES */.Jh, "email"]) {
-        parsedRealmJson[`${themeType}Theme`] =
-            !parsedKeycloakThemesJsonEntry.types.includes(themeType)
-                ? ""
-                : parsedKeycloakThemesJsonEntry.name;
-    }
-}
-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;
-    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);
-            }
+// EXTERNAL MODULE: ./dist/bin/sync-extensions/getExtensionModuleFileSourceCodeReadyToBeCopied.js
+var getExtensionModuleFileSourceCodeReadyToBeCopied = __webpack_require__(2237);
+// EXTERNAL MODULE: external "crypto"
+var external_crypto_ = __webpack_require__(6113);
+// EXTERNAL MODULE: ./dist/bin/shared/constants.js
+var constants = __webpack_require__(173);
+// EXTERNAL MODULE: ./node_modules/tsafe/esm/exclude.mjs
+var exclude = __webpack_require__(83101);
+;// CONCATENATED MODULE: ./node_modules/tsafe/esm/isAmong.mjs
+/** https://docs.tsafe.dev/isamong */
+function isAmong(names, value) {
+    for (const name of names) {
+        if (name === value) {
+            return true;
         }
     }
+    return false;
 }
-//# sourceMappingURL=prepareRealmConfig.js.map
-// EXTERNAL MODULE: ./dist/bin/tools/runPrettier.js
-var runPrettier = __webpack_require__(48433);
-;// CONCATENATED MODULE: ./dist/bin/tools/Stringifyable.js
+
+
+//# sourceMappingURL=isAmong.mjs.map
+
+;// CONCATENATED MODULE: ./dist/bin/sync-extensions/extensionModuleMeta.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
 
 
 
@@ -1298,242 +105,418 @@ async function writeRealmJsonFile(params) {
 
 
 
+const zExtensionModuleMeta = (() => {
+    const zTargetType = lib.z.object({
+        moduleName: lib.z.string(),
+        version: lib.z.string(),
+        files: lib.z.array(lib.z.object({
+            fileRelativePath: lib.z.string(),
+            hash: lib.z.string(),
+            copyableFilePath: lib.z.string()
+        })),
+        peerDependencies: lib.z.record(lib.z.string())
+    });
+    (0,assert/* assert */.h)();
+    return (0,id.id)(zTargetType);
+})();
+const zParsedCacheFile = (() => {
+    const zTargetType = lib.z.object({
+        keycloakifyVersion: lib.z.string(),
+        prettierConfigHash: lib.z.union([lib.z.string(), lib.z["null"]()]),
+        thisFilePath: lib.z.string(),
+        extensionModuleMetas: lib.z.array(zExtensionModuleMeta)
+    });
+    (0,assert/* assert */.h)();
+    return (0,id.id)(zTargetType);
+})();
+const CACHE_FILE_RELATIVE_PATH = (0,external_path_.join)("extension-modules", "cache.json");
 (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();
+async function getExtensionModuleMetas(params) {
+    const { buildContext } = params;
+    const cacheFilePath = (0,external_path_.join)(buildContext.cacheDirPath, CACHE_FILE_RELATIVE_PATH);
+    const keycloakifyVersion = (0,readThisNpmPackageVersion/* readThisNpmPackageVersion */.K)();
+    const prettierConfigHash = await (async () => {
+        if (!(await (0,runPrettier/* getIsPrettierAvailable */.MT)())) {
+            return null;
+        }
+        const { configHash } = await (0,runPrettier/* getPrettier */.LG)();
+        return configHash;
+    })();
+    const installedExtensionModules = await (async () => {
+        const installedModulesWithKeycloakifyInTheName = await (0,listInstalledModules/* listInstalledModules */.P)({
+            packageJsonFilePath: buildContext.packageJsonFilePath,
+            filter: ({ moduleName }) => moduleName.includes("keycloakify") && moduleName !== "keycloakify"
         });
-        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 (await Promise.all(installedModulesWithKeycloakifyInTheName.map(async (entry) => {
+            if (!(await (0,fs_existsAsync/* existsAsync */.o)((0,external_path_.join)(entry.dirPath, constants/* KEYCLOAK_THEME */.PC)))) {
+                return undefined;
+            }
+            return entry;
+        }))).filter((0,exclude/* exclude */.D)(undefined));
+    })();
+    const cacheContent = await (async () => {
+        if (!(await (0,fs_existsAsync/* existsAsync */.o)(cacheFilePath))) {
+            return undefined;
         }
-    }
-    {
-        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);
+        return await promises_.readFile(cacheFilePath);
+    })();
+    const extensionModuleMetas_cacheUpToDate = await (async () => {
+        const parsedCacheFile = await (async () => {
+            if (cacheContent === undefined) {
+                return undefined;
             }
-            output += outputStr;
-        });
-        child.stderr.on("data", data => (output += source_default().red(data.toString("utf8"))));
-        try {
-            await dCompleted.pr;
+            const cacheContentStr = cacheContent.toString("utf8");
+            let parsedCacheFile;
+            try {
+                parsedCacheFile = JSON.parse(cacheContentStr);
+            }
+            catch (_a) {
+                return undefined;
+            }
+            try {
+                zParsedCacheFile.parse(parsedCacheFile);
+            }
+            catch (_b) {
+                return undefined;
+            }
+            (0,assert/* assert */.h)((0,assert.is)(parsedCacheFile));
+            return parsedCacheFile;
+        })();
+        if (parsedCacheFile === undefined) {
+            return [];
         }
-        catch (error) {
-            (0,assert/* assert */.h)((0,assert.is)(error));
-            console.log(source_default().red(error.message));
-            console.log(output);
-            throw error;
+        if (parsedCacheFile.keycloakifyVersion !== keycloakifyVersion) {
+            return [];
         }
-    }
-    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;
+        if (parsedCacheFile.prettierConfigHash !== prettierConfigHash) {
+            return [];
+        }
+        if (parsedCacheFile.thisFilePath !== cacheFilePath) {
+            return [];
+        }
+        const extensionModuleMetas_cacheUpToDate = parsedCacheFile.extensionModuleMetas.filter(extensionModuleMeta => {
+            const correspondingInstalledExtensionModule = installedExtensionModules.find(installedExtensionModule => installedExtensionModule.moduleName ===
+                extensionModuleMeta.moduleName);
+            if (correspondingInstalledExtensionModule === undefined) {
+                return false;
             }
-            dCompleted.resolve();
+            return (correspondingInstalledExtensionModule.version ===
+                extensionModuleMeta.version);
         });
-        try {
-            await dCompleted.pr;
+        return extensionModuleMetas_cacheUpToDate;
+    })();
+    const extensionModuleMetas = await Promise.all(installedExtensionModules.map(async ({ moduleName, version, peerDependencies, dirPath }) => {
+        use_cache: {
+            const extensionModuleMeta_cache = extensionModuleMetas_cacheUpToDate.find(extensionModuleMeta => extensionModuleMeta.moduleName === moduleName);
+            if (extensionModuleMeta_cache === undefined) {
+                break use_cache;
+            }
+            return extensionModuleMeta_cache;
         }
-        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 files = [];
+        {
+            const srcDirPath = (0,external_path_.join)(dirPath, constants/* KEYCLOAK_THEME */.PC);
+            await crawlAsync({
+                dirPath: srcDirPath,
+                returnedPathsType: "relative to dirPath",
+                onFileFound: async (fileRelativePath) => {
+                    const sourceCode = await (0,getExtensionModuleFileSourceCodeReadyToBeCopied/* getExtensionModuleFileSourceCodeReadyToBeCopied */.p)({
+                        buildContext,
+                        fileRelativePath,
+                        isOwnershipAction: false,
+                        extensionModuleDirPath: dirPath,
+                        extensionModuleName: moduleName,
+                        extensionModuleVersion: version
+                    });
+                    const hash = computeHash(sourceCode);
+                    const copyableFilePath = (0,external_path_.join)((0,external_path_.dirname)(cacheFilePath), constants/* KEYCLOAK_THEME */.PC, fileRelativePath);
+                    {
+                        const dirPath = (0,external_path_.dirname)(copyableFilePath);
+                        if (!(await (0,fs_existsAsync/* existsAsync */.o)(dirPath))) {
+                            await promises_.mkdir(dirPath, { recursive: true });
+                        }
+                    }
+                    promises_.writeFile(copyableFilePath, sourceCode);
+                    files.push({
+                        fileRelativePath,
+                        hash,
+                        copyableFilePath
+                    });
+                }
+            });
         }
-    }
-    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();
+        return (0,id.id)({
+            moduleName,
+            version,
+            files,
+            peerDependencies: Object.fromEntries(Object.entries(peerDependencies).filter(([moduleName]) => !isAmong(["react", "@types/react"], moduleName)))
         });
-        try {
-            await dCompleted.pr;
+    }));
+    update_cache: {
+        const parsedCacheFile = (0,id.id)({
+            keycloakifyVersion,
+            prettierConfigHash,
+            thisFilePath: cacheFilePath,
+            extensionModuleMetas
+        });
+        const cacheContent_new = Buffer.from(JSON.stringify(parsedCacheFile, null, 2), "utf8");
+        if (cacheContent !== undefined && cacheContent_new.equals(cacheContent)) {
+            break update_cache;
         }
-        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;
+        create_dir: {
+            const dirPath = (0,external_path_.dirname)(cacheFilePath);
+            if (await (0,fs_existsAsync/* existsAsync */.o)(dirPath)) {
+                break create_dir;
+            }
+            await promises_.mkdir(dirPath, { recursive: true });
         }
+        await promises_.writeFile(cacheFilePath, cacheContent_new);
     }
-    return readRealmJsonFile({
-        realmJsonFilePath: targetRealmConfigJsonFilePath_tmp
-    });
+    return extensionModuleMetas;
 }
-//# sourceMappingURL=dumpContainerConfig.js.map
-;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/realmConfig.js
-
-
-
+function computeHash(data) {
+    return external_crypto_.createHash("sha256").update(data).digest("hex");
+}
+//# sourceMappingURL=extensionModuleMeta.js.map
 
+/***/ }),
 
+/***/ 2237:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "p": () => (/* binding */ getExtensionModuleFileSourceCodeReadyToBeCopied)
+/* harmony export */ });
+/* harmony import */ var _tools_runPrettier__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(48433);
+/* harmony import */ var fs_promises__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(73292);
+/* harmony import */ var fs_promises__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(fs_promises__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(71017);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var tsafe_assert__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(29041);
+/* harmony import */ var _shared_constants__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(173);
 
 
 
 
 
-assert/* assert */.h;
-async function getRealmConfig(params) {
-    const { keycloakMajorVersionNumber, realmJsonFilePath_userProvided, parsedKeycloakThemesJsonEntry, 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,
-        keycloakMajorVersionNumber,
-        parsedKeycloakThemesJsonEntry
-    });
-    {
-        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
+(0,tsafe_assert__WEBPACK_IMPORTED_MODULE_3__/* .assert */ .h)();
+async function getExtensionModuleFileSourceCodeReadyToBeCopied(params) {
+    const { buildContext, extensionModuleDirPath, fileRelativePath, isOwnershipAction, extensionModuleName, extensionModuleVersion } = params;
+    let sourceCode = (await fs_promises__WEBPACK_IMPORTED_MODULE_1__.readFile((0,path__WEBPACK_IMPORTED_MODULE_2__.join)(extensionModuleDirPath, _shared_constants__WEBPACK_IMPORTED_MODULE_4__/* .KEYCLOAK_THEME */ .PC, fileRelativePath))).toString("utf8");
+    sourceCode = addCommentToSourceCode({
+        sourceCode,
+        fileRelativePath,
+        commentLines: (() => {
+            const path = fileRelativePath.split(path__WEBPACK_IMPORTED_MODULE_2__.sep).join("/");
+            return isOwnershipAction
+                ? [
+                    `This file has been claimed for ownership from ${extensionModuleName} version ${extensionModuleVersion}.`,
+                    `To relinquish ownership and restore this file to its original content, run the following command:`,
+                    ``,
+                    `$ npx keycloakify own --path "${path}" --revert`
+                ]
+                : [
+                    `WARNING: Before modifying this file, run the following command:`,
+                    ``,
+                    `$ npx keycloakify own --path "${path}"`,
+                    ``,
+                    `This file is provided by ${extensionModuleName} version ${extensionModuleVersion}.`,
+                    `It was copied into your repository by the postinstall script: \`keycloakify sync-extensions\`.`
+                ];
+        })()
     });
-    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
+    const destFilePath = (0,path__WEBPACK_IMPORTED_MODULE_2__.join)(buildContext.themeSrcDirPath, fileRelativePath);
+    format: {
+        if (!(await (0,_tools_runPrettier__WEBPACK_IMPORTED_MODULE_0__/* .getIsPrettierAvailable */ .MT)())) {
+            break format;
+        }
+        sourceCode = await (0,_tools_runPrettier__WEBPACK_IMPORTED_MODULE_0__/* .runPrettier */ .eY)({
+            filePath: destFilePath,
+            sourceCode
         });
-        async function onRealmConfigChange() {
-            await waitForDebounce();
-            run();
-        }
-        return { onRealmConfigChange };
-    })();
-    return {
-        realmJsonFilePath,
-        clientName,
-        realmName,
-        username,
-        onRealmConfigChange
+    }
+    return Buffer.from(sourceCode, "utf8");
+}
+function addCommentToSourceCode(params) {
+    const { sourceCode, fileRelativePath, commentLines } = params;
+    const toResult = (comment) => {
+        return [comment, ``, sourceCode].join("\n");
     };
+    for (const ext of [".ts", ".tsx", ".css", ".less", ".sass", ".js", ".jsx"]) {
+        if (!fileRelativePath.endsWith(ext)) {
+            continue;
+        }
+        return toResult([`/**`, ...commentLines.map(line => ` * ${line}`), ` */`].join("\n"));
+    }
+    if (fileRelativePath.endsWith(".properties")) {
+        return toResult(commentLines.map(line => `# ${line}`).join("\n"));
+    }
+    if (fileRelativePath.endsWith(".ftl")) {
+        const comment = [`<#--`, ...commentLines.map(line => `  ${line}`), `-->`].join("\n");
+        if (sourceCode.trim().startsWith("<#ftl")) {
+            const [first, ...rest] = sourceCode.split(">");
+            const last = rest.join(">");
+            return [`${first}>`, comment, last].join("\n");
+        }
+        return toResult(comment);
+    }
+    if (fileRelativePath.endsWith(".html") || fileRelativePath.endsWith(".svg")) {
+        const comment = [
+            `<!--`,
+            ...commentLines.map(line => ` ${line
+                .replace("--path", "-t")
+                .replace("--revert", "-r")
+                .replace("Before modifying", "Before modifying or replacing")}`),
+            `-->`
+        ].join("\n");
+        if (fileRelativePath.endsWith(".html") && sourceCode.trim().startsWith("<!")) {
+            const [first, ...rest] = sourceCode.split(">");
+            const last = rest.join(">");
+            return [`${first}>`, comment, last].join("\n");
+        }
+        if (fileRelativePath.endsWith(".svg") && sourceCode.trim().startsWith("<?")) {
+            const [first, ...rest] = sourceCode.split("?>");
+            const last = rest.join("?>");
+            return [`${first}?>`, comment, last].join("\n");
+        }
+        return toResult(comment);
+    }
+    return sourceCode;
 }
-//# 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
-
-
-
-
+//# sourceMappingURL=getExtensionModuleFileSourceCodeReadyToBeCopied.js.map
 
+/***/ }),
 
+/***/ 69674:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "Y": () => (/* binding */ writeManagedGitignoreFile),
+/* harmony export */   "w": () => (/* binding */ readManagedGitignoreFile)
+/* 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__);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(71017);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var tsafe_assert__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(29041);
+/* harmony import */ var _tools_fs_existsAsync__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(43765);
+/* harmony import */ var _tools_getAbsoluteAndInOsFormatPath__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(84794);
 
 
 
 
 
+(0,tsafe_assert__WEBPACK_IMPORTED_MODULE_2__/* .assert */ .h)();
+const DELIMITER_START = `# === Owned files start ===`;
+const DELIMITER_END = `# === Owned files end =====`;
+async function writeManagedGitignoreFile(params) {
+    const { buildContext, extensionModuleMetas, ownedFilesRelativePaths } = params;
+    if (extensionModuleMetas.length === 0) {
+        return;
+    }
+    const filePath = (0,path__WEBPACK_IMPORTED_MODULE_1__.join)(buildContext.themeSrcDirPath, ".gitignore");
+    const content_new = Buffer.from([
+        `# This file is managed by Keycloakify, do not edit it manually.`,
+        ``,
+        DELIMITER_START,
+        ...ownedFilesRelativePaths
+            .map(fileRelativePath => fileRelativePath.split(path__WEBPACK_IMPORTED_MODULE_1__.sep).join("/"))
+            .map(line => `# ${line}`),
+        DELIMITER_END,
+        ``,
+        ...extensionModuleMetas
+            .map(extensionModuleMeta => [
+            `# === ${extensionModuleMeta.moduleName} v${extensionModuleMeta.version} ===`,
+            ...extensionModuleMeta.files
+                .map(({ fileRelativePath }) => fileRelativePath)
+                .filter(fileRelativePath => !ownedFilesRelativePaths.includes(fileRelativePath))
+                .map(fileRelativePath => `/${fileRelativePath.split(path__WEBPACK_IMPORTED_MODULE_1__.sep).join("/").replace(/^\.\//, "")}`),
+            ``
+        ])
+            .flat()
+    ].join("\n"), "utf8");
+    const content_current = await (async () => {
+        if (!(await (0,_tools_fs_existsAsync__WEBPACK_IMPORTED_MODULE_3__/* .existsAsync */ .o)(filePath))) {
+            return undefined;
+        }
+        return await fs_promises__WEBPACK_IMPORTED_MODULE_0__.readFile(filePath);
+    })();
+    if (content_current !== undefined && content_current.equals(content_new)) {
+        return;
+    }
+    create_dir: {
+        const dirPath = (0,path__WEBPACK_IMPORTED_MODULE_1__.dirname)(filePath);
+        if (await (0,_tools_fs_existsAsync__WEBPACK_IMPORTED_MODULE_3__/* .existsAsync */ .o)(dirPath)) {
+            break create_dir;
+        }
+        await fs_promises__WEBPACK_IMPORTED_MODULE_0__.mkdir(dirPath, { recursive: true });
+    }
+    await fs_promises__WEBPACK_IMPORTED_MODULE_0__.writeFile(filePath, content_new);
+}
+async function readManagedGitignoreFile(params) {
+    const { buildContext } = params;
+    const filePath = (0,path__WEBPACK_IMPORTED_MODULE_1__.join)(buildContext.themeSrcDirPath, ".gitignore");
+    if (!(await (0,_tools_fs_existsAsync__WEBPACK_IMPORTED_MODULE_3__/* .existsAsync */ .o)(filePath))) {
+        return { ownedFilesRelativePaths: [] };
+    }
+    const contentStr = (await fs_promises__WEBPACK_IMPORTED_MODULE_0__.readFile(filePath)).toString("utf8");
+    const payload = (() => {
+        const index_start = contentStr.indexOf(DELIMITER_START);
+        const index_end = contentStr.indexOf(DELIMITER_END);
+        if (index_start === -1 || index_end === -1) {
+            return undefined;
+        }
+        return contentStr.slice(index_start + DELIMITER_START.length, index_end).trim();
+    })();
+    if (payload === undefined) {
+        return { ownedFilesRelativePaths: [] };
+    }
+    const ownedFilesRelativePaths = payload
+        .split("\n")
+        .map(line => line.trim())
+        .map(line => line.replace(/^# /, ""))
+        .filter(line => line !== "")
+        .map(line => (0,_tools_getAbsoluteAndInOsFormatPath__WEBPACK_IMPORTED_MODULE_4__/* .getAbsoluteAndInOsFormatPath */ .c)({
+        cwd: buildContext.themeSrcDirPath,
+        pathIsh: line
+    }))
+        .map(filePath => (0,path__WEBPACK_IMPORTED_MODULE_1__.relative)(buildContext.themeSrcDirPath, filePath));
+    return { ownedFilesRelativePaths };
+}
+//# sourceMappingURL=managedGitignoreFile.js.map
 
+/***/ }),
 
+/***/ 91097:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "W": () => (/* binding */ command)
+});
 
+// EXTERNAL MODULE: ./dist/bin/sync-extensions/extensionModuleMeta.js + 2 modules
+var sync_extensions_extensionModuleMeta = __webpack_require__(77372);
+// EXTERNAL MODULE: ./node_modules/tsafe/esm/assert.mjs + 1 modules
+var assert = __webpack_require__(29041);
+// EXTERNAL MODULE: ./node_modules/zod/lib/index.mjs
+var lib = __webpack_require__(52300);
+// EXTERNAL MODULE: ./node_modules/tsafe/esm/id.mjs
+var id = __webpack_require__(38469);
+// EXTERNAL MODULE: external "fs/promises"
+var promises_ = __webpack_require__(73292);
+// EXTERNAL MODULE: ./dist/bin/tools/SemVer.js
+var SemVer = __webpack_require__(12171);
+// EXTERNAL MODULE: ./node_modules/evt/tools/inDepth/same.js
+var same = __webpack_require__(33805);
+// EXTERNAL MODULE: ./dist/bin/tools/runPrettier.js
+var runPrettier = __webpack_require__(48433);
+// EXTERNAL MODULE: ./dist/bin/tools/npmInstall.js + 1 modules
+var npmInstall = __webpack_require__(63046);
+// EXTERNAL MODULE: external "path"
+var external_path_ = __webpack_require__(71017);
+;// CONCATENATED MODULE: ./dist/bin/sync-extensions/installExtensionModulesPeerDependencies.js
 
 
 
@@ -1543,512 +526,211 @@ async function getRealmConfig(params) {
 
 
 
-async function command(params) {
-    var _a, _b, _c, _d;
-    exit_if_docker_not_installed: {
-        let commandOutput = undefined;
-        try {
-            commandOutput = external_child_process_.execSync("docker --version", {
-                stdio: ["ignore", "pipe", "ignore"]
-            })
-                .toString("utf8");
-        }
-        catch (_e) {
-            commandOutput = "";
-        }
-        commandOutput = commandOutput.trim().toLowerCase();
-        for (const term of ["docker", "podman"]) {
-            if (commandOutput.includes(term)) {
-                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 (_f) {
-            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
-    });
-    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;
+(0,assert/* assert */.h)();
+(0,assert/* assert */.h)();
+async function installExtensionModulesPeerDependencies(params) {
+    var _a, _b;
+    const { buildContext, extensionModuleMetas } = params;
+    const { extensionModulesPerDependencies } = (() => {
+        const extensionModulesPerDependencies = {};
+        for (const { peerDependencies } of extensionModuleMetas) {
+            for (const [peerDependencyName, versionRange_candidate] of Object.entries(peerDependencies)) {
+                const versionRange = (() => {
+                    const versionRange_current = extensionModulesPerDependencies[peerDependencyName];
+                    if (versionRange_current === undefined) {
+                        return versionRange_candidate;
                     }
-                }
-                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;
+                    if (versionRange_current === "*") {
+                        return versionRange_candidate;
                     }
-                }
-                {
-                    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;
+                    if (versionRange_candidate === "*") {
+                        return versionRange_current;
                     }
-                }
-                break;
-            }
-            return tag;
-        })();
-        console.log(`→ ${tag_userSelected}`);
-        return { dockerImageTag: tag_userSelected };
+                    const { versionRange } = [
+                        versionRange_current,
+                        versionRange_candidate
+                    ]
+                        .map(versionRange => ({
+                        versionRange,
+                        semVer: SemVer/* SemVer.parse */.h.parse((() => {
+                            if (versionRange.startsWith("^") ||
+                                versionRange.startsWith("~")) {
+                                return versionRange.slice(1);
+                            }
+                            return versionRange;
+                        })())
+                    }))
+                        .sort((a, b) => SemVer/* SemVer.compare */.h.compare(b.semVer, a.semVer))[0];
+                    return versionRange;
+                })();
+                extensionModulesPerDependencies[peerDependencyName] = versionRange;
+            }
+        }
+        return { extensionModulesPerDependencies };
     })();
-    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 parsedPackageJson = await (async () => {
+        const zParsedPackageJson = (() => {
+            const zParsedPackageJson = lib.z.object({
+                dependencies: lib.z.record(lib.z.string()).optional(),
+                devDependencies: lib.z.record(lib.z.string()).optional()
+            });
+            (0,assert/* assert */.h)();
+            return (0,id.id)(zParsedPackageJson);
+        })();
+        const parsedPackageJson = JSON.parse((await promises_.readFile(buildContext.packageJsonFilePath)).toString("utf8"));
+        zParsedPackageJson.parse(parsedPackageJson);
+        (0,assert/* assert */.h)((0,assert.is)(parsedPackageJson));
+        return parsedPackageJson;
     })();
-    {
-        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);
+    const parsedPackageJson_before = JSON.parse(JSON.stringify(parsedPackageJson));
+    for (const [moduleName, versionRange] of Object.entries(extensionModulesPerDependencies)) {
+        if (moduleName.startsWith("@types/")) {
+            ((_a = parsedPackageJson.devDependencies) !== null && _a !== void 0 ? _a : (parsedPackageJson.devDependencies = {}))[moduleName] = versionRange;
+            continue;
         }
-        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);
+        if (parsedPackageJson.devDependencies !== undefined) {
+            delete parsedPackageJson.devDependencies[moduleName];
         }
+        ((_b = parsedPackageJson.dependencies) !== null && _b !== void 0 ? _b : (parsedPackageJson.dependencies = {}))[moduleName] = versionRange;
     }
-    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);
-        })))
-    ];
-    let parsedKeycloakThemesJson = (0,id.id)(undefined);
-    async function extractThemeResourcesFromJar() {
-        await extractArchive({
-            archiveFilePath: jarFilePath,
-            onArchiveFile: async ({ relativeFilePathInArchive, writeFile, readFile }) => {
-                if (relativeFilePathInArchive ===
-                    (0,external_path_.join)("META-INF", "keycloak-themes.json") &&
-                    parsedKeycloakThemesJson === undefined) {
-                    parsedKeycloakThemesJson = JSON.parse((await readFile()).toString("utf8"));
-                }
-                if ((0,isInside/* isInside */.V)({ dirPath: "theme", filePath: relativeFilePathInArchive })) {
-                    await writeFile({
-                        filePath: (0,external_path_.join)(buildContext.keycloakifyBuildDirPath, relativeFilePathInArchive)
-                    });
-                }
-            }
-        });
+    if ((0,same.same)(parsedPackageJson, parsedPackageJson_before)) {
+        return;
     }
-    {
-        const destDirPath = (0,external_path_.join)(buildContext.keycloakifyBuildDirPath, "theme");
-        if (await (0,fs_existsAsync/* existsAsync */.o)(destDirPath)) {
-            await rm(destDirPath, { recursive: true });
+    let packageJsonContentStr = JSON.stringify(parsedPackageJson, null, 2);
+    format: {
+        if (!(await (0,runPrettier/* getIsPrettierAvailable */.MT)())) {
+            break format;
         }
+        packageJsonContentStr = await (0,runPrettier/* runPrettier */.eY)({
+            sourceCode: packageJsonContentStr,
+            filePath: buildContext.packageJsonFilePath
+        });
     }
-    await extractThemeResourcesFromJar();
-    (0,assert/* assert */.h)(parsedKeycloakThemesJson !== undefined);
-    const { clientName, onRealmConfigChange, realmJsonFilePath, realmName, username } = await getRealmConfig({
-        keycloakMajorVersionNumber,
-        parsedKeycloakThemesJsonEntry: (() => {
-            const entry = parsedKeycloakThemesJson.themes.find(({ name }) => name === buildContext.themeNames[0]);
-            (0,assert/* assert */.h)(entry !== undefined);
-            return entry;
-        })(),
-        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
+    await promises_.writeFile(buildContext.packageJsonFilePath, packageJsonContentStr);
+    await (0,npmInstall/* npmInstall */.c)({
+        packageJsonDirPath: (0,external_path_.dirname)(buildContext.packageJsonFilePath)
     });
-    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"
-        });
+    process.exit(0);
+}
+//# sourceMappingURL=installExtensionModulesPeerDependencies.js.map
+// EXTERNAL MODULE: ./dist/bin/sync-extensions/managedGitignoreFile.js
+var managedGitignoreFile = __webpack_require__(69674);
+// EXTERNAL MODULE: ./dist/bin/tools/fs.existsAsync.js
+var fs_existsAsync = __webpack_require__(43765);
+// EXTERNAL MODULE: external "child_process"
+var external_child_process_ = __webpack_require__(32081);
+// EXTERNAL MODULE: ./node_modules/evt/tools/Deferred.js
+var Deferred = __webpack_require__(50689);
+// EXTERNAL MODULE: external "fs"
+var external_fs_ = __webpack_require__(57147);
+// EXTERNAL MODULE: ./node_modules/run-exclusive/lib/runExclusive.js
+var runExclusive = __webpack_require__(81708);
+;// CONCATENATED MODULE: ./dist/bin/tools/gitUtils.js
+
+
+
+
+
+
+const groupRef = runExclusive.createGroupRef();
+const getIsKnownByGit = runExclusive.build(groupRef, (params) => {
+    const { filePath } = params;
+    const dIsKnownByGit = new Deferred.Deferred();
+    let relativePath = (0,external_path_.basename)(filePath);
+    let dirPath = (0,external_path_.dirname)(filePath);
+    while (!external_fs_.existsSync(dirPath)) {
+        relativePath = (0,external_path_.join)((0,external_path_.basename)(dirPath), relativePath);
+        dirPath = (0,external_path_.dirname)(dirPath);
     }
-    catch (_g) { }
-    const port = (_b = (_a = cliCommandOptions.port) !== null && _a !== void 0 ? _a : buildContext.startKeycloakOptions.port) !== null && _b !== void 0 ? _b : 8080;
-    const doStartDevServer = (() => {
-        const hasSpaUi = buildContext.implementedThemeTypes.admin.isImplemented ||
-            (buildContext.implementedThemeTypes.account.isImplemented &&
-                buildContext.implementedThemeTypes.account.type === "Single-Page");
-        if (!hasSpaUi) {
-            return false;
+    external_child_process_.exec(`git ls-files --error-unmatch '${relativePath.split(external_path_.sep).join("/")}'`, { cwd: dirPath }, error => {
+        if (error === null) {
+            dIsKnownByGit.resolve(true);
+            return;
         }
-        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 (error.code === 1) {
+            dIsKnownByGit.resolve(false);
+            return;
         }
-        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;
+        dIsKnownByGit.reject(error);
+    });
+    return dIsKnownByGit.pr;
+});
+const untrackFromGit = runExclusive.build(groupRef, async (params) => {
+    const { filePath } = params;
+    const dDone = new Deferred.Deferred();
+    let relativePath = (0,external_path_.basename)(filePath);
+    let dirPath = (0,external_path_.dirname)(filePath);
+    while (!(await (0,fs_existsAsync/* existsAsync */.o)(dirPath))) {
+        relativePath = (0,external_path_.join)((0,external_path_.basename)(dirPath), relativePath);
+        dirPath = (0,external_path_.dirname)(dirPath);
+    }
+    external_child_process_.exec(`git rm --cached '${relativePath.split(external_path_.sep).join("/")}'`, { cwd: dirPath }, error => {
+        if (error !== null) {
+            dDone.reject(error);
+            return;
         }
-        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, "'\\''")}'`),
-        `${(_d = (_c = buildContext.startKeycloakOptions.dockerImage) === null || _c === void 0 ? void 0 : _c.reference) !== null && _d !== void 0 ? _d : "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();
+        dDone.resolve();
+    });
+    await dDone.pr;
+});
+//# sourceMappingURL=gitUtils.js.map
+;// CONCATENATED MODULE: ./dist/bin/sync-extensions/sync-extension.js
+
+
+
+
+
+
+
+
+async function command(params) {
+    const { buildContext } = params;
+    const extensionModuleMetas = await (0,sync_extensions_extensionModuleMeta/* getExtensionModuleMetas */.f)({ buildContext });
+    await installExtensionModulesPeerDependencies({
+        buildContext,
+        extensionModuleMetas
+    });
+    const { ownedFilesRelativePaths } = await (0,managedGitignoreFile/* readManagedGitignoreFile */.w)({
+        buildContext
+    });
+    await (0,managedGitignoreFile/* writeManagedGitignoreFile */.Y)({
+        buildContext,
+        ownedFilesRelativePaths,
+        extensionModuleMetas
+    });
+    await Promise.all(extensionModuleMetas
+        .map(extensionModuleMeta => Promise.all(extensionModuleMeta.files.map(async ({ fileRelativePath, copyableFilePath, hash }) => {
+        if (ownedFilesRelativePaths.includes(fileRelativePath)) {
             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;
+        const destFilePath = (0,external_path_.join)(buildContext.themeSrcDirPath, fileRelativePath);
+        const doesFileExist = await (0,fs_existsAsync/* existsAsync */.o)(destFilePath);
+        skip_condition: {
+            if (!doesFileExist) {
+                break skip_condition;
             }
-            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 destFileHash = (0,sync_extensions_extensionModuleMeta/* computeHash */.x)(await promises_.readFile(destFilePath));
+            if (destFileHash !== hash) {
+                break skip_condition;
             }
-            const { isKeycloakifyBuildSuccess } = await keycloakifyBuild({
-                buildForKeycloakMajorVersionNumber: keycloakMajorVersionNumber,
-                buildContext
+            return;
+        }
+        if (await getIsKnownByGit({ filePath: destFilePath })) {
+            await untrackFromGit({
+                filePath: destFilePath
             });
-            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;
-                }
-                ignore_patternfly: {
-                    if (!(0,isInside/* isInside */.V)({
-                        dirPath: (0,external_path_.join)(buildContext.themeSrcDirPath, "shared", "@patternfly"),
-                        filePath
-                    })) {
-                        break ignore_patternfly;
-                    }
-                    return;
-                }
-                ignore_keycloak_ui_shared: {
-                    if (!(0,isInside/* isInside */.V)({
-                        dirPath: (0,external_path_.join)(buildContext.themeSrcDirPath, "shared", "keycloak-ui-shared"),
-                        filePath
-                    })) {
-                        break ignore_keycloak_ui_shared;
-                    }
-                    return;
-                }
+        }
+        {
+            const dirName = (0,external_path_.dirname)(destFilePath);
+            if (!(await (0,fs_existsAsync/* existsAsync */.o)(dirName))) {
+                await promises_.mkdir(dirName, { recursive: true });
             }
-            console.log(`Detected changes in ${filePath}`);
-            await waitForDebounce();
-            runFullBuild();
-        });
-    }
+        }
+        await promises_.copyFile(copyableFilePath, destFilePath);
+    })))
+        .flat());
 }
-//# sourceMappingURL=start-keycloak.js.map
-;// CONCATENATED MODULE: ./dist/bin/start-keycloak/index.js
-
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=sync-extension.js.map
 
 /***/ }),
 
@@ -2161,6 +843,49 @@ async function existsAsync(path) {
 
 /***/ }),
 
+/***/ 89693:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "a": () => (/* binding */ rmSync)
+/* harmony export */ });
+/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(57147);
+/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(fs__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(71017);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _SemVer__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(12171);
+
+
+
+/**
+ * Polyfill of fs.rmSync(dirPath, { "recursive": true })
+ * For older version of Node
+ */
+function rmSync(dirPath, options) {
+    if (_SemVer__WEBPACK_IMPORTED_MODULE_2__/* .SemVer.compare */ .h.compare(_SemVer__WEBPACK_IMPORTED_MODULE_2__/* .SemVer.parse */ .h.parse(process.version), _SemVer__WEBPACK_IMPORTED_MODULE_2__/* .SemVer.parse */ .h.parse("14.14.0")) > 0) {
+        fs__WEBPACK_IMPORTED_MODULE_0__.rmSync(dirPath, options);
+        return;
+    }
+    const { force = true } = options;
+    if (force && !fs__WEBPACK_IMPORTED_MODULE_0__.existsSync(dirPath)) {
+        return;
+    }
+    const removeDir_rec = (dirPath) => fs__WEBPACK_IMPORTED_MODULE_0__.readdirSync(dirPath).forEach(basename => {
+        const fileOrDirPath = (0,path__WEBPACK_IMPORTED_MODULE_1__.join)(dirPath, basename);
+        if (fs__WEBPACK_IMPORTED_MODULE_0__.lstatSync(fileOrDirPath).isDirectory()) {
+            removeDir_rec(fileOrDirPath);
+            return;
+        }
+        else {
+            fs__WEBPACK_IMPORTED_MODULE_0__.unlinkSync(fileOrDirPath);
+        }
+    });
+    removeDir_rec(dirPath);
+}
+//# sourceMappingURL=fs.rmSync.js.map
+
+/***/ }),
+
 /***/ 93721:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
@@ -2237,20 +962,91 @@ async function getInstalledModuleDirPath(params) {
 
 /***/ }),
 
-/***/ 90665:
+/***/ 75564:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   "V": () => (/* binding */ isInside)
+/* harmony export */   "P": () => (/* binding */ listInstalledModules)
 /* harmony export */ });
-/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(71017);
-/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var tsafe_assert__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(29041);
+/* harmony import */ var tsafe_id__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(38469);
+/* harmony import */ var zod__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(52300);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(71017);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var fs_promises__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(73292);
+/* harmony import */ var fs_promises__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(fs_promises__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _tools_getInstalledModuleDirPath__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(93721);
+/* harmony import */ var tsafe_exclude__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(83101);
 
-function isInside(params) {
-    const { dirPath, filePath } = params;
-    return !(0,path__WEBPACK_IMPORTED_MODULE_0__.relative)(dirPath, filePath).startsWith("..");
+
+
+
+
+
+
+async function listInstalledModules(params) {
+    const { packageJsonFilePath, filter } = params;
+    const parsedPackageJson = await readPackageJsonDependencies({
+        packageJsonFilePath
+    });
+    const extensionModuleNames = [parsedPackageJson.dependencies, parsedPackageJson.devDependencies]
+        .filter((0,tsafe_exclude__WEBPACK_IMPORTED_MODULE_4__/* .exclude */ .D)(undefined))
+        .map(obj => Object.keys(obj))
+        .flat()
+        .filter(moduleName => filter({ moduleName }));
+    const result = await Promise.all(extensionModuleNames.map(async (moduleName) => {
+        const dirPath = await (0,_tools_getInstalledModuleDirPath__WEBPACK_IMPORTED_MODULE_3__/* .getInstalledModuleDirPath */ .p)({
+            moduleName,
+            packageJsonDirPath: (0,path__WEBPACK_IMPORTED_MODULE_1__.dirname)(packageJsonFilePath)
+        });
+        const { version, peerDependencies } = await readPackageJsonVersionAndPeerDependencies({
+            packageJsonFilePath: (0,path__WEBPACK_IMPORTED_MODULE_1__.join)(dirPath, "package.json")
+        });
+        return { moduleName, version, peerDependencies, dirPath };
+    }));
+    return result;
 }
-//# sourceMappingURL=isInside.js.map
+const { readPackageJsonDependencies } = (() => {
+    const zParsedPackageJson = (() => {
+        const zTargetType = zod__WEBPACK_IMPORTED_MODULE_5__.z.object({
+            dependencies: zod__WEBPACK_IMPORTED_MODULE_5__.z.record(zod__WEBPACK_IMPORTED_MODULE_5__.z.string()).optional(),
+            devDependencies: zod__WEBPACK_IMPORTED_MODULE_5__.z.record(zod__WEBPACK_IMPORTED_MODULE_5__.z.string()).optional()
+        });
+        (0,tsafe_assert__WEBPACK_IMPORTED_MODULE_0__/* .assert */ .h)();
+        return (0,tsafe_id__WEBPACK_IMPORTED_MODULE_6__.id)(zTargetType);
+    })();
+    async function readPackageJsonDependencies(params) {
+        const { packageJsonFilePath } = params;
+        const parsedPackageJson = JSON.parse((await fs_promises__WEBPACK_IMPORTED_MODULE_2__.readFile(packageJsonFilePath)).toString("utf8"));
+        zParsedPackageJson.parse(parsedPackageJson);
+        (0,tsafe_assert__WEBPACK_IMPORTED_MODULE_0__/* .assert */ .h)((0,tsafe_assert__WEBPACK_IMPORTED_MODULE_0__.is)(parsedPackageJson));
+        return parsedPackageJson;
+    }
+    return { readPackageJsonDependencies };
+})();
+const { readPackageJsonVersionAndPeerDependencies } = (() => {
+    const zParsedPackageJson = (() => {
+        const zTargetType = zod__WEBPACK_IMPORTED_MODULE_5__.z.object({
+            version: zod__WEBPACK_IMPORTED_MODULE_5__.z.string(),
+            peerDependencies: zod__WEBPACK_IMPORTED_MODULE_5__.z.record(zod__WEBPACK_IMPORTED_MODULE_5__.z.string()).optional()
+        });
+        (0,tsafe_assert__WEBPACK_IMPORTED_MODULE_0__/* .assert */ .h)();
+        return (0,tsafe_id__WEBPACK_IMPORTED_MODULE_6__.id)(zTargetType);
+    })();
+    async function readPackageJsonVersionAndPeerDependencies(params) {
+        var _a;
+        const { packageJsonFilePath } = params;
+        const parsedPackageJson = JSON.parse((await fs_promises__WEBPACK_IMPORTED_MODULE_2__.readFile(packageJsonFilePath)).toString("utf8"));
+        zParsedPackageJson.parse(parsedPackageJson);
+        (0,tsafe_assert__WEBPACK_IMPORTED_MODULE_0__/* .assert */ .h)((0,tsafe_assert__WEBPACK_IMPORTED_MODULE_0__.is)(parsedPackageJson));
+        return {
+            version: parsedPackageJson.version,
+            peerDependencies: (_a = parsedPackageJson.peerDependencies) !== null && _a !== void 0 ? _a : {}
+        };
+    }
+    return { readPackageJsonVersionAndPeerDependencies };
+})();
+//# sourceMappingURL=listInstalledModules.js.map
 
 /***/ }),
 
@@ -2388,6 +1184,379 @@ function getNodeModulesBinDirPath(params) {
 
 /***/ }),
 
+/***/ 63046:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "c": () => (/* binding */ npmInstall)
+});
+
+// EXTERNAL MODULE: external "fs"
+var external_fs_ = __webpack_require__(57147);
+// EXTERNAL MODULE: external "path"
+var external_path_ = __webpack_require__(71017);
+// EXTERNAL MODULE: external "child_process"
+var external_child_process_ = __webpack_require__(32081);
+// 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/zod/lib/index.mjs
+var lib = __webpack_require__(52300);
+// EXTERNAL MODULE: ./node_modules/tsafe/esm/assert.mjs + 1 modules
+var assert = __webpack_require__(29041);
+// EXTERNAL MODULE: ./node_modules/tsafe/esm/id.mjs
+var id = __webpack_require__(38469);
+;// CONCATENATED MODULE: ./node_modules/tsafe/esm/objectKeys.mjs
+/** https://docs.tsafe.dev/objectKeys */
+function objectKeys(o) {
+    return Object.keys(o);
+}
+
+
+//# sourceMappingURL=objectKeys.mjs.map
+
+// EXTERNAL MODULE: ./dist/bin/tools/getAbsoluteAndInOsFormatPath.js
+var getAbsoluteAndInOsFormatPath = __webpack_require__(84794);
+// EXTERNAL MODULE: ./node_modules/tsafe/esm/exclude.mjs
+var exclude = __webpack_require__(83101);
+// EXTERNAL MODULE: ./dist/bin/tools/fs.rmSync.js
+var fs_rmSync = __webpack_require__(89693);
+// EXTERNAL MODULE: ./node_modules/evt/tools/Deferred.js
+var Deferred = __webpack_require__(50689);
+;// CONCATENATED MODULE: ./dist/bin/tools/npmInstall.js
+
+
+
+
+
+
+
+
+
+
+
+
+async function npmInstall(params) {
+    const { packageJsonDirPath } = params;
+    const packageManagerBinName = (() => {
+        const packageMangers = [
+            {
+                binName: "yarn",
+                lockFileBasename: "yarn.lock"
+            },
+            {
+                binName: "npm",
+                lockFileBasename: "package-lock.json"
+            },
+            {
+                binName: "pnpm",
+                lockFileBasename: "pnpm-lock.yaml"
+            },
+            {
+                binName: "bun",
+                lockFileBasename: "bun.lockdb"
+            },
+            {
+                binName: "deno",
+                lockFileBasename: "deno.lock"
+            }
+        ];
+        for (const packageManager of packageMangers) {
+            if (external_fs_.existsSync((0,external_path_.join)(packageJsonDirPath, packageManager.lockFileBasename)) ||
+                external_fs_.existsSync((0,external_path_.join)(process.cwd(), packageManager.lockFileBasename))) {
+                return packageManager.binName;
+            }
+        }
+        throw new Error("No lock file found, cannot tell which package manager to use for installing dependencies.");
+    })();
+    console.log(`Installing the new dependencies...`);
+    install_without_breaking_links: {
+        if (packageManagerBinName !== "yarn") {
+            break install_without_breaking_links;
+        }
+        const garronejLinkInfos = getGarronejLinkInfos({ packageJsonDirPath });
+        if (garronejLinkInfos === undefined) {
+            break install_without_breaking_links;
+        }
+        console.log(source_default().green("Installing in a way that won't break the links..."));
+        await installWithoutBreakingLinks({
+            packageJsonDirPath,
+            garronejLinkInfos
+        });
+        return;
+    }
+    try {
+        await runPackageManagerInstall({
+            packageManagerBinName,
+            cwd: packageJsonDirPath
+        });
+    }
+    catch (_a) {
+        console.log(source_default().yellow(`\`${packageManagerBinName} install\` failed, continuing anyway...`));
+    }
+}
+async function runPackageManagerInstall(params) {
+    const { packageManagerBinName, cwd } = params;
+    const dCompleted = new Deferred.Deferred();
+    const child = external_child_process_.spawn(packageManagerBinName, ["install"], {
+        cwd,
+        env: process.env,
+        shell: true
+    });
+    child.stdout.on("data", data => process.stdout.write(data));
+    child.stderr.on("data", data => {
+        if (data.toString("utf8").includes("peer dependency")) {
+            return;
+        }
+        process.stderr.write(data);
+    });
+    child.on("exit", code => {
+        if (code !== 0) {
+            dCompleted.reject(new Error(`Failed with code ${code}`));
+            return;
+        }
+        dCompleted.resolve();
+    });
+    await dCompleted.pr;
+}
+function getGarronejLinkInfos(params) {
+    const { packageJsonDirPath } = params;
+    const nodeModuleDirPath = (0,external_path_.join)(packageJsonDirPath, "node_modules");
+    if (!external_fs_.existsSync(nodeModuleDirPath)) {
+        return undefined;
+    }
+    const linkedModuleNames = [];
+    let yarnHomeDirPath = undefined;
+    const getIsLinkedByGarronejScript = (path) => {
+        let realPath;
+        try {
+            realPath = external_fs_.readlinkSync(path);
+        }
+        catch (_a) {
+            return false;
+        }
+        const doesIncludeYarnHome = realPath.includes(".yarn_home");
+        if (!doesIncludeYarnHome) {
+            return false;
+        }
+        set_yarnHomeDirPath: {
+            if (yarnHomeDirPath !== undefined) {
+                break set_yarnHomeDirPath;
+            }
+            const [firstElement] = (0,getAbsoluteAndInOsFormatPath/* getAbsoluteAndInOsFormatPath */.c)({
+                pathIsh: realPath,
+                cwd: (0,external_path_.dirname)(path)
+            }).split(".yarn_home");
+            yarnHomeDirPath = (0,external_path_.join)(firstElement, ".yarn_home");
+        }
+        return true;
+    };
+    for (const basename of external_fs_.readdirSync(nodeModuleDirPath)) {
+        const path = (0,external_path_.join)(nodeModuleDirPath, basename);
+        if (external_fs_.lstatSync(path).isSymbolicLink()) {
+            if (basename.startsWith("@")) {
+                return undefined;
+            }
+            if (!getIsLinkedByGarronejScript(path)) {
+                return undefined;
+            }
+            linkedModuleNames.push(basename);
+            continue;
+        }
+        if (!external_fs_.lstatSync(path).isDirectory()) {
+            continue;
+        }
+        if (basename.startsWith("@")) {
+            for (const subBasename of external_fs_.readdirSync(path)) {
+                const subPath = (0,external_path_.join)(path, subBasename);
+                if (!external_fs_.lstatSync(subPath).isSymbolicLink()) {
+                    continue;
+                }
+                if (!getIsLinkedByGarronejScript(subPath)) {
+                    return undefined;
+                }
+                linkedModuleNames.push(`${basename}/${subBasename}`);
+            }
+        }
+    }
+    if (yarnHomeDirPath === undefined) {
+        return undefined;
+    }
+    return { linkedModuleNames, yarnHomeDirPath };
+}
+async function installWithoutBreakingLinks(params) {
+    const { packageJsonDirPath, garronejLinkInfos: { linkedModuleNames, yarnHomeDirPath } } = params;
+    const parsedPackageJson = (() => {
+        const packageJsonFilePath = (0,external_path_.join)(packageJsonDirPath, "package.json");
+        const zParsedPackageJson = (() => {
+            const zTargetType = lib.z.object({
+                scripts: lib.z.record(lib.z.string()).optional()
+            });
+            assert/* assert */.h;
+            return (0,id.id)(zTargetType);
+        })();
+        const parsedPackageJson = JSON.parse(external_fs_.readFileSync(packageJsonFilePath).toString("utf8"));
+        zParsedPackageJson.parse(parsedPackageJson);
+        (0,assert/* assert */.h)((0,assert.is)(parsedPackageJson));
+        return parsedPackageJson;
+    })();
+    const isImplementedScriptByName = {
+        postinstall: false,
+        prepare: false
+    };
+    delete_postinstall_script: {
+        if (parsedPackageJson.scripts === undefined) {
+            break delete_postinstall_script;
+        }
+        for (const scriptName of objectKeys(isImplementedScriptByName)) {
+            if (parsedPackageJson.scripts[scriptName] === undefined) {
+                continue;
+            }
+            isImplementedScriptByName[scriptName] = true;
+            delete parsedPackageJson.scripts[scriptName];
+        }
+    }
+    const tmpProjectDirPath = (0,external_path_.join)(yarnHomeDirPath, "tmpProject");
+    if (external_fs_.existsSync(tmpProjectDirPath)) {
+        (0,fs_rmSync/* rmSync */.a)(tmpProjectDirPath, { recursive: true });
+    }
+    external_fs_.mkdirSync(tmpProjectDirPath, { recursive: true });
+    external_fs_.writeFileSync((0,external_path_.join)(tmpProjectDirPath, "package.json"), JSON.stringify(parsedPackageJson, undefined, 4));
+    const YARN_LOCK = "yarn.lock";
+    external_fs_.copyFileSync((0,external_path_.join)(packageJsonDirPath, YARN_LOCK), (0,external_path_.join)(tmpProjectDirPath, YARN_LOCK));
+    await runPackageManagerInstall({
+        packageManagerBinName: "yarn",
+        cwd: tmpProjectDirPath
+    });
+    // NOTE: Moving the modules from the tmp project to the actual project
+    // without messing up the links.
+    {
+        const { getAreSameVersions } = (() => {
+            const zParsedPackageJson = (() => {
+                const zTargetType = lib.z.object({
+                    version: lib.z.string()
+                });
+                assert/* assert */.h;
+                return (0,id.id)(zTargetType);
+            })();
+            function readVersion(params) {
+                const { moduleDirPath } = params;
+                const packageJsonFilePath = (0,external_path_.join)(moduleDirPath, "package.json");
+                const packageJson = JSON.parse(external_fs_.readFileSync(packageJsonFilePath).toString("utf8"));
+                zParsedPackageJson.parse(packageJson);
+                (0,assert/* assert */.h)((0,assert.is)(packageJson));
+                return packageJson.version;
+            }
+            function getAreSameVersions(params) {
+                const { moduleDirPath_a, moduleDirPath_b } = params;
+                return (readVersion({ moduleDirPath: moduleDirPath_a }) ===
+                    readVersion({ moduleDirPath: moduleDirPath_b }));
+            }
+            return { getAreSameVersions };
+        })();
+        const nodeModulesDirPath_tmpProject = (0,external_path_.join)(tmpProjectDirPath, "node_modules");
+        const nodeModulesDirPath = (0,external_path_.join)(packageJsonDirPath, "node_modules");
+        const modulePaths = external_fs_.readdirSync(nodeModulesDirPath_tmpProject)
+            .map(basename => {
+            if (basename.startsWith(".")) {
+                return undefined;
+            }
+            const path = (0,external_path_.join)(nodeModulesDirPath_tmpProject, basename);
+            if (basename.startsWith("@")) {
+                return external_fs_.readdirSync(path)
+                    .map(subBasename => {
+                    if (subBasename.startsWith(".")) {
+                        return undefined;
+                    }
+                    const subPath = (0,external_path_.join)(path, subBasename);
+                    if (!external_fs_.lstatSync(subPath).isDirectory()) {
+                        return undefined;
+                    }
+                    return {
+                        moduleName: `${basename}/${subBasename}`,
+                        moduleDirPath_tmpProject: subPath,
+                        moduleDirPath: (0,external_path_.join)(nodeModulesDirPath, basename, subBasename)
+                    };
+                })
+                    .filter((0,exclude/* exclude */.D)(undefined));
+            }
+            if (!external_fs_.lstatSync(path).isDirectory()) {
+                return undefined;
+            }
+            return [
+                {
+                    moduleName: basename,
+                    moduleDirPath_tmpProject: path,
+                    moduleDirPath: (0,external_path_.join)(nodeModulesDirPath, basename)
+                }
+            ];
+        })
+            .filter((0,exclude/* exclude */.D)(undefined))
+            .flat();
+        for (const { moduleName, moduleDirPath, moduleDirPath_tmpProject } of modulePaths) {
+            if (linkedModuleNames.includes(moduleName)) {
+                continue;
+            }
+            let doesTargetModuleExist = false;
+            skip_condition: {
+                if (!external_fs_.existsSync(moduleDirPath)) {
+                    break skip_condition;
+                }
+                doesTargetModuleExist = true;
+                const areSameVersions = getAreSameVersions({
+                    moduleDirPath_a: moduleDirPath,
+                    moduleDirPath_b: moduleDirPath_tmpProject
+                });
+                if (!areSameVersions) {
+                    break skip_condition;
+                }
+                continue;
+            }
+            if (doesTargetModuleExist) {
+                (0,fs_rmSync/* rmSync */.a)(moduleDirPath, { recursive: true });
+            }
+            {
+                const dirPath = (0,external_path_.dirname)(moduleDirPath);
+                if (!external_fs_.existsSync(dirPath)) {
+                    external_fs_.mkdirSync(dirPath, { recursive: true });
+                }
+            }
+            external_fs_.renameSync(moduleDirPath_tmpProject, moduleDirPath);
+        }
+        move_bin: {
+            const binDirPath_tmpProject = (0,external_path_.join)(nodeModulesDirPath_tmpProject, ".bin");
+            const binDirPath = (0,external_path_.join)(nodeModulesDirPath, ".bin");
+            if (!external_fs_.existsSync(binDirPath_tmpProject)) {
+                break move_bin;
+            }
+            for (const basename of external_fs_.readdirSync(binDirPath_tmpProject)) {
+                const path_tmpProject = (0,external_path_.join)(binDirPath_tmpProject, basename);
+                const path = (0,external_path_.join)(binDirPath, basename);
+                if (external_fs_.existsSync(path)) {
+                    continue;
+                }
+                external_fs_.renameSync(path_tmpProject, path);
+            }
+        }
+    }
+    external_fs_.cpSync((0,external_path_.join)(tmpProjectDirPath, YARN_LOCK), (0,external_path_.join)(packageJsonDirPath, YARN_LOCK));
+    (0,fs_rmSync/* rmSync */.a)(tmpProjectDirPath, { recursive: true });
+    for (const scriptName of objectKeys(isImplementedScriptByName)) {
+        if (!isImplementedScriptByName[scriptName]) {
+            continue;
+        }
+        external_child_process_.execSync(`yarn run ${scriptName}`, {
+            cwd: packageJsonDirPath,
+            stdio: "inherit"
+        });
+    }
+}
+//# sourceMappingURL=npmInstall.js.map
+
+/***/ }),
+
 /***/ 48433:
 /***/ ((module, __webpack_exports__, __webpack_require__) => {