keycloakify 10.0.0-rc.62 → 10.0.0-rc.64

package/bin/{952.index.js → 363.index.js}

@@ -1,6 +1,6 @@
 "use strict";
-exports.id = 952;
-exports.ids = [952];
+exports.id = 363;
+exports.ids = [363];
 exports.modules = {
 
 /***/ 73817:
@@ -155,7 +155,7 @@ function generateMessageProperties(params) {
 
 /***/ }),
 
-/***/ 24952:
+/***/ 52363:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 // ESM COMPAT FLAG
@@ -514,8 +514,6 @@ function generateFtlFilesCodeFactory(params) {
 ;// CONCATENATED MODULE: ./dist/bin/keycloakify/generateFtl/index.js
 
 //# sourceMappingURL=index.js.map
-// EXTERNAL MODULE: ./dist/bin/tools/isInside.js
-var isInside = __webpack_require__(90665);
 // EXTERNAL MODULE: ./dist/bin/shared/downloadKeycloakStaticResources.js
 var downloadKeycloakStaticResources = __webpack_require__(62190);
 // EXTERNAL MODULE: ./dist/bin/tools/crawl.js
@@ -686,12 +684,33 @@ var getThemeSrcDirPath = __webpack_require__(39216);
 var fs_rmSync = __webpack_require__(89693);
 // EXTERNAL MODULE: ./dist/bin/tools/readThisNpmPackageVersion.js
 var readThisNpmPackageVersion = __webpack_require__(64795);
-// EXTERNAL MODULE: ./dist/bin/shared/metaInfKeycloakThemes.js
-var shared_metaInfKeycloakThemes = __webpack_require__(26914);
+;// CONCATENATED MODULE: ./dist/bin/shared/metaInfKeycloakThemes.js
+
+
+function writeMetaInfKeycloakThemes(params) {
+    const { resourcesDirPath, getNewMetaInfKeycloakTheme } = params;
+    const filePath = (0,external_path_.join)(resourcesDirPath, "META-INF", "keycloak-themes.json");
+    const currentMetaInfKeycloakTheme = !external_fs_.existsSync(filePath)
+        ? undefined
+        : JSON.parse(external_fs_.readFileSync(filePath).toString("utf8"));
+    const newMetaInfKeycloakThemes = getNewMetaInfKeycloakTheme({
+        metaInfKeycloakTheme: currentMetaInfKeycloakTheme
+    });
+    {
+        const dirPath = (0,external_path_.dirname)(filePath);
+        if (!external_fs_.existsSync(dirPath)) {
+            external_fs_.mkdirSync(dirPath, { recursive: true });
+        }
+    }
+    external_fs_.writeFileSync(filePath, Buffer.from(JSON.stringify(newMetaInfKeycloakThemes, null, 2), "utf8"));
+}
+//# sourceMappingURL=metaInfKeycloakThemes.js.map
 // EXTERNAL MODULE: ./node_modules/tsafe/objectEntries.js
 var objectEntries = __webpack_require__(39612);
 // EXTERNAL MODULE: ./dist/bin/tools/escapeStringForPropertiesFile.js
 var escapeStringForPropertiesFile = __webpack_require__(27190);
+// EXTERNAL MODULE: ./dist/bin/shared/getImplementedThemeTypes.js
+var getImplementedThemeTypes = __webpack_require__(64409);
 ;// CONCATENATED MODULE: ./dist/bin/keycloakify/generateResources/generateResourcesForMainTheme.js
 
 
@@ -720,21 +739,18 @@ async function generateResourcesForMainTheme(params) {
     const { themeSrcDirPath } = (0,getThemeSrcDirPath/* getThemeSrcDirPath */.f)({
         projectDirPath: buildContext.projectDirPath
     });
+    const { implementedThemeTypes } = (0,getImplementedThemeTypes/* getImplementedThemeTypes */.C)({
+        projectDirPath: buildContext.projectDirPath
+    });
     const getThemeTypeDirPath = (params) => {
         const { themeType } = params;
         return (0,external_path_.join)(resourcesDirPath, "theme", themeName, themeType);
     };
     const cssGlobalsToDefine = {};
-    const implementedThemeTypes = {
-        login: false,
-        account: false,
-        email: false
-    };
     for (const themeType of ["login", "account"]) {
-        if (!external_fs_.existsSync((0,external_path_.join)(themeSrcDirPath, themeType))) {
+        if (!implementedThemeTypes[themeType]) {
             continue;
         }
-        implementedThemeTypes[themeType] = true;
         const themeTypeDirPath = getThemeTypeDirPath({ themeType });
         apply_replacers_and_move_to_theme_resources: {
             const destDirPath = (0,external_path_.join)(themeTypeDirPath, "resources", constants/* basenameOfTheKeycloakifyResourcesDir */.M);
@@ -750,19 +766,24 @@ async function generateResourcesForMainTheme(params) {
                 });
                 break apply_replacers_and_move_to_theme_resources;
             }
+            {
+                const dirPath = (0,external_path_.join)(buildContext.projectBuildDirPath, constants/* keycloak_resources */.N$);
+                if (external_fs_.existsSync(dirPath)) {
+                    (0,assert.assert)(buildContext.bundler === "webpack");
+                    throw new Error([
+                        `Keycloakify build error: The ${constants/* keycloak_resources */.N$} directory shouldn't exist in your build directory.`,
+                        `(${(0,external_path_.relative)(process.cwd(), dirPath)}).\n`,
+                        `Theses assets are only required for local development with Storybook.",
+                            "Please remove this directory as an additional step of your command.\n`,
+                        `For example: \`"build": "... && rimraf ${(0,external_path_.relative)(buildContext.projectDirPath, dirPath)}"\``
+                    ].join(" "));
+                }
+            }
             (0,transformCodebase/* transformCodebase */.N)({
                 srcDirPath: buildContext.projectBuildDirPath,
                 destDirPath,
                 transformSourceCode: ({ filePath, sourceCode }) => {
-                    //NOTE: Prevent cycles, excludes the folder we generated for debug in public/
-                    // This should not happen if users follow the new instruction setup but we keep it for retrocompatibility.
-                    if ((0,isInside/* isInside */.V)({
-                        dirPath: (0,external_path_.join)(buildContext.projectBuildDirPath, constants/* keycloak_resources */.N$),
-                        filePath
-                    })) {
-                        return undefined;
-                    }
-                    if (/\.css?$/i.test(filePath)) {
+                    if (filePath.endsWith(".css")) {
                         const { cssGlobalsToDefine: cssGlobalsToDefineForThisFile, fixedCssCode } = replaceImportsInCssCode({
                             cssCode: sourceCode.toString("utf8")
                         });
@@ -773,7 +794,7 @@ async function generateResourcesForMainTheme(params) {
                             modifiedSourceCode: Buffer.from(fixedCssCode, "utf8")
                         };
                     }
-                    if (/\.js?$/i.test(filePath)) {
+                    if (filePath.endsWith(".js")) {
                         const { fixedJsCode } = replaceImportsInJsCode({
                             jsCode: sourceCode.toString("utf8"),
                             buildContext
@@ -855,11 +876,10 @@ async function generateResourcesForMainTheme(params) {
         ].join("\n\n"), "utf8"));
     }
     email: {
-        const emailThemeSrcDirPath = (0,external_path_.join)(themeSrcDirPath, "email");
-        if (!external_fs_.existsSync(emailThemeSrcDirPath)) {
+        if (!implementedThemeTypes.email) {
             break email;
         }
-        implementedThemeTypes.email = true;
+        const emailThemeSrcDirPath = (0,external_path_.join)(themeSrcDirPath, "email");
         (0,transformCodebase/* transformCodebase */.N)({
             srcDirPath: emailThemeSrcDirPath,
             destDirPath: getThemeTypeDirPath({ themeType: "email" })
@@ -885,9 +905,9 @@ async function generateResourcesForMainTheme(params) {
                 types: ["account"]
             });
         }
-        (0,shared_metaInfKeycloakThemes/* writeMetaInfKeycloakThemes */.JJ)({
+        writeMetaInfKeycloakThemes({
             resourcesDirPath,
-            metaInfKeycloakThemes
+            getNewMetaInfKeycloakTheme: () => metaInfKeycloakThemes
         });
     }
 }
@@ -909,30 +929,29 @@ function generateResourcesForThemeVariant(params) {
                 fileRelativePath.split(external_path_.sep).length === 2) {
                 const modifiedSourceCode = Buffer.from(Buffer.from(sourceCode)
                     .toString("utf-8")
-                    .replace(`out["themeName"] = "${themeName}";`, `out["themeName"] = "${themeVariantName}";`), "utf8");
+                    .replace(`kcContext.themeName = "${themeName}";`, `kcContext.themeName = "${themeVariantName}";`), "utf8");
                 (0,assert.assert)(Buffer.compare(modifiedSourceCode, sourceCode) !== 0);
                 return { modifiedSourceCode };
             }
             return { modifiedSourceCode: sourceCode };
         }
     });
-    {
-        const updatedMetaInfKeycloakThemes = (0,shared_metaInfKeycloakThemes/* readMetaInfKeycloakThemes_fromResourcesDirPath */.Ju)({
-            resourcesDirPath
-        });
-        updatedMetaInfKeycloakThemes.themes.push({
-            name: themeVariantName,
-            types: (() => {
-                const theme = updatedMetaInfKeycloakThemes.themes.find(({ name }) => name === themeName);
-                (0,assert.assert)(theme !== undefined);
-                return theme.types;
-            })()
-        });
-        (0,shared_metaInfKeycloakThemes/* writeMetaInfKeycloakThemes */.JJ)({
-            resourcesDirPath,
-            metaInfKeycloakThemes: updatedMetaInfKeycloakThemes
-        });
-    }
+    writeMetaInfKeycloakThemes({
+        resourcesDirPath,
+        getNewMetaInfKeycloakTheme: ({ metaInfKeycloakTheme }) => {
+            (0,assert.assert)(metaInfKeycloakTheme !== undefined);
+            const newMetaInfKeycloakTheme = metaInfKeycloakTheme;
+            newMetaInfKeycloakTheme.themes.push({
+                name: themeVariantName,
+                types: (() => {
+                    const theme = newMetaInfKeycloakTheme.themes.find(({ name }) => name === themeName);
+                    (0,assert.assert)(theme !== undefined);
+                    return theme.types;
+                })()
+            });
+            return newMetaInfKeycloakTheme;
+        }
+    });
 }
 //# sourceMappingURL=generateResourcesForThemeVariant.js.map
 ;// CONCATENATED MODULE: ./dist/bin/keycloakify/generateResources/generateResources.js
@@ -1111,6 +1130,8 @@ function generatePom(params) {
     return { pomFileCode };
 }
 //# sourceMappingURL=generatePom.js.map
+// EXTERNAL MODULE: ./dist/bin/tools/isInside.js
+var isInside = __webpack_require__(90665);
 ;// CONCATENATED MODULE: ./dist/bin/keycloakify/buildJars/buildJar.js
 
 
@@ -1128,9 +1149,10 @@ async function buildJar(params) {
     const { jarFileBasename, keycloakAccountV1Version, keycloakThemeAdditionalInfoExtensionVersion, resourcesDirPath, buildContext } = params;
     const keycloakifyBuildTmpDirPath = (0,external_path_.join)(buildContext.cacheDirPath, jarFileBasename.replace(".jar", ""));
     (0,fs_rmSync/* rmSync */.a)(keycloakifyBuildTmpDirPath, { recursive: true, force: true });
+    const tmpResourcesDirPath = (0,external_path_.join)(keycloakifyBuildTmpDirPath, "src", "main", "resources");
     (0,transformCodebase/* transformCodebase */.N)({
         srcDirPath: resourcesDirPath,
-        destDirPath: (0,external_path_.join)(keycloakifyBuildTmpDirPath, "src", "main", "resources"),
+        destDirPath: tmpResourcesDirPath,
         transformSourceCode: keycloakAccountV1Version !== null
             ? undefined
             : (params) => {
@@ -1141,17 +1163,6 @@ async function buildJar(params) {
                 })) {
                     return undefined;
                 }
-                if (fileRelativePath ===
-                    (0,shared_metaInfKeycloakThemes/* getMetaInfKeycloakThemesJsonFilePath */.KQ)({
-                        resourcesDirPath: "."
-                    })) {
-                    const keycloakThemesJsonParsed = JSON.parse(sourceCode.toString("utf8"));
-                    keycloakThemesJsonParsed.themes =
-                        keycloakThemesJsonParsed.themes.filter(({ name }) => name !== constants/* accountV1ThemeName */.y_);
-                    return {
-                        modifiedSourceCode: Buffer.from(JSON.stringify(keycloakThemesJsonParsed, null, 2), "utf8")
-                    };
-                }
                 for (const themeName of buildContext.themeNames) {
                     if (fileRelativePath ===
                         (0,external_path_.join)("theme", themeName, "account", "theme.properties")) {
@@ -1165,6 +1176,16 @@ async function buildJar(params) {
                 return { modifiedSourceCode: sourceCode };
             }
     });
+    if (keycloakAccountV1Version === null) {
+        writeMetaInfKeycloakThemes({
+            resourcesDirPath: tmpResourcesDirPath,
+            getNewMetaInfKeycloakTheme: ({ metaInfKeycloakTheme }) => {
+                (0,assert.assert)(metaInfKeycloakTheme !== undefined);
+                metaInfKeycloakTheme.themes = metaInfKeycloakTheme.themes.filter(({ name }) => name !== constants/* accountV1ThemeName */.y_);
+                return metaInfKeycloakTheme;
+            }
+        });
+    }
     route_legacy_pages: {
         // NOTE: If there's no account theme there is no special target for keycloak 24 and up so we create
         // the pages anyway. If there is an account pages, since we know that account-v1 is only support keycloak
@@ -1233,13 +1254,12 @@ var getJarFileBasename = __webpack_require__(2323);
 
 
 
-
 (0,assert.assert)();
 async function buildJars(params) {
     const { onlyBuildJarFileBasename, resourcesDirPath, buildContext } = params;
-    const doesImplementAccountTheme = (0,shared_metaInfKeycloakThemes/* readMetaInfKeycloakThemes_fromResourcesDirPath */.Ju)({
-        resourcesDirPath
-    }).themes.some(({ name }) => name === constants/* accountV1ThemeName */.y_);
+    const doesImplementAccountTheme = (0,getImplementedThemeTypes/* getImplementedThemeTypes */.C)({
+        projectDirPath: buildContext.projectDirPath
+    }).implementedThemeTypes.account;
     await Promise.all(keycloakAccountV1Versions.map(keycloakAccountV1Version => keycloakThemeAdditionalInfoExtensionVersions.map(keycloakThemeAdditionalInfoExtensionVersion => {
         const keycloakVersionRange = getKeycloakVersionRangeForJar({
             doesImplementAccountTheme,
@@ -1369,6 +1389,478 @@ async function command(params) {
 
 /***/ }),
 
+/***/ 47802:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "x": () => (/* binding */ downloadKeycloakDefaultTheme)
+});
+
+// EXTERNAL MODULE: external "path"
+var external_path_ = __webpack_require__(71017);
+// EXTERNAL MODULE: ./node_modules/tsafe/assert.js
+var assert = __webpack_require__(88078);
+// EXTERNAL MODULE: ./dist/bin/shared/constants.js
+var constants = __webpack_require__(173);
+// EXTERNAL MODULE: ./node_modules/make-fetch-happen/lib/index.js
+var lib = __webpack_require__(9525);
+var lib_default = /*#__PURE__*/__webpack_require__.n(lib);
+// EXTERNAL MODULE: external "fs/promises"
+var promises_ = __webpack_require__(73292);
+// EXTERNAL MODULE: ./dist/bin/tools/extractArchive.js
+var extractArchive = __webpack_require__(29121);
+// 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: external "util"
+var external_util_ = __webpack_require__(73837);
+;// CONCATENATED MODULE: ./dist/bin/tools/downloadAndExtractArchive/fetchProxyOptions.js
+
+
+
+function ensureArray(arg0) {
+    return Array.isArray(arg0) ? arg0 : typeof arg0 === "undefined" ? [] : [arg0];
+}
+function ensureSingleOrNone(arg0) {
+    if (!Array.isArray(arg0))
+        return arg0;
+    if (arg0.length === 0)
+        return undefined;
+    if (arg0.length === 1)
+        return arg0[0];
+    throw new Error("Illegal configuration, expected a single value but found multiple: " +
+        arg0.map(String).join(", "));
+}
+/**
+ * Get npm configuration as map
+ */
+async function getNmpConfig(params) {
+    const { npmWorkspaceRootDirPath } = params;
+    const exec = (0,external_util_.promisify)(external_child_process_.exec);
+    const stdout = await exec("npm config get", {
+        encoding: "utf8",
+        cwd: npmWorkspaceRootDirPath
+    }).then(({ stdout }) => stdout);
+    const npmConfigReducer = (cfg, [key, value]) => key in cfg
+        ? Object.assign(Object.assign({}, cfg), { [key]: [...ensureArray(cfg[key]), value] }) : Object.assign(Object.assign({}, cfg), { [key]: value });
+    return stdout
+        .split("\n")
+        .filter(line => !line.startsWith(";"))
+        .map(line => line.trim())
+        .map(line => line.split("=", 2))
+        .reduce(npmConfigReducer, {});
+}
+async function getProxyFetchOptions(params) {
+    var _a, _b, _c;
+    const { npmWorkspaceRootDirPath } = params;
+    const cfg = await getNmpConfig({ npmWorkspaceRootDirPath });
+    const proxy = ensureSingleOrNone((_a = cfg["https-proxy"]) !== null && _a !== void 0 ? _a : cfg["proxy"]);
+    const noProxy = (_b = cfg["noproxy"]) !== null && _b !== void 0 ? _b : cfg["no-proxy"];
+    function maybeBoolean(arg0) {
+        return typeof arg0 === "undefined" ? undefined : Boolean(arg0);
+    }
+    const strictSSL = maybeBoolean(ensureSingleOrNone(cfg["strict-ssl"]));
+    const cert = cfg["cert"];
+    const ca = ensureArray((_c = cfg["ca"]) !== null && _c !== void 0 ? _c : cfg["ca[]"]);
+    const cafile = ensureSingleOrNone(cfg["cafile"]);
+    if (typeof cafile !== "undefined" && cafile !== "null") {
+        ca.push(...(await (async () => {
+            function chunks(arr, size = 2) {
+                return arr
+                    .map((_, i) => i % size == 0 && arr.slice(i, i + size))
+                    .filter(Boolean);
+            }
+            const cafileContent = await (0,promises_.readFile)(cafile, "utf-8");
+            const newLinePlaceholder = "NEW_LINE_PLACEHOLDER_xIsPsK23svt";
+            return chunks(cafileContent.split(/(-----END CERTIFICATE-----)/), 2).map(ca => ca
+                .join("")
+                .replace(/\r?\n/g, newLinePlaceholder)
+                .replace(new RegExp(`^${newLinePlaceholder}`), "")
+                .replace(new RegExp(newLinePlaceholder, "g"), "\\n"));
+        })()));
+    }
+    return {
+        proxy,
+        noProxy,
+        strictSSL,
+        cert,
+        ca: ca.length === 0 ? undefined : ca
+    };
+}
+//# sourceMappingURL=fetchProxyOptions.js.map
+// EXTERNAL MODULE: external "crypto"
+var external_crypto_ = __webpack_require__(6113);
+// EXTERNAL MODULE: ./dist/bin/tools/fs.rm.js
+var fs_rm = __webpack_require__(8699);
+;// CONCATENATED MODULE: ./dist/bin/tools/downloadAndExtractArchive/downloadAndExtractArchive.js
+
+
+
+
+
+
+
+
+
+async function downloadAndExtractArchive(params) {
+    var _a;
+    const { url, uniqueIdOfOnOnArchiveFile, onArchiveFile, cacheDirPath, npmWorkspaceRootDirPath } = params;
+    const archiveFileBasename = url.split("?")[0].split("/").reverse()[0];
+    const archiveFilePath = (0,external_path_.join)(cacheDirPath, archiveFileBasename);
+    download: {
+        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
+            });
+        }
+        await (0,promises_.mkdir)((0,external_path_.dirname)(archiveFilePath), { recursive: true });
+        const response = await lib_default()(url, await getProxyFetchOptions({ npmWorkspaceRootDirPath }));
+        (_a = response.body) === null || _a === void 0 ? void 0 : _a.setMaxListeners(Number.MAX_VALUE);
+        (0,assert.assert)(typeof response.body !== "undefined" && response.body != null);
+        await (0,promises_.writeFile)(archiveFilePath, response.body);
+        await SuccessTracker.markAsDownloaded({
+            cacheDirPath,
+            archiveFileBasename
+        });
+    }
+    const extractDirBasename = `${archiveFileBasename.split(".")[0]}_${uniqueIdOfOnOnArchiveFile}_${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 (0,fs_rm.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 (0,fs_rm.rm)(extractedDirPath, { recursive: true });
+            await SuccessTracker.removeFromExtracted({
+                cacheDirPath,
+                extractDirBasename
+            });
+        }
+        await (0,extractArchive/* extractArchive */.N)({
+            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 };
+}
+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/tools/downloadAndExtractArchive/index.js
+
+//# sourceMappingURL=index.js.map
+// EXTERNAL MODULE: ./dist/bin/tools/isInside.js
+var isInside = __webpack_require__(90665);
+;// CONCATENATED MODULE: ./dist/bin/shared/downloadKeycloakDefaultTheme.js
+
+
+
+
+
+(0,assert.assert)();
+async function downloadKeycloakDefaultTheme(params) {
+    const { keycloakVersion, buildContext } = params;
+    const { extractedDirPath } = await downloadAndExtractArchive({
+        url: `https://repo1.maven.org/maven2/org/keycloak/keycloak-themes/${keycloakVersion}/keycloak-themes-${keycloakVersion}.jar`,
+        cacheDirPath: buildContext.cacheDirPath,
+        npmWorkspaceRootDirPath: buildContext.npmWorkspaceRootDirPath,
+        uniqueIdOfOnOnArchiveFile: "downloadKeycloakDefaultTheme",
+        onArchiveFile: async (params) => {
+            if (!(0,isInside/* isInside */.V)({ dirPath: "theme", filePath: params.fileRelativePath })) {
+                return;
+            }
+            const { readFile, writeFile } = params;
+            const fileRelativePath = (0,external_path_.relative)("theme", params.fileRelativePath);
+            skip_keycloak_v2: {
+                if (!(0,isInside/* isInside */.V)({
+                    dirPath: (0,external_path_.join)("keycloak.v2"),
+                    filePath: fileRelativePath
+                })) {
+                    break skip_keycloak_v2;
+                }
+                return;
+            }
+            last_account_v1_transformations: {
+                if (constants/* lastKeycloakVersionWithAccountV1 */.v$ !== keycloakVersion) {
+                    break last_account_v1_transformations;
+                }
+                patch_account_css: {
+                    if (fileRelativePath !==
+                        (0,external_path_.join)("keycloak", "account", "resources", "css", "account.css")) {
+                        break patch_account_css;
+                    }
+                    await writeFile({
+                        fileRelativePath,
+                        modifiedData: Buffer.from((await readFile())
+                            .toString("utf8")
+                            .replace("top: -34px;", "top: -34px !important;"), "utf8")
+                    });
+                    return;
+                }
+                skip_web_modules: {
+                    if (!(0,isInside/* isInside */.V)({
+                        dirPath: (0,external_path_.join)("keycloak", "common", "resources", "web_modules"),
+                        filePath: fileRelativePath
+                    })) {
+                        break skip_web_modules;
+                    }
+                    return;
+                }
+                skip_unused_node_modules: {
+                    const nodeModulesDirPath = (0,external_path_.join)("keycloak", "common", "resources", "node_modules");
+                    if (!(0,isInside/* isInside */.V)({
+                        dirPath: nodeModulesDirPath,
+                        filePath: fileRelativePath
+                    })) {
+                        break skip_unused_node_modules;
+                    }
+                    const toKeepPrefixes = [
+                        ...[
+                            "patternfly.min.css",
+                            "patternfly-additions.min.css",
+                            "patternfly-additions.min.css"
+                        ].map(fileBasename => (0,external_path_.join)(nodeModulesDirPath, "patternfly", "dist", "css", fileBasename)),
+                        (0,external_path_.join)(nodeModulesDirPath, "patternfly", "dist", "fonts")
+                    ];
+                    if (toKeepPrefixes.find(prefix => fileRelativePath.startsWith(prefix)) !== undefined) {
+                        break skip_unused_node_modules;
+                    }
+                    return;
+                }
+            }
+            skip_unused_resources: {
+                if (keycloakVersion !== "24.0.4") {
+                    break skip_unused_resources;
+                }
+                for (const dirBasename of [
+                    "@patternfly-v5",
+                    "@rollup",
+                    "rollup",
+                    "react",
+                    "react-dom",
+                    "shx",
+                    ".pnpm"
+                ]) {
+                    if ((0,isInside/* isInside */.V)({
+                        dirPath: (0,external_path_.join)("keycloak", "common", "resources", "node_modules", dirBasename),
+                        filePath: fileRelativePath
+                    })) {
+                        return;
+                    }
+                }
+                for (const dirBasename of ["react", "react-dom"]) {
+                    if ((0,isInside/* isInside */.V)({
+                        dirPath: (0,external_path_.join)("keycloak", "common", "resources", "vendor", dirBasename),
+                        filePath: fileRelativePath
+                    })) {
+                        return;
+                    }
+                }
+                if ((0,isInside/* isInside */.V)({
+                    dirPath: (0,external_path_.join)("keycloak", "common", "resources", "node_modules", "@patternfly", "react-core"),
+                    filePath: fileRelativePath
+                })) {
+                    return;
+                }
+            }
+            await writeFile({ fileRelativePath });
+        }
+    });
+    return { defaultThemeDirPath: extractedDirPath };
+}
+//# sourceMappingURL=downloadKeycloakDefaultTheme.js.map
+
+/***/ }),
+
+/***/ 62190:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "p": () => (/* binding */ downloadKeycloakStaticResources)
+/* harmony export */ });
+/* harmony import */ var _tools_transformCodebase__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(60332);
+/* 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 _downloadKeycloakDefaultTheme__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(47802);
+/* harmony import */ var _constants__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(173);
+/* harmony import */ var tsafe_assert__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(88078);
+/* harmony import */ var tsafe_assert__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(tsafe_assert__WEBPACK_IMPORTED_MODULE_4__);
+/* harmony import */ var _tools_fs_existsAsync__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(43765);
+
+
+
+
+
+
+(0,tsafe_assert__WEBPACK_IMPORTED_MODULE_4__.assert)();
+async function downloadKeycloakStaticResources(params) {
+    const { themeType, themeDirPath, keycloakVersion, buildContext } = params;
+    const { defaultThemeDirPath } = await (0,_downloadKeycloakDefaultTheme__WEBPACK_IMPORTED_MODULE_2__/* .downloadKeycloakDefaultTheme */ .x)({
+        keycloakVersion,
+        buildContext
+    });
+    const resourcesDirPath = (0,path__WEBPACK_IMPORTED_MODULE_1__.join)(themeDirPath, themeType, "resources");
+    repatriate_base_resources: {
+        const srcDirPath = (0,path__WEBPACK_IMPORTED_MODULE_1__.join)(defaultThemeDirPath, "base", themeType, "resources");
+        if (!(await (0,_tools_fs_existsAsync__WEBPACK_IMPORTED_MODULE_5__/* .existsAsync */ .o)(srcDirPath))) {
+            break repatriate_base_resources;
+        }
+        (0,_tools_transformCodebase__WEBPACK_IMPORTED_MODULE_0__/* .transformCodebase */ .N)({
+            srcDirPath,
+            destDirPath: resourcesDirPath
+        });
+    }
+    (0,_tools_transformCodebase__WEBPACK_IMPORTED_MODULE_0__/* .transformCodebase */ .N)({
+        srcDirPath: (0,path__WEBPACK_IMPORTED_MODULE_1__.join)(defaultThemeDirPath, "keycloak", themeType, "resources"),
+        destDirPath: resourcesDirPath
+    });
+    (0,_tools_transformCodebase__WEBPACK_IMPORTED_MODULE_0__/* .transformCodebase */ .N)({
+        srcDirPath: (0,path__WEBPACK_IMPORTED_MODULE_1__.join)(defaultThemeDirPath, "keycloak", "common", "resources"),
+        destDirPath: (0,path__WEBPACK_IMPORTED_MODULE_1__.join)(resourcesDirPath, _constants__WEBPACK_IMPORTED_MODULE_3__/* .resources_common */ .z0)
+    });
+}
+//# sourceMappingURL=downloadKeycloakStaticResources.js.map
+
+/***/ }),
+
+/***/ 64409:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "C": () => (/* binding */ getImplementedThemeTypes)
+/* 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_objectFromEntries__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(68634);
+/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(57147);
+/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(fs__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _getThemeSrcDirPath__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(39216);
+
+
+
+
+function getImplementedThemeTypes(params) {
+    const { projectDirPath } = params;
+    const { themeSrcDirPath } = (0,_getThemeSrcDirPath__WEBPACK_IMPORTED_MODULE_3__/* .getThemeSrcDirPath */ .f)({
+        projectDirPath
+    });
+    const implementedThemeTypes = (0,tsafe_objectFromEntries__WEBPACK_IMPORTED_MODULE_1__.objectFromEntries)(["login", "account", "email"].map(themeType => [
+        themeType,
+        fs__WEBPACK_IMPORTED_MODULE_2__.existsSync((0,path__WEBPACK_IMPORTED_MODULE_0__.join)(themeSrcDirPath, themeType))
+    ]));
+    return { implementedThemeTypes };
+}
+//# sourceMappingURL=getImplementedThemeTypes.js.map
+
+/***/ }),
+
 /***/ 2323:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
@@ -1398,111 +1890,56 @@ function getJarFileBasename(params) {
 /* harmony import */ var path__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(71017);
 /* harmony import */ var path__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_3__);
 /* harmony import */ var _constants__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(173);
+/* harmony import */ var chalk__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(78818);
+/* harmony import */ var chalk__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(chalk__WEBPACK_IMPORTED_MODULE_5__);
 
 
 
 
 
-const themeSrcDirBasenames = ["keycloak-theme", "keycloak_theme"];
+
+let cache = undefined;
 /** Can't catch error, if the directory isn't found, this function will just exit the process with an error message. */
 function getThemeSrcDirPath(params) {
     const { projectDirPath } = params;
-    const srcDirPath = (0,path__WEBPACK_IMPORTED_MODULE_3__.join)(projectDirPath, "src");
-    const themeSrcDirPath = (0,_tools_crawl__WEBPACK_IMPORTED_MODULE_2__/* .crawl */ .J)({
-        dirPath: srcDirPath,
-        returnedPathsType: "relative to dirPath"
-    })
-        .map(fileRelativePath => {
-        for (const themeSrcDirBasename of themeSrcDirBasenames) {
-            const split = fileRelativePath.split(themeSrcDirBasename);
-            if (split.length === 2) {
-                return (0,path__WEBPACK_IMPORTED_MODULE_3__.join)(srcDirPath, split[0] + themeSrcDirBasename);
-            }
-        }
-        return undefined;
-    })
-        .filter((0,tsafe__WEBPACK_IMPORTED_MODULE_1__.exclude)(undefined))[0];
-    if (themeSrcDirPath !== undefined) {
+    if (cache !== undefined && cache.projectDirPath === projectDirPath) {
+        const { themeSrcDirPath } = cache;
         return { themeSrcDirPath };
     }
-    for (const themeType of [..._constants__WEBPACK_IMPORTED_MODULE_4__/* .themeTypes */ .rO, "email"]) {
-        if (!fs__WEBPACK_IMPORTED_MODULE_0__.existsSync((0,path__WEBPACK_IMPORTED_MODULE_3__.join)(srcDirPath, themeType))) {
-            continue;
-        }
-        return { themeSrcDirPath: srcDirPath };
-    }
-    console.error([
-        "Can't locate your theme source directory. It should be either: ",
-        "src/ or src/keycloak-theme or src/keycloak_theme.",
-        "Example in the starter: https://github.com/keycloakify/keycloakify-starter/tree/main/src/keycloak-theme"
-    ].join("\n"));
-    process.exit(-1);
-}
-//# sourceMappingURL=getThemeSrcDirPath.js.map
-
-/***/ }),
-
-/***/ 26914:
-/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
-
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   "IS": () => (/* binding */ readMetaInfKeycloakThemes_fromJar),
-/* harmony export */   "JJ": () => (/* binding */ writeMetaInfKeycloakThemes),
-/* harmony export */   "Ju": () => (/* binding */ readMetaInfKeycloakThemes_fromResourcesDirPath),
-/* harmony export */   "KQ": () => (/* binding */ getMetaInfKeycloakThemesJsonFilePath)
-/* 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 fs__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(57147);
-/* harmony import */ var fs__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(fs__WEBPACK_IMPORTED_MODULE_1__);
-/* harmony import */ var tsafe_assert__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(88078);
-/* harmony import */ var tsafe_assert__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(tsafe_assert__WEBPACK_IMPORTED_MODULE_2__);
-/* harmony import */ var _tools_extractArchive__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(29121);
-
-
-
-
-function getMetaInfKeycloakThemesJsonFilePath(params) {
-    const { resourcesDirPath } = params;
-    return (0,path__WEBPACK_IMPORTED_MODULE_0__.join)(resourcesDirPath === "." ? "" : resourcesDirPath, "META-INF", "keycloak-themes.json");
-}
-function readMetaInfKeycloakThemes_fromResourcesDirPath(params) {
-    const { resourcesDirPath } = params;
-    return JSON.parse(fs__WEBPACK_IMPORTED_MODULE_1__.readFileSync(getMetaInfKeycloakThemesJsonFilePath({
-        resourcesDirPath
-    }))
-        .toString("utf8"));
-}
-async function readMetaInfKeycloakThemes_fromJar(params) {
-    const { jarFilePath } = params;
-    let metaInfKeycloakThemes = undefined;
-    await (0,_tools_extractArchive__WEBPACK_IMPORTED_MODULE_3__/* .extractArchive */ .N)({
-        archiveFilePath: jarFilePath,
-        onArchiveFile: async ({ relativeFilePathInArchive, readFile, earlyExit }) => {
-            if (relativeFilePathInArchive ===
-                getMetaInfKeycloakThemesJsonFilePath({ resourcesDirPath: "." })) {
-                metaInfKeycloakThemes = JSON.parse((await readFile()).toString("utf8"));
-                earlyExit();
+    cache = undefined;
+    const { themeSrcDirPath } = (() => {
+        const srcDirPath = (0,path__WEBPACK_IMPORTED_MODULE_3__.join)(projectDirPath, "src");
+        const themeSrcDirPath = (0,_tools_crawl__WEBPACK_IMPORTED_MODULE_2__/* .crawl */ .J)({
+            dirPath: srcDirPath,
+            returnedPathsType: "relative to dirPath"
+        })
+            .map(fileRelativePath => {
+            for (const themeSrcDirBasename of themeSrcDirBasenames) {
+                const split = fileRelativePath.split(themeSrcDirBasename);
+                if (split.length === 2) {
+                    return (0,path__WEBPACK_IMPORTED_MODULE_3__.join)(srcDirPath, split[0] + themeSrcDirBasename);
+                }
             }
+            return undefined;
+        })
+            .filter((0,tsafe__WEBPACK_IMPORTED_MODULE_1__.exclude)(undefined))[0];
+        if (themeSrcDirPath !== undefined) {
+            return { themeSrcDirPath };
         }
-    });
-    (0,tsafe_assert__WEBPACK_IMPORTED_MODULE_2__.assert)(metaInfKeycloakThemes !== undefined);
-    return metaInfKeycloakThemes;
-}
-function writeMetaInfKeycloakThemes(params) {
-    const { resourcesDirPath, metaInfKeycloakThemes } = params;
-    const metaInfKeycloakThemesJsonPath = getMetaInfKeycloakThemesJsonFilePath({
-        resourcesDirPath
-    });
-    {
-        const dirPath = (0,path__WEBPACK_IMPORTED_MODULE_0__.dirname)(metaInfKeycloakThemesJsonPath);
-        if (!fs__WEBPACK_IMPORTED_MODULE_1__.existsSync(dirPath)) {
-            fs__WEBPACK_IMPORTED_MODULE_1__.mkdirSync(dirPath, { recursive: true });
+        for (const themeType of [..._constants__WEBPACK_IMPORTED_MODULE_4__/* .themeTypes */ .rO, "email"]) {
+            if (!fs__WEBPACK_IMPORTED_MODULE_0__.existsSync((0,path__WEBPACK_IMPORTED_MODULE_3__.join)(srcDirPath, themeType))) {
+                continue;
+            }
+            return { themeSrcDirPath: srcDirPath };
         }
-    }
-    fs__WEBPACK_IMPORTED_MODULE_1__.writeFileSync(metaInfKeycloakThemesJsonPath, Buffer.from(JSON.stringify(metaInfKeycloakThemes, null, 2), "utf8"));
+        console.log(chalk__WEBPACK_IMPORTED_MODULE_5___default().red("Can't locate your theme source directory. It should be either: "));
+        process.exit(-1);
+    })();
+    cache = { projectDirPath, themeSrcDirPath };
+    return { themeSrcDirPath };
 }
-//# sourceMappingURL=metaInfKeycloakThemes.js.map
+const themeSrcDirBasenames = ["keycloak-theme", "keycloak_theme"];
+//# sourceMappingURL=getThemeSrcDirPath.js.map
 
 /***/ }),
 
@@ -1577,6 +2014,117 @@ function escapeStringForPropertiesFile(str) {
 }
 //# sourceMappingURL=escapeStringForPropertiesFile.js.map
 
+/***/ }),
+
+/***/ 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
+
+/***/ }),
+
+/***/ 60332:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "N": () => (/* binding */ transformCodebase)
+/* 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 _crawl__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(73036);
+/* harmony import */ var _tools_fs_rmSync__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(89693);
+
+
+
+
+/**
+ * Apply a transformation function to every file of directory
+ * If source and destination are the same this function can be used to apply the transformation in place
+ * like filtering out some files or modifying them.
+ * */
+function transformCodebase(params) {
+    const { srcDirPath, transformSourceCode } = params;
+    const isTargetSameAsSource = path__WEBPACK_IMPORTED_MODULE_1__.relative(srcDirPath, params.destDirPath) === "";
+    const destDirPath = isTargetSameAsSource
+        ? path__WEBPACK_IMPORTED_MODULE_1__.join(srcDirPath, "..", "tmp_xOsPdkPsTdzPs34sOkHs")
+        : params.destDirPath;
+    fs__WEBPACK_IMPORTED_MODULE_0__.mkdirSync(destDirPath, {
+        recursive: true
+    });
+    for (const fileRelativePath of (0,_crawl__WEBPACK_IMPORTED_MODULE_2__/* .crawl */ .J)({
+        dirPath: srcDirPath,
+        returnedPathsType: "relative to dirPath"
+    })) {
+        const filePath = path__WEBPACK_IMPORTED_MODULE_1__.join(srcDirPath, fileRelativePath);
+        const destFilePath = path__WEBPACK_IMPORTED_MODULE_1__.join(destDirPath, fileRelativePath);
+        // NOTE: Optimization, if we don't need to transform the file, just copy
+        // it using the lower level implementation.
+        if (transformSourceCode === undefined) {
+            fs__WEBPACK_IMPORTED_MODULE_0__.mkdirSync(path__WEBPACK_IMPORTED_MODULE_1__.dirname(destFilePath), {
+                recursive: true
+            });
+            fs__WEBPACK_IMPORTED_MODULE_0__.copyFileSync(filePath, destFilePath);
+            continue;
+        }
+        const transformSourceCodeResult = transformSourceCode({
+            sourceCode: fs__WEBPACK_IMPORTED_MODULE_0__.readFileSync(filePath),
+            filePath,
+            fileRelativePath
+        });
+        if (transformSourceCodeResult === undefined) {
+            continue;
+        }
+        fs__WEBPACK_IMPORTED_MODULE_0__.mkdirSync(path__WEBPACK_IMPORTED_MODULE_1__.dirname(destFilePath), {
+            recursive: true
+        });
+        const { newFileName, modifiedSourceCode } = transformSourceCodeResult;
+        fs__WEBPACK_IMPORTED_MODULE_0__.writeFileSync(path__WEBPACK_IMPORTED_MODULE_1__.join(path__WEBPACK_IMPORTED_MODULE_1__.dirname(destFilePath), newFileName !== null && newFileName !== void 0 ? newFileName : path__WEBPACK_IMPORTED_MODULE_1__.basename(destFilePath)), modifiedSourceCode);
+    }
+    if (isTargetSameAsSource) {
+        (0,_tools_fs_rmSync__WEBPACK_IMPORTED_MODULE_3__/* .rmSync */ .a)(srcDirPath, { recursive: true });
+        fs__WEBPACK_IMPORTED_MODULE_0__.renameSync(destDirPath, srcDirPath);
+    }
+}
+//# sourceMappingURL=transformCodebase.js.map
+
 /***/ })
 
 };