keycloakify 11.6.1 → 11.7.0

package/bin/9.index.js

@@ -0,0 +1,850 @@
+"use strict";
+exports.id = 9;
+exports.ids = [9];
+exports.modules = {
+
+/***/ 28434:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "z": () => (/* binding */ getSupportedDockerImageTags)
+/* 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 tsafe_assert__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(29041);
+/* harmony import */ var tsafe_id__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(38469);
+/* harmony import */ var zod__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(52300);
+/* harmony import */ var _tools_SemVer__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(12171);
+/* harmony import */ var tsafe_exclude__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(83101);
+/* harmony import */ var _realmConfig_defaultConfig__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(88984);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(71017);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_4__);
+/* harmony import */ var fs_promises__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(73292);
+/* harmony import */ var fs_promises__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(fs_promises__WEBPACK_IMPORTED_MODULE_5__);
+/* harmony import */ var _tools_fs_existsAsync__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(43765);
+/* harmony import */ var _tools_readThisNpmPackageVersion__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(64795);
+
+
+
+
+
+
+
+
+
+
+
+tsafe_assert__WEBPACK_IMPORTED_MODULE_1__/* .assert */ .h;
+async function getSupportedDockerImageTags(params) {
+    const { buildContext } = params;
+    {
+        const result = await getCachedValue({ cacheDirPath: buildContext.cacheDirPath });
+        if (result !== undefined) {
+            return result;
+        }
+    }
+    const tags_queryResponse = [];
+    await (async function callee(url) {
+        const r = await make_fetch_happen__WEBPACK_IMPORTED_MODULE_0___default()(url, buildContext.fetchOptions);
+        await Promise.all([
+            (async () => {
+                tags_queryResponse.push(...zod__WEBPACK_IMPORTED_MODULE_8__.z.object({
+                    tags: zod__WEBPACK_IMPORTED_MODULE_8__.z.array(zod__WEBPACK_IMPORTED_MODULE_8__.z.string())
+                })
+                    .parse(await r.json()).tags);
+            })(),
+            (async () => {
+                const link = r.headers.get("link");
+                if (link === null) {
+                    return;
+                }
+                const split = link.split(";").map(s => s.trim());
+                (0,tsafe_assert__WEBPACK_IMPORTED_MODULE_1__/* .assert */ .h)(split.length === 2);
+                (0,tsafe_assert__WEBPACK_IMPORTED_MODULE_1__/* .assert */ .h)(split[1] === 'rel="next"');
+                const match = split[0].match(/^<(.+)>$/);
+                (0,tsafe_assert__WEBPACK_IMPORTED_MODULE_1__/* .assert */ .h)(match !== null);
+                const nextUrl = new URL(url).origin + match[1];
+                await callee(nextUrl);
+            })()
+        ]);
+    })("https://quay.io/v2/keycloak/keycloak/tags/list");
+    const supportedKeycloakMajorVersions = (0,_realmConfig_defaultConfig__WEBPACK_IMPORTED_MODULE_3__/* .getSupportedKeycloakMajorVersions */ .Z)();
+    const allSupportedTags_withVersion = tags_queryResponse
+        .map(tag => ({
+        tag,
+        version: (() => {
+            if (tag.includes("-")) {
+                return undefined;
+            }
+            let version;
+            try {
+                version = _tools_SemVer__WEBPACK_IMPORTED_MODULE_2__/* .SemVer.parse */ .h.parse(tag);
+            }
+            catch (_a) {
+                return undefined;
+            }
+            if (tag.split(".").length !== 3) {
+                return undefined;
+            }
+            if (!supportedKeycloakMajorVersions.includes(version.major)) {
+                return undefined;
+            }
+            return version;
+        })()
+    }))
+        .map(({ tag, version }) => (version === undefined ? undefined : { tag, version }))
+        .filter((0,tsafe_exclude__WEBPACK_IMPORTED_MODULE_9__/* .exclude */ .D)(undefined))
+        .sort(({ version: a }, { version: b }) => _tools_SemVer__WEBPACK_IMPORTED_MODULE_2__/* .SemVer.compare */ .h.compare(b, a));
+    const latestTagByMajor = {};
+    for (const { version } of allSupportedTags_withVersion) {
+        const version_current = latestTagByMajor[version.major];
+        if (version_current === undefined ||
+            _tools_SemVer__WEBPACK_IMPORTED_MODULE_2__/* .SemVer.compare */ .h.compare(version_current, version) === -1) {
+            latestTagByMajor[version.major] = version;
+        }
+    }
+    const latestMajorTags = Object.entries(latestTagByMajor)
+        .sort(([a], [b]) => parseInt(b) - parseInt(a))
+        .map(([, version]) => version)
+        .map(version => {
+        (0,tsafe_assert__WEBPACK_IMPORTED_MODULE_1__/* .assert */ .h)(version !== undefined);
+        if (!supportedKeycloakMajorVersions.includes(version.major)) {
+            return undefined;
+        }
+        return _tools_SemVer__WEBPACK_IMPORTED_MODULE_2__/* .SemVer.stringify */ .h.stringify(version);
+    })
+        .filter((0,tsafe_exclude__WEBPACK_IMPORTED_MODULE_9__/* .exclude */ .D)(undefined));
+    const allSupportedTags = allSupportedTags_withVersion.map(({ tag }) => tag);
+    const result = {
+        latestMajorTags,
+        allSupportedTags
+    };
+    await setCachedValue({ cacheDirPath: buildContext.cacheDirPath, result });
+    return result;
+}
+const { getCachedValue, setCachedValue } = (() => {
+    const zResult = (() => {
+        const zTargetType = zod__WEBPACK_IMPORTED_MODULE_8__.z.object({
+            allSupportedTags: zod__WEBPACK_IMPORTED_MODULE_8__.z.array(zod__WEBPACK_IMPORTED_MODULE_8__.z.string()),
+            latestMajorTags: zod__WEBPACK_IMPORTED_MODULE_8__.z.array(zod__WEBPACK_IMPORTED_MODULE_8__.z.string())
+        });
+        tsafe_assert__WEBPACK_IMPORTED_MODULE_1__/* .assert */ .h;
+        return (0,tsafe_id__WEBPACK_IMPORTED_MODULE_10__.id)(zTargetType);
+    })();
+    const zCache = (() => {
+        const zTargetType = zod__WEBPACK_IMPORTED_MODULE_8__.z.object({
+            keycloakifyVersion: zod__WEBPACK_IMPORTED_MODULE_8__.z.string(),
+            time: zod__WEBPACK_IMPORTED_MODULE_8__.z.number(),
+            result: zResult
+        });
+        tsafe_assert__WEBPACK_IMPORTED_MODULE_1__/* .assert */ .h;
+        return (0,tsafe_id__WEBPACK_IMPORTED_MODULE_10__.id)(zTargetType);
+    })();
+    let inMemoryCachedResult = undefined;
+    function getCacheFilePath(params) {
+        const { cacheDirPath } = params;
+        return (0,path__WEBPACK_IMPORTED_MODULE_4__.join)(cacheDirPath, "supportedDockerImageTags.json");
+    }
+    async function getCachedValue(params) {
+        const { cacheDirPath } = params;
+        if (inMemoryCachedResult !== undefined) {
+            return inMemoryCachedResult;
+        }
+        const cacheFilePath = getCacheFilePath({ cacheDirPath });
+        if (!(await (0,_tools_fs_existsAsync__WEBPACK_IMPORTED_MODULE_6__/* .existsAsync */ .o)(cacheFilePath))) {
+            return undefined;
+        }
+        let cache;
+        try {
+            cache = zCache.parse(JSON.parse(await fs_promises__WEBPACK_IMPORTED_MODULE_5__.readFile(cacheFilePath, "utf8")));
+        }
+        catch (_a) {
+            return undefined;
+        }
+        if (cache.keycloakifyVersion !== (0,_tools_readThisNpmPackageVersion__WEBPACK_IMPORTED_MODULE_7__/* .readThisNpmPackageVersion */ .K)()) {
+            return undefined;
+        }
+        if (Date.now() - cache.time > 3600 * 24) {
+            return undefined;
+        }
+        inMemoryCachedResult = cache.result;
+        return cache.result;
+    }
+    async function setCachedValue(params) {
+        const { cacheDirPath, result } = params;
+        inMemoryCachedResult = result;
+        const cacheFilePath = getCacheFilePath({ cacheDirPath });
+        {
+            const dirPath = (0,path__WEBPACK_IMPORTED_MODULE_4__.dirname)(cacheFilePath);
+            if (!(await (0,_tools_fs_existsAsync__WEBPACK_IMPORTED_MODULE_6__/* .existsAsync */ .o)(dirPath))) {
+                await fs_promises__WEBPACK_IMPORTED_MODULE_5__.mkdir(dirPath, { recursive: true });
+            }
+        }
+        await fs_promises__WEBPACK_IMPORTED_MODULE_5__.writeFile(cacheFilePath, JSON.stringify(zCache.parse({
+            keycloakifyVersion: (0,_tools_readThisNpmPackageVersion__WEBPACK_IMPORTED_MODULE_7__/* .readThisNpmPackageVersion */ .K)(),
+            time: Date.now(),
+            result
+        }), null, 2));
+    }
+    return {
+        getCachedValue,
+        setCachedValue
+    };
+})();
+//# sourceMappingURL=getSupportedDockerImageTags.js.map
+
+/***/ }),
+
+/***/ 96709:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "X": () => (/* binding */ readRealmJsonFile)
+});
+
+// EXTERNAL MODULE: ./node_modules/tsafe/esm/assert.mjs + 1 modules
+var assert = __webpack_require__(29041);
+// EXTERNAL MODULE: ./node_modules/tsafe/esm/is.mjs
+var is = __webpack_require__(16453);
+// 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/esm/id.mjs
+var id = __webpack_require__(38469);
+;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/ParsedRealmJson/ParsedRealmJson.js
+
+
+
+const zParsedRealmJson = (() => {
+    const zTargetType = lib.z.object({
+        realm: lib.z.string(),
+        loginTheme: lib.z.string().optional(),
+        accountTheme: lib.z.string().optional(),
+        adminTheme: lib.z.string().optional(),
+        emailTheme: lib.z.string().optional(),
+        eventsListeners: lib.z.array(lib.z.string()),
+        users: lib.z.array(lib.z.object({
+            id: lib.z.string(),
+            email: lib.z.string(),
+            username: lib.z.string(),
+            credentials: lib.z.array(lib.z.object({
+                type: lib.z.string()
+            })),
+            clientRoles: lib.z.record(lib.z.array(lib.z.string())).optional()
+        })),
+        roles: lib.z.object({
+            client: lib.z.record(lib.z.array(lib.z.object({
+                name: lib.z.string(),
+                containerId: lib.z.string()
+            })))
+        }),
+        clients: lib.z.array(lib.z.object({
+            id: lib.z.string(),
+            clientId: lib.z.string(),
+            baseUrl: lib.z.string().optional(),
+            redirectUris: lib.z.array(lib.z.string()).optional(),
+            webOrigins: lib.z.array(lib.z.string()).optional(),
+            attributes: lib.z.object({
+                "post.logout.redirect.uris": lib.z.string().optional()
+            })
+                .optional(),
+            protocol: lib.z.string().optional(),
+            protocolMappers: lib.z.array(lib.z.object({
+                id: lib.z.string(),
+                name: lib.z.string(),
+                protocol: lib.z.string(),
+                protocolMapper: lib.z.string(),
+                consentRequired: lib.z.boolean(),
+                config: lib.z.record(lib.z.string()).optional()
+            }))
+                .optional()
+        }))
+    });
+    assert/* assert */.h;
+    return (0,id.id)(zTargetType);
+})();
+//# sourceMappingURL=ParsedRealmJson.js.map
+;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/ParsedRealmJson/readRealmJsonFile.js
+
+
+
+
+function readRealmJsonFile(params) {
+    const { realmJsonFilePath } = params;
+    const parsedRealmJson = JSON.parse(external_fs_.readFileSync(realmJsonFilePath).toString("utf8"));
+    zParsedRealmJson.parse(parsedRealmJson);
+    (0,assert/* assert */.h)((0,is.is)(parsedRealmJson));
+    return parsedRealmJson;
+}
+//# sourceMappingURL=readRealmJsonFile.js.map
+
+/***/ }),
+
+/***/ 88984:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "_": () => (/* reexport */ getDefaultConfig),
+  "Z": () => (/* reexport */ getSupportedKeycloakMajorVersions)
+});
+
+// EXTERNAL MODULE: external "path"
+var external_path_ = __webpack_require__(71017);
+// EXTERNAL MODULE: ./dist/bin/tools/getThisCodebaseRootDirPath.js
+var getThisCodebaseRootDirPath = __webpack_require__(58822);
+// EXTERNAL MODULE: external "fs"
+var external_fs_ = __webpack_require__(57147);
+// EXTERNAL MODULE: ./node_modules/tsafe/esm/exclude.mjs
+var exclude = __webpack_require__(83101);
+// EXTERNAL MODULE: ./node_modules/tsafe/esm/assert.mjs + 1 modules
+var assert = __webpack_require__(29041);
+// EXTERNAL MODULE: ./dist/bin/start-keycloak/realmConfig/ParsedRealmJson/readRealmJsonFile.js + 1 modules
+var readRealmJsonFile = __webpack_require__(96709);
+;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/defaultConfig/defaultConfig.js
+
+
+
+
+
+
+function getDefaultRealmJsonFilePath(params) {
+    const { keycloakMajorVersionNumber } = params;
+    return (0,external_path_.join)((0,getThisCodebaseRootDirPath/* getThisCodebaseRootDirPath */.e)(), "src", "bin", "start-keycloak", "realmConfig", "defaultConfig", `realm-kc-${keycloakMajorVersionNumber}.json`);
+}
+const { getSupportedKeycloakMajorVersions } = (() => {
+    let cache = undefined;
+    function getSupportedKeycloakMajorVersions() {
+        if (cache !== undefined) {
+            return cache;
+        }
+        cache = external_fs_.readdirSync((0,external_path_.dirname)(getDefaultRealmJsonFilePath({ keycloakMajorVersionNumber: 0 })))
+            .map(fileBasename => {
+            const match = fileBasename.match(/^realm-kc-(\d+)\.json$/);
+            if (match === null) {
+                return undefined;
+            }
+            const n = parseInt(match[1]);
+            (0,assert/* assert */.h)(!isNaN(n));
+            return n;
+        })
+            .filter((0,exclude/* exclude */.D)(undefined))
+            .sort((a, b) => b - a);
+        return cache;
+    }
+    return { getSupportedKeycloakMajorVersions };
+})();
+function getDefaultConfig(params) {
+    const { keycloakMajorVersionNumber } = params;
+    (0,assert/* assert */.h)(getSupportedKeycloakMajorVersions().includes(keycloakMajorVersionNumber), `We do not have a default config for Keycloak ${keycloakMajorVersionNumber}`);
+    return (0,readRealmJsonFile/* readRealmJsonFile */.X)({
+        realmJsonFilePath: getDefaultRealmJsonFilePath({
+            keycloakMajorVersionNumber
+        })
+    });
+}
+//# sourceMappingURL=defaultConfig.js.map
+;// CONCATENATED MODULE: ./dist/bin/start-keycloak/realmConfig/defaultConfig/index.js
+
+//# sourceMappingURL=index.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
+
+/***/ }),
+
+/***/ 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__(29041);
+/* 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 */ .h)(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__) => {
+
+/* 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
+
+/***/ }),
+
+/***/ 73776:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "K": () => (/* binding */ getNodeModulesBinDirPath)
+/* 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__);
+
+let cache = undefined;
+function getNodeModulesBinDirPath() {
+    if (cache !== undefined) {
+        return cache;
+    }
+    const binPath = process.argv[1];
+    const segments = [".bin"];
+    let foundNodeModules = false;
+    for (const segment of binPath.split(path__WEBPACK_IMPORTED_MODULE_0__.sep).reverse()) {
+        skip_segment: {
+            if (foundNodeModules) {
+                break skip_segment;
+            }
+            if (segment === "node_modules") {
+                foundNodeModules = true;
+                break skip_segment;
+            }
+            continue;
+        }
+        segments.unshift(segment);
+    }
+    const nodeModulesBinDirPath = segments.join(path__WEBPACK_IMPORTED_MODULE_0__.sep);
+    cache = nodeModulesBinDirPath;
+    return nodeModulesBinDirPath;
+}
+//# sourceMappingURL=nodeModulesBinDirPath.js.map
+
+/***/ })
+
+};
+;