keycloakify 10.0.0-rc.7 → 10.0.0-rc.70

package/bin/837.index.js

@@ -0,0 +1,787 @@
+"use strict";
+exports.id = 837;
+exports.ids = [837];
+exports.modules = {
+
+/***/ 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
+;// CONCATENATED MODULE: ./dist/bin/shared/downloadKeycloakDefaultTheme.js
+
+
+
+
+(0,assert.assert)();
+async function downloadKeycloakDefaultTheme(params) {
+    const { keycloakVersion, buildContext } = params;
+    let kcNodeModulesKeepFilePaths = undefined;
+    let kcNodeModulesKeepFilePaths_lastAccountV1 = undefined;
+    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) => {
+            const fileRelativePath = (0,external_path_.relative)("theme", params.fileRelativePath);
+            if (fileRelativePath.startsWith("..")) {
+                return;
+            }
+            const { readFile, writeFile } = params;
+            skip_keycloak_v2: {
+                if (!fileRelativePath.startsWith((0,external_path_.join)("keycloak.v2"))) {
+                    break skip_keycloak_v2;
+                }
+                return;
+            }
+            last_account_v1_transformations: {
+                if (constants/* lastKeycloakVersionWithAccountV1 */.v$ !== 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: {
+                    if (!fileRelativePath.startsWith((0,external_path_.join)("keycloak", "common", "resources", "node_modules"))) {
+                        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")
+                        ];
+                    }
+                    for (const keepPath of kcNodeModulesKeepFilePaths_lastAccountV1) {
+                        if (fileRelativePath.endsWith(keepPath)) {
+                            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;
+                }
+            }
+            skip_unused_resources: {
+                if (keycloakVersion !== "24.0.4") {
+                    break skip_unused_resources;
+                }
+                skip_node_modules: {
+                    if (!fileRelativePath.startsWith((0,external_path_.join)("keycloak", "common", "resources", "node_modules"))) {
+                        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", "fontawesome-webfont.woff2"),
+                            (0,external_path_.join)("jquery", "dist", "jquery.min.js")
+                        ];
+                    }
+                    for (const keepPath of kcNodeModulesKeepFilePaths) {
+                        if (fileRelativePath.endsWith(keepPath)) {
+                            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 });
+        }
+    });
+    return { defaultThemeDirPath: extractedDirPath };
+}
+//# sourceMappingURL=downloadKeycloakDefaultTheme.js.map
+
+/***/ }),
+
+/***/ 12171:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "h": () => (/* binding */ SemVer)
+/* harmony export */ });
+var SemVer;
+(function (SemVer) {
+    const bumpTypes = ["major", "minor", "patch", "rc", "no bump"];
+    function parse(versionStr) {
+        const match = versionStr.match(/^v?([0-9]+)\.([0-9]+)(?:\.([0-9]+))?(?:-rc.([0-9]+))?$/);
+        if (!match) {
+            throw new Error(`${versionStr} is not a valid semantic version`);
+        }
+        const semVer = Object.assign({ major: parseInt(match[1]), minor: parseInt(match[2]), patch: (() => {
+                const str = match[3];
+                return str === undefined ? 0 : parseInt(str);
+            })() }, (() => {
+            const str = match[4];
+            return str === undefined ? {} : { rc: parseInt(str) };
+        })());
+        const initialStr = stringify(semVer);
+        Object.defineProperty(semVer, "parsedFrom", {
+            enumerable: true,
+            get: function () {
+                const currentStr = stringify(this);
+                if (currentStr !== initialStr) {
+                    throw new Error(`SemVer.parsedFrom can't be read anymore, the version have been modified from ${initialStr} to ${currentStr}`);
+                }
+                return versionStr;
+            }
+        });
+        return semVer;
+    }
+    SemVer.parse = parse;
+    function stringify(v) {
+        return `${v.major}.${v.minor}.${v.patch}${v.rc === undefined ? "" : `-rc.${v.rc}`}`;
+    }
+    SemVer.stringify = stringify;
+    /**
+     *
+     * v1  <  v2  => -1
+     * v1 === v2  => 0
+     * v1  >  v2  => 1
+     *
+     */
+    function compare(v1, v2) {
+        const sign = (diff) => (diff === 0 ? 0 : diff < 0 ? -1 : 1);
+        const noUndefined = (n) => n !== null && n !== void 0 ? n : Infinity;
+        for (const level of ["major", "minor", "patch", "rc"]) {
+            if (noUndefined(v1[level]) !== noUndefined(v2[level])) {
+                return sign(noUndefined(v1[level]) - noUndefined(v2[level]));
+            }
+        }
+        return 0;
+    }
+    SemVer.compare = compare;
+    /*
+    console.log(compare(parse("3.0.0-rc.3"), parse("3.0.0")) === -1 )
+    console.log(compare(parse("3.0.0-rc.3"), parse("3.0.0-rc.4")) === -1 )
+    console.log(compare(parse("3.0.0-rc.3"), parse("4.0.0")) === -1 )
+    */
+    function bumpType(params) {
+        const versionAhead = typeof params.versionAhead === "string"
+            ? parse(params.versionAhead)
+            : params.versionAhead;
+        const versionBehind = typeof params.versionBehind === "string"
+            ? parse(params.versionBehind)
+            : params.versionBehind;
+        if (compare(versionBehind, versionAhead) === 1) {
+            throw new Error(`Version regression ${stringify(versionBehind)} -> ${stringify(versionAhead)}`);
+        }
+        for (const level of ["major", "minor", "patch", "rc"]) {
+            if (versionBehind[level] !== versionAhead[level]) {
+                return level;
+            }
+        }
+        return "no bump";
+    }
+    SemVer.bumpType = bumpType;
+})(SemVer || (SemVer = {}));
+//# sourceMappingURL=SemVer.js.map
+
+/***/ }),
+
+/***/ 29121:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "N": () => (/* binding */ extractArchive)
+/* harmony export */ });
+/* harmony import */ var fs_promises__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(73292);
+/* harmony import */ var fs_promises__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(fs_promises__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var 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 yauzl__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(78781);
+/* harmony import */ var stream__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(12781);
+/* harmony import */ var stream__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(stream__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var evt_tools_Deferred__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(50689);
+/* harmony import */ var evt_tools_Deferred__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(evt_tools_Deferred__WEBPACK_IMPORTED_MODULE_4__);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(71017);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_5__);
+/* harmony import */ var _fs_existsAsync__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(43765);
+
+
+
+
+
+
+
+async function extractArchive(params) {
+    const { archiveFilePath, onArchiveFile } = params;
+    const zipFile = await new Promise((resolve, reject) => {
+        yauzl__WEBPACK_IMPORTED_MODULE_2__.open(archiveFilePath, { lazyEntries: true }, async (error, zipFile) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve(zipFile);
+        });
+    });
+    const dDone = new evt_tools_Deferred__WEBPACK_IMPORTED_MODULE_4__.Deferred();
+    zipFile.once("end", () => {
+        zipFile.close();
+        dDone.resolve();
+    });
+    const writeFile = async (entry, params) => {
+        const { filePath, modifiedData } = params;
+        {
+            const dirPath = (0,path__WEBPACK_IMPORTED_MODULE_5__.dirname)(filePath);
+            if (!(await (0,_fs_existsAsync__WEBPACK_IMPORTED_MODULE_6__/* .existsAsync */ .o)(dirPath))) {
+                await fs_promises__WEBPACK_IMPORTED_MODULE_0___default().mkdir(dirPath, { recursive: true });
+            }
+        }
+        if (modifiedData !== undefined) {
+            await fs_promises__WEBPACK_IMPORTED_MODULE_0___default().writeFile(filePath, modifiedData);
+            return;
+        }
+        const readStream = await new Promise(resolve => zipFile.openReadStream(entry, async (error, readStream) => {
+            if (error) {
+                dDone.reject(error);
+                return;
+            }
+            resolve(readStream);
+        }));
+        const dDoneWithFile = new evt_tools_Deferred__WEBPACK_IMPORTED_MODULE_4__.Deferred();
+        stream__WEBPACK_IMPORTED_MODULE_3___default().pipeline(readStream, fs__WEBPACK_IMPORTED_MODULE_1___default().createWriteStream(filePath), error => {
+            if (error) {
+                dDone.reject(error);
+                return;
+            }
+            dDoneWithFile.resolve();
+        });
+        await dDoneWithFile.pr;
+    };
+    const readFile = (entry) => new Promise(resolve => zipFile.openReadStream(entry, async (error, readStream) => {
+        if (error) {
+            dDone.reject(error);
+            return;
+        }
+        const chunks = [];
+        readStream.on("data", chunk => {
+            chunks.push(chunk);
+        });
+        readStream.on("end", () => {
+            resolve(Buffer.concat(chunks));
+        });
+        readStream.on("error", error => {
+            dDone.reject(error);
+        });
+    }));
+    zipFile.on("entry", async (entry) => {
+        handle_file: {
+            // NOTE: Skip directories
+            if (entry.fileName.endsWith("/")) {
+                break handle_file;
+            }
+            let hasEarlyExitBeenCalled = false;
+            await onArchiveFile({
+                relativeFilePathInArchive: entry.fileName.split("/").join(path__WEBPACK_IMPORTED_MODULE_5__.sep),
+                readFile: () => readFile(entry),
+                writeFile: params => writeFile(entry, params),
+                earlyExit: () => {
+                    hasEarlyExitBeenCalled = true;
+                }
+            });
+            if (hasEarlyExitBeenCalled) {
+                zipFile.close();
+                dDone.resolve();
+                return;
+            }
+        }
+        zipFile.readEntry();
+    });
+    zipFile.readEntry();
+    await dDone.pr;
+}
+//# sourceMappingURL=extractArchive.js.map
+
+/***/ }),
+
+/***/ 43765:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "o": () => (/* binding */ existsAsync)
+/* harmony export */ });
+/* harmony import */ var fs_promises__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(73292);
+/* harmony import */ var fs_promises__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(fs_promises__WEBPACK_IMPORTED_MODULE_0__);
+
+async function existsAsync(path) {
+    try {
+        await fs_promises__WEBPACK_IMPORTED_MODULE_0__.stat(path);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+//# sourceMappingURL=fs.existsAsync.js.map
+
+/***/ }),
+
+/***/ 8699:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "rm": () => (/* binding */ rm)
+/* harmony export */ });
+/* harmony import */ var fs_promises__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(73292);
+/* harmony import */ var fs_promises__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(fs_promises__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(71017);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _SemVer__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(12171);
+
+
+
+/**
+ * Polyfill of fs.rm(dirPath, { "recursive": true })
+ * For older version of Node
+ */
+async function rm(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) {
+        return fs_promises__WEBPACK_IMPORTED_MODULE_0__.rm(dirPath, options);
+    }
+    const { force = true } = options;
+    if (force && !(await checkDirExists(dirPath))) {
+        return;
+    }
+    const removeDir_rec = async (dirPath) => Promise.all((await fs_promises__WEBPACK_IMPORTED_MODULE_0__.readdir(dirPath)).map(async (basename) => {
+        const fileOrDirpath = (0,path__WEBPACK_IMPORTED_MODULE_1__.join)(dirPath, basename);
+        if ((await fs_promises__WEBPACK_IMPORTED_MODULE_0__.lstat(fileOrDirpath)).isDirectory()) {
+            await removeDir_rec(fileOrDirpath);
+        }
+        else {
+            await fs_promises__WEBPACK_IMPORTED_MODULE_0__.unlink(fileOrDirpath);
+        }
+    }));
+    await removeDir_rec(dirPath);
+}
+async function checkDirExists(dirPath) {
+    try {
+        await fs_promises__WEBPACK_IMPORTED_MODULE_0__.access(dirPath, fs_promises__WEBPACK_IMPORTED_MODULE_0__.constants.F_OK);
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+//# 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
+
+/***/ })
+
+};
+;