keycloakify 10.0.0-rc.99 → 10.0.0

package/bin/{893.index.js → 622.index.js}

@@ -1,262 +1,88 @@
 "use strict";
-exports.id = 893;
-exports.ids = [893];
+exports.id = 622;
+exports.ids = [622];
 exports.modules = {
 
-/***/ 77741:
+/***/ 60597:
 /***/ ((__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 "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.js
-
-
-
-
-
-
-
-
-async function downloadAndExtractArchive(params) {
-    var _a;
-    const { url, uniqueIdOfOnOnArchiveFile, onArchiveFile, cacheDirPath, fetchOptions } = 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, fetchOptions);
-        (_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/shared/downloadKeycloakDefaultTheme.js
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "x": () => (/* binding */ downloadKeycloakDefaultTheme)
+/* 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_1__ = __webpack_require__(88078);
+/* harmony import */ var tsafe_assert__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(tsafe_assert__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _constants__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(173);
+/* harmony import */ var _tools_downloadAndExtractArchive__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(38367);
 
 
 
 
-(0,assert.assert)();
+(0,tsafe_assert__WEBPACK_IMPORTED_MODULE_1__.assert)();
 async function downloadKeycloakDefaultTheme(params) {
     const { keycloakVersion, buildContext } = params;
     let kcNodeModulesKeepFilePaths = undefined;
     let kcNodeModulesKeepFilePaths_lastAccountV1 = undefined;
-    const { extractedDirPath } = await downloadAndExtractArchive({
+    const { extractedDirPath } = await (0,_tools_downloadAndExtractArchive__WEBPACK_IMPORTED_MODULE_3__/* .downloadAndExtractArchive */ .I)({
         url: `https://repo1.maven.org/maven2/org/keycloak/keycloak-themes/${keycloakVersion}/keycloak-themes-${keycloakVersion}.jar`,
         cacheDirPath: buildContext.cacheDirPath,
         fetchOptions: buildContext.fetchOptions,
-        uniqueIdOfOnOnArchiveFile: "downloadKeycloakDefaultTheme",
+        uniqueIdOfOnArchiveFile: "downloadKeycloakDefaultTheme",
         onArchiveFile: async (params) => {
-            const fileRelativePath = (0,external_path_.relative)("theme", params.fileRelativePath);
+            const fileRelativePath = (0,path__WEBPACK_IMPORTED_MODULE_0__.relative)("theme", params.fileRelativePath);
             if (fileRelativePath.startsWith("..")) {
                 return;
             }
             const { readFile, writeFile } = params;
             skip_keycloak_v2: {
-                if (!fileRelativePath.startsWith((0,external_path_.join)("keycloak.v2"))) {
+                if (!fileRelativePath.startsWith((0,path__WEBPACK_IMPORTED_MODULE_0__.join)("keycloak.v2"))) {
                     break skip_keycloak_v2;
                 }
                 return;
             }
             last_account_v1_transformations: {
-                if (constants/* lastKeycloakVersionWithAccountV1 */.v$ !== keycloakVersion) {
+                if (_constants__WEBPACK_IMPORTED_MODULE_2__/* .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"))) {
+                    if (!fileRelativePath.startsWith((0,path__WEBPACK_IMPORTED_MODULE_0__.join)("keycloak", "common", "resources", "web_modules"))) {
                         break skip_web_modules;
                     }
                     return;
                 }
                 skip_lib: {
-                    if (!fileRelativePath.startsWith((0,external_path_.join)("keycloak", "common", "resources", "lib"))) {
+                    if (!fileRelativePath.startsWith((0,path__WEBPACK_IMPORTED_MODULE_0__.join)("keycloak", "common", "resources", "lib"))) {
                         break skip_lib;
                     }
                     return;
                 }
                 skip_node_modules: {
-                    if (!fileRelativePath.startsWith((0,external_path_.join)("keycloak", "common", "resources", "node_modules"))) {
+                    const nodeModulesRelativeDirPath = (0,path__WEBPACK_IMPORTED_MODULE_0__.join)("keycloak", "common", "resources", "node_modules");
+                    if (!fileRelativePath.startsWith(nodeModulesRelativeDirPath)) {
                         break skip_node_modules;
                     }
                     if (kcNodeModulesKeepFilePaths_lastAccountV1 === undefined) {
-                        kcNodeModulesKeepFilePaths_lastAccountV1 = [
-                            (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")
-                        ];
+                        kcNodeModulesKeepFilePaths_lastAccountV1 = new Set([
+                            (0,path__WEBPACK_IMPORTED_MODULE_0__.join)("patternfly", "dist", "css", "patternfly.min.css"),
+                            (0,path__WEBPACK_IMPORTED_MODULE_0__.join)("patternfly", "dist", "css", "patternfly-additions.min.css"),
+                            (0,path__WEBPACK_IMPORTED_MODULE_0__.join)("patternfly", "dist", "fonts", "OpenSans-Regular-webfont.woff2"),
+                            (0,path__WEBPACK_IMPORTED_MODULE_0__.join)("patternfly", "dist", "fonts", "OpenSans-Bold-webfont.woff2"),
+                            (0,path__WEBPACK_IMPORTED_MODULE_0__.join)("patternfly", "dist", "fonts", "OpenSans-Light-webfont.woff2"),
+                            (0,path__WEBPACK_IMPORTED_MODULE_0__.join)("patternfly", "dist", "fonts", "OpenSans-Semibold-webfont.woff2"),
+                            (0,path__WEBPACK_IMPORTED_MODULE_0__.join)("patternfly", "dist", "fonts", "PatternFlyIcons-webfont.ttf"),
+                            (0,path__WEBPACK_IMPORTED_MODULE_0__.join)("patternfly", "dist", "fonts", "PatternFlyIcons-webfont.woff")
+                        ]);
                     }
-                    for (const keepPath of kcNodeModulesKeepFilePaths_lastAccountV1) {
-                        if (fileRelativePath.endsWith(keepPath)) {
-                            break skip_node_modules;
-                        }
+                    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")) {
+                        (0,path__WEBPACK_IMPORTED_MODULE_0__.join)("keycloak", "account", "resources", "css", "account.css")) {
                         break patch_account_css;
                     }
                     await writeFile({
@@ -273,41 +99,43 @@ async function downloadKeycloakDefaultTheme(params) {
                     break skip_unused_resources;
                 }
                 skip_node_modules: {
-                    if (!fileRelativePath.startsWith((0,external_path_.join)("keycloak", "common", "resources", "node_modules"))) {
+                    const nodeModulesRelativeDirPath = (0,path__WEBPACK_IMPORTED_MODULE_0__.join)("keycloak", "common", "resources", "node_modules");
+                    if (!fileRelativePath.startsWith(nodeModulesRelativeDirPath)) {
                         break skip_node_modules;
                     }
                     if (kcNodeModulesKeepFilePaths === undefined) {
-                        kcNodeModulesKeepFilePaths = [
-                            (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)("jquery", "dist", "jquery.min.js")
-                        ];
+                        kcNodeModulesKeepFilePaths = new Set([
+                            (0,path__WEBPACK_IMPORTED_MODULE_0__.join)("@patternfly", "patternfly", "patternfly.min.css"),
+                            (0,path__WEBPACK_IMPORTED_MODULE_0__.join)("patternfly", "dist", "css", "patternfly.min.css"),
+                            (0,path__WEBPACK_IMPORTED_MODULE_0__.join)("patternfly", "dist", "css", "patternfly-additions.min.css"),
+                            (0,path__WEBPACK_IMPORTED_MODULE_0__.join)("patternfly", "dist", "fonts", "OpenSans-Regular-webfont.woff2"),
+                            (0,path__WEBPACK_IMPORTED_MODULE_0__.join)("patternfly", "dist", "fonts", "OpenSans-Light-webfont.woff2"),
+                            (0,path__WEBPACK_IMPORTED_MODULE_0__.join)("patternfly", "dist", "fonts", "OpenSans-Bold-webfont.woff2"),
+                            (0,path__WEBPACK_IMPORTED_MODULE_0__.join)("patternfly", "dist", "fonts", "OpenSans-Bold-webfont.woff"),
+                            (0,path__WEBPACK_IMPORTED_MODULE_0__.join)("patternfly", "dist", "fonts", "OpenSans-Bold-webfont.ttf"),
+                            (0,path__WEBPACK_IMPORTED_MODULE_0__.join)("patternfly", "dist", "fonts", "fontawesome-webfont.woff2"),
+                            (0,path__WEBPACK_IMPORTED_MODULE_0__.join)("patternfly", "dist", "fonts", "PatternFlyIcons-webfont.ttf"),
+                            (0,path__WEBPACK_IMPORTED_MODULE_0__.join)("patternfly", "dist", "fonts", "PatternFlyIcons-webfont.woff"),
+                            (0,path__WEBPACK_IMPORTED_MODULE_0__.join)("patternfly", "dist", "fonts", "OpenSans-Semibold-webfont.woff2"),
+                            (0,path__WEBPACK_IMPORTED_MODULE_0__.join)("patternfly", "dist", "img", "bg-login.jpg"),
+                            (0,path__WEBPACK_IMPORTED_MODULE_0__.join)("jquery", "dist", "jquery.min.js")
+                        ]);
                     }
-                    for (const keepPath of kcNodeModulesKeepFilePaths) {
-                        if (fileRelativePath.endsWith(keepPath)) {
-                            break skip_node_modules;
-                        }
+                    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"))) {
+                    if (!fileRelativePath.startsWith((0,path__WEBPACK_IMPORTED_MODULE_0__.join)("keycloak", "common", "resources", "vendor"))) {
                         break skip_vendor;
                     }
                     return;
                 }
                 skip_rollup_config: {
                     if (fileRelativePath !==
-                        (0,external_path_.join)("keycloak", "common", "resources", "rollup.config.js")) {
+                        (0,path__WEBPACK_IMPORTED_MODULE_0__.join)("keycloak", "common", "resources", "rollup.config.js")) {
                         break skip_rollup_config;
                     }
                     return;
@@ -407,6 +235,186 @@ var SemVer;
 
 /***/ }),
 
+/***/ 38367:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "I": () => (/* binding */ downloadAndExtractArchive)
+/* harmony export */ });
+/* harmony import */ var make_fetch_happen__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(9525);
+/* harmony import */ var make_fetch_happen__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(make_fetch_happen__WEBPACK_IMPORTED_MODULE_0__);
+/* 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__(88078);
+/* harmony import */ var tsafe_assert__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(tsafe_assert__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var _extractArchive__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(29121);
+/* harmony import */ var _fs_existsAsync__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(43765);
+/* harmony import */ var crypto__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(6113);
+/* harmony import */ var crypto__WEBPACK_IMPORTED_MODULE_6___default = /*#__PURE__*/__webpack_require__.n(crypto__WEBPACK_IMPORTED_MODULE_6__);
+/* harmony import */ var _fs_rm__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(8699);
+
+
+
+
+
+
+
+
+async function downloadAndExtractArchive(params) {
+    var _a;
+    const { url, uniqueIdOfOnArchiveFile, onArchiveFile, cacheDirPath, fetchOptions } = params;
+    const archiveFileBasename = url.split("?")[0].split("/").reverse()[0];
+    const archiveFilePath = (0,path__WEBPACK_IMPORTED_MODULE_2__.join)(cacheDirPath, archiveFileBasename);
+    download: {
+        await (0,fs_promises__WEBPACK_IMPORTED_MODULE_1__.mkdir)((0,path__WEBPACK_IMPORTED_MODULE_2__.dirname)(archiveFilePath), { recursive: true });
+        if (await (0,_fs_existsAsync__WEBPACK_IMPORTED_MODULE_5__/* .existsAsync */ .o)(archiveFilePath)) {
+            const isDownloaded = await SuccessTracker.getIsDownloaded({
+                cacheDirPath,
+                archiveFileBasename
+            });
+            if (isDownloaded) {
+                break download;
+            }
+            await (0,fs_promises__WEBPACK_IMPORTED_MODULE_1__.unlink)(archiveFilePath);
+            await SuccessTracker.removeFromDownloaded({
+                cacheDirPath,
+                archiveFileBasename
+            });
+        }
+        const response = await make_fetch_happen__WEBPACK_IMPORTED_MODULE_0___default()(url, fetchOptions);
+        (_a = response.body) === null || _a === void 0 ? void 0 : _a.setMaxListeners(Number.MAX_VALUE);
+        (0,tsafe_assert__WEBPACK_IMPORTED_MODULE_3__.assert)(typeof response.body !== "undefined" && response.body != null);
+        await (0,fs_promises__WEBPACK_IMPORTED_MODULE_1__.writeFile)(archiveFilePath, response.body);
+        await SuccessTracker.markAsDownloaded({
+            cacheDirPath,
+            archiveFileBasename
+        });
+    }
+    const extractDirBasename = `${archiveFileBasename.replace(/\.([^.]+)$/, (...[, ext]) => `_${ext}`)}_${uniqueIdOfOnArchiveFile}_${crypto__WEBPACK_IMPORTED_MODULE_6__.createHash("sha256")
+        .update(onArchiveFile.toString())
+        .digest("hex")
+        .substring(0, 5)}`;
+    await Promise.all((await (0,fs_promises__WEBPACK_IMPORTED_MODULE_1__.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__WEBPACK_IMPORTED_MODULE_7__.rm)((0,path__WEBPACK_IMPORTED_MODULE_2__.join)(cacheDirPath, extractDirBasename), {
+            recursive: true
+        });
+        await SuccessTracker.removeFromExtracted({
+            cacheDirPath,
+            extractDirBasename
+        });
+    }));
+    const extractedDirPath = (0,path__WEBPACK_IMPORTED_MODULE_2__.join)(cacheDirPath, extractDirBasename);
+    extract_and_transform: {
+        if (await (0,_fs_existsAsync__WEBPACK_IMPORTED_MODULE_5__/* .existsAsync */ .o)(extractedDirPath)) {
+            const isExtracted = await SuccessTracker.getIsExtracted({
+                cacheDirPath,
+                extractDirBasename
+            });
+            if (isExtracted) {
+                break extract_and_transform;
+            }
+            await (0,_fs_rm__WEBPACK_IMPORTED_MODULE_7__.rm)(extractedDirPath, { recursive: true });
+            await SuccessTracker.removeFromExtracted({
+                cacheDirPath,
+                extractDirBasename
+            });
+        }
+        await (0,_extractArchive__WEBPACK_IMPORTED_MODULE_4__/* .extractArchive */ .N)({
+            archiveFilePath,
+            onArchiveFile: async ({ relativeFilePathInArchive, readFile, writeFile }) => onArchiveFile({
+                fileRelativePath: relativeFilePathInArchive,
+                readFile,
+                writeFile: ({ fileRelativePath, modifiedData }) => writeFile({
+                    filePath: (0,path__WEBPACK_IMPORTED_MODULE_2__.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,path__WEBPACK_IMPORTED_MODULE_2__.join)(cacheDirPath, "downloadAndExtractArchive.json");
+        if (!(await (0,_fs_existsAsync__WEBPACK_IMPORTED_MODULE_5__/* .existsAsync */ .o)(filePath))) {
+            return { archiveFileBasenames: [], extractDirBasenames: [] };
+        }
+        return JSON.parse((await (0,fs_promises__WEBPACK_IMPORTED_MODULE_1__.readFile)(filePath)).toString("utf8"));
+    }
+    async function write(params) {
+        const { cacheDirPath, successTracker } = params;
+        const filePath = (0,path__WEBPACK_IMPORTED_MODULE_2__.join)(cacheDirPath, "downloadAndExtractArchive.json");
+        {
+            const dirPath = (0,path__WEBPACK_IMPORTED_MODULE_2__.dirname)(filePath);
+            if (!(await (0,_fs_existsAsync__WEBPACK_IMPORTED_MODULE_5__/* .existsAsync */ .o)(dirPath))) {
+                await (0,fs_promises__WEBPACK_IMPORTED_MODULE_1__.mkdir)(dirPath, { recursive: true });
+            }
+        }
+        await (0,fs_promises__WEBPACK_IMPORTED_MODULE_1__.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
+
+/***/ }),
+
 /***/ 29121:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {