keycloakify 10.1.0-rc.1 → 10.1.1

package/bin/{365.index.js → 20.index.js}

@@ -1,181 +1,331 @@
 "use strict";
-exports.id = 365;
-exports.ids = [365];
+exports.id = 20;
+exports.ids = [20];
 exports.modules = {
 
-/***/ 33168:
+/***/ 97189:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
-  "x": () => (/* reexport */ downloadKeycloakDefaultTheme)
+  "_": () => (/* binding */ getLatestsSemVersionedTag)
 });
 
+;// CONCATENATED MODULE: ./dist/bin/tools/octokit-addons/listTags.js
+var __await = (undefined && undefined.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (undefined && undefined.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+const per_page = 99;
+function listTagsFactory(params) {
+    const { octokit } = params;
+    const octokit_repo_listTags = async (params) => {
+        return octokit.repos.listTags(params);
+    };
+    function listTags(params) {
+        return __asyncGenerator(this, arguments, function* listTags_1() {
+            const { owner, repo } = params;
+            let page = 1;
+            while (true) {
+                const resp = yield __await(octokit_repo_listTags({
+                    owner,
+                    repo,
+                    per_page,
+                    page: page++
+                }));
+                for (const branch of resp.data.map(({ name }) => name)) {
+                    yield yield __await(branch);
+                }
+                if (resp.data.length < 99) {
+                    break;
+                }
+            }
+        });
+    }
+    /** Returns the same "latest" tag as deno.land/x, not actually the latest though */
+    async function getLatestTag(params) {
+        const { owner, repo } = params;
+        const itRes = await listTags({ owner, repo }).next();
+        if (itRes.done) {
+            return undefined;
+        }
+        return itRes.value;
+    }
+    return { listTags, getLatestTag };
+}
+//# sourceMappingURL=listTags.js.map
+// EXTERNAL MODULE: ./dist/bin/tools/SemVer.js
+var SemVer = __webpack_require__(12171);
+;// CONCATENATED MODULE: ./dist/bin/tools/octokit-addons/getLatestsSemVersionedTag.js
+var __asyncValues = (undefined && undefined.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+
+
+function getLatestsSemVersionedTagFactory(params) {
+    const { octokit } = params;
+    async function getLatestsSemVersionedTag(params) {
+        var _a, e_1, _b, _c;
+        const { owner, repo, count, doIgnoreReleaseCandidates } = params;
+        const semVersionedTags = [];
+        const { listTags } = listTagsFactory({ octokit });
+        try {
+            for (var _d = true, _e = __asyncValues(listTags({ owner, repo })), _f; _f = await _e.next(), _a = _f.done, !_a;) {
+                _c = _f.value;
+                _d = false;
+                try {
+                    const tag = _c;
+                    let version;
+                    try {
+                        version = SemVer/* SemVer.parse */.h.parse(tag.replace(/^[vV]?/, ""));
+                    }
+                    catch (_g) {
+                        continue;
+                    }
+                    if (doIgnoreReleaseCandidates && version.rc !== undefined) {
+                        continue;
+                    }
+                    semVersionedTags.push({ tag, version });
+                }
+                finally {
+                    _d = true;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = _e.return)) await _b.call(_e);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return semVersionedTags
+            .sort(({ version: vX }, { version: vY }) => SemVer/* SemVer.compare */.h.compare(vY, vX))
+            .slice(0, count);
+    }
+    return { getLatestsSemVersionedTag };
+}
+//# sourceMappingURL=getLatestsSemVersionedTag.js.map
+// EXTERNAL MODULE: ./node_modules/@octokit/rest/dist-node/index.js
+var dist_node = __webpack_require__(55375);
 // EXTERNAL MODULE: external "path"
 var external_path_ = __webpack_require__(71017);
+// EXTERNAL MODULE: external "fs"
+var external_fs_ = __webpack_require__(57147);
+// EXTERNAL MODULE: ./node_modules/zod/lib/index.mjs
+var lib = __webpack_require__(52300);
 // 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: ./dist/bin/tools/downloadAndExtractArchive.js
-var downloadAndExtractArchive = __webpack_require__(38367);
-// EXTERNAL MODULE: ./dist/bin/tools/getThisCodebaseRootDirPath.js
-var getThisCodebaseRootDirPath = __webpack_require__(58822);
-// EXTERNAL MODULE: external "fs/promises"
-var promises_ = __webpack_require__(73292);
-;// CONCATENATED MODULE: ./dist/bin/shared/downloadKeycloakDefaultTheme/downloadKeycloakDefaultTheme.js
+// EXTERNAL MODULE: ./node_modules/tsafe/id.js
+var id = __webpack_require__(43047);
+// EXTERNAL MODULE: ./node_modules/evt/tools/inDepth/same.js
+var same = __webpack_require__(33805);
+// 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);
+;// CONCATENATED MODULE: ./dist/bin/shared/getLatestsSemVersionedTag.js
+var __rest = (undefined && undefined.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+
 
 
 
 
 
 
+
+
+let getLatestsSemVersionedTag_stateless = undefined;
+const CACHE_VERSION = 1;
 (0,assert.assert)();
-async function downloadKeycloakDefaultTheme(params) {
-    const { keycloakVersion, buildContext } = params;
-    let kcNodeModulesKeepFilePaths = undefined;
-    let kcNodeModulesKeepFilePaths_lastAccountV1 = undefined;
-    let areExtraAssetsFor24Copied = false;
-    const { extractedDirPath } = await (0,downloadAndExtractArchive/* downloadAndExtractArchive */.I)({
-        url: `https://repo1.maven.org/maven2/org/keycloak/keycloak-themes/${keycloakVersion}/keycloak-themes-${keycloakVersion}.jar`,
-        cacheDirPath: buildContext.cacheDirPath,
-        fetchOptions: buildContext.fetchOptions,
-        uniqueIdOfOnArchiveFile: "downloadKeycloakDefaultTheme",
-        onArchiveFile: async (params) => {
-            const fileRelativePath = (0,external_path_.relative)("theme", params.fileRelativePath);
-            if (fileRelativePath.startsWith("..")) {
-                return;
+async function getLatestsSemVersionedTag(_a) {
+    var { buildContext } = _a, params = __rest(_a, ["buildContext"]);
+    const cacheFilePath = (0,external_path_.join)(buildContext.cacheDirPath, "latest-sem-versioned-tags.json");
+    const cacheLookupResult = (() => {
+        const getResult_currentCache = (currentCacheEntries) => ({
+            hasCachedResult: false,
+            currentCache: {
+                version: CACHE_VERSION,
+                entries: currentCacheEntries
             }
-            skip_keycloak_v2: {
-                if (!fileRelativePath.startsWith((0,external_path_.join)("keycloak.v2"))) {
-                    break skip_keycloak_v2;
-                }
-                return;
-            }
-            const { readFile, writeFile } = params;
-            last_account_v1_transformations: {
-                if (constants/* LAST_KEYCLOAK_VERSION_WITH_ACCOUNT_V1 */.rK !== keycloakVersion) {
-                    break last_account_v1_transformations;
-                }
-                skip_web_modules: {
-                    if (!fileRelativePath.startsWith((0,external_path_.join)("keycloak", "common", "resources", "web_modules"))) {
-                        break skip_web_modules;
-                    }
-                    return;
-                }
-                skip_lib: {
-                    if (!fileRelativePath.startsWith((0,external_path_.join)("keycloak", "common", "resources", "lib"))) {
-                        break skip_lib;
-                    }
-                    return;
-                }
-                skip_node_modules: {
-                    const nodeModulesRelativeDirPath = (0,external_path_.join)("keycloak", "common", "resources", "node_modules");
-                    if (!fileRelativePath.startsWith(nodeModulesRelativeDirPath)) {
-                        break skip_node_modules;
-                    }
-                    if (kcNodeModulesKeepFilePaths_lastAccountV1 === undefined) {
-                        kcNodeModulesKeepFilePaths_lastAccountV1 = new Set([
-                            (0,external_path_.join)("patternfly", "dist", "css", "patternfly.min.css"),
-                            (0,external_path_.join)("patternfly", "dist", "css", "patternfly-additions.min.css"),
-                            (0,external_path_.join)("patternfly", "dist", "fonts", "OpenSans-Regular-webfont.woff2"),
-                            (0,external_path_.join)("patternfly", "dist", "fonts", "OpenSans-Bold-webfont.woff2"),
-                            (0,external_path_.join)("patternfly", "dist", "fonts", "OpenSans-Light-webfont.woff2"),
-                            (0,external_path_.join)("patternfly", "dist", "fonts", "OpenSans-Semibold-webfont.woff2"),
-                            (0,external_path_.join)("patternfly", "dist", "fonts", "PatternFlyIcons-webfont.ttf"),
-                            (0,external_path_.join)("patternfly", "dist", "fonts", "PatternFlyIcons-webfont.woff")
-                        ]);
-                    }
-                    const fileRelativeToNodeModulesPath = fileRelativePath.substring(nodeModulesRelativeDirPath.length + 1);
-                    if (kcNodeModulesKeepFilePaths_lastAccountV1.has(fileRelativeToNodeModulesPath)) {
-                        break skip_node_modules;
-                    }
-                    return;
-                }
-                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;
-                }
-            }
-            copy_extra_assets: {
-                if (keycloakVersion !== "24.0.4") {
-                    break copy_extra_assets;
-                }
-                if (areExtraAssetsFor24Copied) {
-                    break copy_extra_assets;
-                }
-                const extraAssetsDirPath = (0,external_path_.join)((0,getThisCodebaseRootDirPath/* getThisCodebaseRootDirPath */.e)(), "src", "bin", "shared", "downloadKeycloakDefaultTheme", "extra-assets");
-                await Promise.all(["webauthnAuthenticate.js", "passkeysConditionalAuth.js"].map(async (fileBasename) => writeFile({
-                    fileRelativePath: (0,external_path_.join)("base", "login", "resources", "js", fileBasename),
-                    modifiedData: await promises_.readFile((0,external_path_.join)(extraAssetsDirPath, fileBasename))
-                })));
-            }
-            skip_unused_resources: {
-                if (keycloakVersion !== "24.0.4") {
-                    break skip_unused_resources;
-                }
-                skip_node_modules: {
-                    const nodeModulesRelativeDirPath = (0,external_path_.join)("keycloak", "common", "resources", "node_modules");
-                    if (!fileRelativePath.startsWith(nodeModulesRelativeDirPath)) {
-                        break skip_node_modules;
-                    }
-                    if (kcNodeModulesKeepFilePaths === undefined) {
-                        kcNodeModulesKeepFilePaths = new Set([
-                            (0,external_path_.join)("@patternfly", "patternfly", "patternfly.min.css"),
-                            (0,external_path_.join)("patternfly", "dist", "css", "patternfly.min.css"),
-                            (0,external_path_.join)("patternfly", "dist", "css", "patternfly-additions.min.css"),
-                            (0,external_path_.join)("patternfly", "dist", "fonts", "OpenSans-Regular-webfont.woff2"),
-                            (0,external_path_.join)("patternfly", "dist", "fonts", "OpenSans-Light-webfont.woff2"),
-                            (0,external_path_.join)("patternfly", "dist", "fonts", "OpenSans-Bold-webfont.woff2"),
-                            (0,external_path_.join)("patternfly", "dist", "fonts", "OpenSans-Bold-webfont.woff"),
-                            (0,external_path_.join)("patternfly", "dist", "fonts", "OpenSans-Bold-webfont.ttf"),
-                            (0,external_path_.join)("patternfly", "dist", "fonts", "fontawesome-webfont.woff2"),
-                            (0,external_path_.join)("patternfly", "dist", "fonts", "PatternFlyIcons-webfont.ttf"),
-                            (0,external_path_.join)("patternfly", "dist", "fonts", "PatternFlyIcons-webfont.woff"),
-                            (0,external_path_.join)("patternfly", "dist", "fonts", "OpenSans-Semibold-webfont.woff2"),
-                            (0,external_path_.join)("patternfly", "dist", "img", "bg-login.jpg"),
-                            (0,external_path_.join)("jquery", "dist", "jquery.min.js")
-                        ]);
-                    }
-                    const fileRelativeToNodeModulesPath = fileRelativePath.substring(nodeModulesRelativeDirPath.length + 1);
-                    if (kcNodeModulesKeepFilePaths.has(fileRelativeToNodeModulesPath)) {
-                        break skip_node_modules;
-                    }
-                    return;
-                }
-                skip_vendor: {
-                    if (!fileRelativePath.startsWith((0,external_path_.join)("keycloak", "common", "resources", "vendor"))) {
-                        break skip_vendor;
-                    }
-                    return;
-                }
-                skip_rollup_config: {
-                    if (fileRelativePath !==
-                        (0,external_path_.join)("keycloak", "common", "resources", "rollup.config.js")) {
-                        break skip_rollup_config;
-                    }
-                    return;
-                }
-            }
-            await writeFile({ fileRelativePath });
+        });
+        if (!external_fs_.existsSync(cacheFilePath)) {
+            return getResult_currentCache([]);
+        }
+        let cache_json;
+        try {
+            cache_json = external_fs_.readFileSync(cacheFilePath).toString("utf8");
+        }
+        catch (_a) {
+            return getResult_currentCache([]);
+        }
+        let cache_json_parsed;
+        try {
+            cache_json_parsed = JSON.parse(cache_json);
+        }
+        catch (_b) {
+            return getResult_currentCache([]);
         }
+        const zSemVer = (() => {
+            const zTargetType = lib.z.object({
+                major: lib.z.number(),
+                minor: lib.z.number(),
+                patch: lib.z.number(),
+                rc: lib.z.number().optional(),
+                parsedFrom: lib.z.string()
+            });
+            (0,assert.assert)();
+            return (0,id.id)(zTargetType);
+        })();
+        const zCache = (() => {
+            const zTargetType = lib.z.object({
+                version: lib.z.literal(CACHE_VERSION),
+                entries: lib.z.array(lib.z.object({
+                    time: lib.z.number(),
+                    params: lib.z.object({
+                        owner: lib.z.string(),
+                        repo: lib.z.string(),
+                        count: lib.z.number(),
+                        doIgnoreReleaseCandidates: lib.z.boolean()
+                    }),
+                    result: lib.z.array(lib.z.object({
+                        tag: lib.z.string(),
+                        version: zSemVer
+                    }))
+                }))
+            });
+            (0,assert.assert)();
+            return (0,id.id)(zTargetType);
+        })();
+        let cache;
+        try {
+            cache = zCache.parse(cache_json_parsed);
+        }
+        catch (_c) {
+            return getResult_currentCache([]);
+        }
+        const cacheEntry = cache.entries.find(e => (0,same.same)(e.params, params));
+        if (cacheEntry === undefined) {
+            return getResult_currentCache(cache.entries);
+        }
+        if (Date.now() - cacheEntry.time > 3600000) {
+            return getResult_currentCache(cache.entries.filter(e => e !== cacheEntry));
+        }
+        return {
+            hasCachedResult: true,
+            cachedResult: cacheEntry.result
+        };
+    })();
+    if (cacheLookupResult.hasCachedResult) {
+        return cacheLookupResult.cachedResult;
+    }
+    const { currentCache } = cacheLookupResult;
+    getLatestsSemVersionedTag_stateless !== null && getLatestsSemVersionedTag_stateless !== void 0 ? getLatestsSemVersionedTag_stateless : (getLatestsSemVersionedTag_stateless = (() => {
+        const octokit = (() => {
+            const githubToken = process.env.GITHUB_TOKEN;
+            const octokit = new dist_node.Octokit(Object.assign(Object.assign({}, (githubToken === undefined ? {} : { auth: githubToken })), { request: {
+                    fetch: (url, options) => lib_default()(url, Object.assign(Object.assign({}, options), buildContext.fetchOptions))
+                } }));
+            return octokit;
+        })();
+        const { getLatestsSemVersionedTag } = getLatestsSemVersionedTagFactory({
+            octokit
+        });
+        return getLatestsSemVersionedTag;
+    })());
+    const result = await getLatestsSemVersionedTag_stateless(params);
+    currentCache.entries.push({
+        time: Date.now(),
+        params,
+        result
     });
-    return { defaultThemeDirPath: extractedDirPath };
+    {
+        const dirPath = (0,external_path_.dirname)(cacheFilePath);
+        if (!external_fs_.existsSync(dirPath)) {
+            external_fs_.mkdirSync(dirPath, { recursive: true });
+        }
+    }
+    external_fs_.writeFileSync(cacheFilePath, JSON.stringify(currentCache, null, 2));
+    return result;
 }
-//# sourceMappingURL=downloadKeycloakDefaultTheme.js.map
-;// CONCATENATED MODULE: ./dist/bin/shared/downloadKeycloakDefaultTheme/index.js
+//# sourceMappingURL=getLatestsSemVersionedTag.js.map
 
-//# sourceMappingURL=index.js.map
+/***/ }),
+
+/***/ 82635:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "s": () => (/* binding */ promptKeycloakVersion)
+/* harmony export */ });
+/* harmony import */ var _getLatestsSemVersionedTag__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(97189);
+/* harmony import */ var cli_select__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(99398);
+/* harmony import */ var cli_select__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(cli_select__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var 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_SemVer__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(12171);
+
+
+
+
+(0,tsafe_assert__WEBPACK_IMPORTED_MODULE_2__.assert)();
+async function promptKeycloakVersion(params) {
+    const { startingFromMajor, excludeMajorVersions, doOmitPatch, buildContext } = params;
+    const semVersionedTagByMajor = new Map();
+    const semVersionedTags = await (0,_getLatestsSemVersionedTag__WEBPACK_IMPORTED_MODULE_0__/* .getLatestsSemVersionedTag */ ._)({
+        count: 50,
+        owner: "keycloak",
+        repo: "keycloak",
+        doIgnoreReleaseCandidates: true,
+        buildContext
+    });
+    semVersionedTags.forEach(semVersionedTag => {
+        if (startingFromMajor !== undefined &&
+            semVersionedTag.version.major < startingFromMajor) {
+            return;
+        }
+        if (excludeMajorVersions.includes(semVersionedTag.version.major)) {
+            return;
+        }
+        const currentSemVersionedTag = semVersionedTagByMajor.get(semVersionedTag.version.major);
+        if (currentSemVersionedTag !== undefined &&
+            _tools_SemVer__WEBPACK_IMPORTED_MODULE_3__/* .SemVer.compare */ .h.compare(semVersionedTag.version, currentSemVersionedTag.version) === -1) {
+            return;
+        }
+        semVersionedTagByMajor.set(semVersionedTag.version.major, semVersionedTag);
+    });
+    const lastMajorVersions = Array.from(semVersionedTagByMajor.values()).map(({ version }) => `${version.major}.${version.minor}${doOmitPatch ? "" : `.${version.patch}`}`);
+    const { value } = await cli_select__WEBPACK_IMPORTED_MODULE_1___default()({
+        values: lastMajorVersions
+    }).catch(() => {
+        process.exit(-1);
+    });
+    const keycloakVersion = value.split(" ")[0];
+    return { keycloakVersion };
+}
+//# sourceMappingURL=promptKeycloakVersion.js.map
 
 /***/ }),
 
@@ -632,117 +782,6 @@ async function checkDirExists(dirPath) {
 }
 //# sourceMappingURL=fs.rm.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
-
 /***/ })
 
 };