keycloakify 10.0.0-rc.14 → 10.0.0-rc.140

package/bin/526.index.js

@@ -0,0 +1,1345 @@
+"use strict";
+exports.id = 526;
+exports.ids = [526];
+exports.modules = {
+
+/***/ 97189:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "_": () => (/* binding */ getLatestsSemVersionedTag)
+});
+
+;// CONCATENATED MODULE: ./dist/bin/tools/octokit-addons/listTags.js
+var __await = (undefined && undefined.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (undefined && undefined.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+const per_page = 99;
+function listTagsFactory(params) {
+    const { octokit } = params;
+    const octokit_repo_listTags = async (params) => {
+        return octokit.repos.listTags(params);
+    };
+    function listTags(params) {
+        return __asyncGenerator(this, arguments, function* listTags_1() {
+            const { owner, repo } = params;
+            let page = 1;
+            while (true) {
+                const resp = yield __await(octokit_repo_listTags({
+                    owner,
+                    repo,
+                    per_page,
+                    page: page++
+                }));
+                for (const branch of resp.data.map(({ name }) => name)) {
+                    yield yield __await(branch);
+                }
+                if (resp.data.length < 99) {
+                    break;
+                }
+            }
+        });
+    }
+    /** Returns the same "latest" tag as deno.land/x, not actually the latest though */
+    async function getLatestTag(params) {
+        const { owner, repo } = params;
+        const itRes = await listTags({ owner, repo }).next();
+        if (itRes.done) {
+            return undefined;
+        }
+        return itRes.value;
+    }
+    return { listTags, getLatestTag };
+}
+//# sourceMappingURL=listTags.js.map
+// EXTERNAL MODULE: ./dist/bin/tools/SemVer.js
+var SemVer = __webpack_require__(12171);
+;// CONCATENATED MODULE: ./dist/bin/tools/octokit-addons/getLatestsSemVersionedTag.js
+var __asyncValues = (undefined && undefined.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+
+
+function getLatestsSemVersionedTagFactory(params) {
+    const { octokit } = params;
+    async function getLatestsSemVersionedTag(params) {
+        var _a, e_1, _b, _c;
+        const { owner, repo, count, doIgnoreReleaseCandidates } = params;
+        const semVersionedTags = [];
+        const { listTags } = listTagsFactory({ octokit });
+        try {
+            for (var _d = true, _e = __asyncValues(listTags({ owner, repo })), _f; _f = await _e.next(), _a = _f.done, !_a;) {
+                _c = _f.value;
+                _d = false;
+                try {
+                    const tag = _c;
+                    let version;
+                    try {
+                        version = SemVer/* SemVer.parse */.h.parse(tag.replace(/^[vV]?/, ""));
+                    }
+                    catch (_g) {
+                        continue;
+                    }
+                    if (doIgnoreReleaseCandidates && version.rc !== undefined) {
+                        continue;
+                    }
+                    semVersionedTags.push({ tag, version });
+                }
+                finally {
+                    _d = true;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = _e.return)) await _b.call(_e);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return semVersionedTags
+            .sort(({ version: vX }, { version: vY }) => SemVer/* SemVer.compare */.h.compare(vY, vX))
+            .slice(0, count);
+    }
+    return { getLatestsSemVersionedTag };
+}
+//# sourceMappingURL=getLatestsSemVersionedTag.js.map
+// EXTERNAL MODULE: ./node_modules/@octokit/rest/dist-node/index.js
+var dist_node = __webpack_require__(55375);
+// EXTERNAL MODULE: external "path"
+var external_path_ = __webpack_require__(71017);
+// EXTERNAL MODULE: external "fs"
+var external_fs_ = __webpack_require__(57147);
+// EXTERNAL MODULE: ./node_modules/zod/lib/index.mjs
+var lib = __webpack_require__(52300);
+// EXTERNAL MODULE: ./node_modules/tsafe/assert.js
+var assert = __webpack_require__(88078);
+// EXTERNAL MODULE: ./node_modules/tsafe/id.js
+var id = __webpack_require__(43047);
+// EXTERNAL MODULE: ./node_modules/evt/tools/inDepth/same.js
+var same = __webpack_require__(33805);
+// EXTERNAL MODULE: ./node_modules/make-fetch-happen/lib/index.js
+var make_fetch_happen_lib = __webpack_require__(9525);
+var lib_default = /*#__PURE__*/__webpack_require__.n(make_fetch_happen_lib);
+;// CONCATENATED MODULE: ./dist/bin/shared/getLatestsSemVersionedTag.js
+var __rest = (undefined && undefined.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+
+
+
+
+
+
+
+
+
+let getLatestsSemVersionedTag_stateless = undefined;
+const CACHE_VERSION = 1;
+(0,assert.assert)();
+async function getLatestsSemVersionedTag(_a) {
+    var { buildContext } = _a, params = __rest(_a, ["buildContext"]);
+    const cacheFilePath = (0,external_path_.join)(buildContext.cacheDirPath, "latest-sem-versioned-tags.json");
+    const cacheLookupResult = (() => {
+        const getResult_currentCache = (currentCacheEntries) => ({
+            hasCachedResult: false,
+            currentCache: {
+                version: CACHE_VERSION,
+                entries: currentCacheEntries
+            }
+        });
+        if (!external_fs_.existsSync(cacheFilePath)) {
+            return getResult_currentCache([]);
+        }
+        let cache_json;
+        try {
+            cache_json = external_fs_.readFileSync(cacheFilePath).toString("utf8");
+        }
+        catch (_a) {
+            return getResult_currentCache([]);
+        }
+        let cache_json_parsed;
+        try {
+            cache_json_parsed = JSON.parse(cache_json);
+        }
+        catch (_b) {
+            return getResult_currentCache([]);
+        }
+        const zSemVer = (() => {
+            const zTargetType = lib.z.object({
+                major: lib.z.number(),
+                minor: lib.z.number(),
+                patch: lib.z.number(),
+                rc: lib.z.number().optional(),
+                parsedFrom: lib.z.string()
+            });
+            (0,assert.assert)();
+            return (0,id.id)(zTargetType);
+        })();
+        const zCache = (() => {
+            const zTargetType = lib.z.object({
+                version: lib.z.literal(CACHE_VERSION),
+                entries: lib.z.array(lib.z.object({
+                    time: lib.z.number(),
+                    params: lib.z.object({
+                        owner: lib.z.string(),
+                        repo: lib.z.string(),
+                        count: lib.z.number(),
+                        doIgnoreReleaseCandidates: lib.z.boolean()
+                    }),
+                    result: lib.z.array(lib.z.object({
+                        tag: lib.z.string(),
+                        version: zSemVer
+                    }))
+                }))
+            });
+            (0,assert.assert)();
+            return (0,id.id)(zTargetType);
+        })();
+        let cache;
+        try {
+            cache = zCache.parse(cache_json_parsed);
+        }
+        catch (_c) {
+            return getResult_currentCache([]);
+        }
+        const cacheEntry = cache.entries.find(e => (0,same.same)(e.params, params));
+        if (cacheEntry === undefined) {
+            return getResult_currentCache(cache.entries);
+        }
+        if (Date.now() - cacheEntry.time > 3600000) {
+            return getResult_currentCache(cache.entries.filter(e => e !== cacheEntry));
+        }
+        return {
+            hasCachedResult: true,
+            cachedResult: cacheEntry.result
+        };
+    })();
+    if (cacheLookupResult.hasCachedResult) {
+        return cacheLookupResult.cachedResult;
+    }
+    const { currentCache } = cacheLookupResult;
+    getLatestsSemVersionedTag_stateless !== null && getLatestsSemVersionedTag_stateless !== void 0 ? getLatestsSemVersionedTag_stateless : (getLatestsSemVersionedTag_stateless = (() => {
+        const octokit = (() => {
+            const githubToken = process.env.GITHUB_TOKEN;
+            const octokit = new dist_node.Octokit(Object.assign(Object.assign({}, (githubToken === undefined ? {} : { auth: githubToken })), { request: {
+                    fetch: (url, options) => lib_default()(url, Object.assign(Object.assign({}, options), buildContext.fetchOptions))
+                } }));
+            return octokit;
+        })();
+        const { getLatestsSemVersionedTag } = getLatestsSemVersionedTagFactory({
+            octokit
+        });
+        return getLatestsSemVersionedTag;
+    })());
+    const result = await getLatestsSemVersionedTag_stateless(params);
+    currentCache.entries.push({
+        time: Date.now(),
+        params,
+        result
+    });
+    {
+        const dirPath = (0,external_path_.dirname)(cacheFilePath);
+        if (!external_fs_.existsSync(dirPath)) {
+            external_fs_.mkdirSync(dirPath, { recursive: true });
+        }
+    }
+    external_fs_.writeFileSync(cacheFilePath, JSON.stringify(currentCache, null, 2));
+    return result;
+}
+//# sourceMappingURL=getLatestsSemVersionedTag.js.map
+
+/***/ }),
+
+/***/ 82635:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "s": () => (/* binding */ promptKeycloakVersion)
+/* harmony export */ });
+/* harmony import */ var _getLatestsSemVersionedTag__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(97189);
+/* harmony import */ var cli_select__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(99398);
+/* harmony import */ var cli_select__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(cli_select__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var tsafe_assert__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(88078);
+/* harmony import */ var tsafe_assert__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(tsafe_assert__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _tools_SemVer__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(12171);
+
+
+
+
+(0,tsafe_assert__WEBPACK_IMPORTED_MODULE_2__.assert)();
+async function promptKeycloakVersion(params) {
+    const { startingFromMajor, excludeMajorVersions, buildContext } = params;
+    const semVersionedTagByMajor = new Map();
+    const semVersionedTags = await (0,_getLatestsSemVersionedTag__WEBPACK_IMPORTED_MODULE_0__/* .getLatestsSemVersionedTag */ ._)({
+        count: 50,
+        owner: "keycloak",
+        repo: "keycloak",
+        doIgnoreReleaseCandidates: true,
+        buildContext
+    });
+    semVersionedTags.forEach(semVersionedTag => {
+        if (startingFromMajor !== undefined &&
+            semVersionedTag.version.major < startingFromMajor) {
+            return;
+        }
+        if (excludeMajorVersions.includes(semVersionedTag.version.major)) {
+            return;
+        }
+        const currentSemVersionedTag = semVersionedTagByMajor.get(semVersionedTag.version.major);
+        if (currentSemVersionedTag !== undefined &&
+            _tools_SemVer__WEBPACK_IMPORTED_MODULE_3__/* .SemVer.compare */ .h.compare(semVersionedTag.version, currentSemVersionedTag.version) === -1) {
+            return;
+        }
+        semVersionedTagByMajor.set(semVersionedTag.version.major, semVersionedTag);
+    });
+    const lastMajorVersions = Array.from(semVersionedTagByMajor.values()).map(({ tag }) => tag);
+    const { value } = await cli_select__WEBPACK_IMPORTED_MODULE_1___default()({
+        values: lastMajorVersions
+    }).catch(() => {
+        process.exit(-1);
+    });
+    const keycloakVersion = value.split(" ")[0];
+    return { keycloakVersion };
+}
+//# sourceMappingURL=promptKeycloakVersion.js.map
+
+/***/ }),
+
+/***/ 80526:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "command": () => (/* reexport */ command)
+});
+
+// EXTERNAL MODULE: ./dist/bin/shared/buildContext.js + 1 modules
+var shared_buildContext = __webpack_require__(56031);
+// EXTERNAL MODULE: ./node_modules/tsafe/exclude.js
+var exclude = __webpack_require__(41370);
+// EXTERNAL MODULE: ./dist/bin/shared/promptKeycloakVersion.js
+var promptKeycloakVersion = __webpack_require__(82635);
+// EXTERNAL MODULE: ./dist/bin/shared/constants.js
+var constants = __webpack_require__(173);
+// EXTERNAL MODULE: ./dist/bin/tools/SemVer.js
+var SemVer = __webpack_require__(12171);
+// EXTERNAL MODULE: ./node_modules/tsafe/assert.js
+var assert = __webpack_require__(88078);
+// EXTERNAL MODULE: external "fs"
+var external_fs_ = __webpack_require__(57147);
+// EXTERNAL MODULE: external "path"
+var external_path_ = __webpack_require__(71017);
+// EXTERNAL MODULE: external "child_process"
+var external_child_process_ = __webpack_require__(32081);
+// EXTERNAL MODULE: ./node_modules/chalk/source/index.js
+var source = __webpack_require__(78818);
+var source_default = /*#__PURE__*/__webpack_require__.n(source);
+// EXTERNAL MODULE: ./node_modules/chokidar/index.js
+var chokidar = __webpack_require__(42677);
+// EXTERNAL MODULE: ./node_modules/powerhooks/tools/waitForDebounce.js
+var tools_waitForDebounce = __webpack_require__(18721);
+// EXTERNAL MODULE: ./dist/bin/tools/getThisCodebaseRootDirPath.js
+var getThisCodebaseRootDirPath = __webpack_require__(58822);
+// EXTERNAL MODULE: ./dist/bin/tools/getAbsoluteAndInOsFormatPath.js
+var getAbsoluteAndInOsFormatPath = __webpack_require__(86644);
+// EXTERNAL MODULE: ./node_modules/cli-select/dist/index.js
+var dist = __webpack_require__(99398);
+var dist_default = /*#__PURE__*/__webpack_require__.n(dist);
+// EXTERNAL MODULE: ./node_modules/run-exclusive/lib/runExclusive.js
+var runExclusive = __webpack_require__(81708);
+// EXTERNAL MODULE: ./dist/bin/tools/extractArchive.js
+var extractArchive = __webpack_require__(29121);
+// EXTERNAL MODULE: ./node_modules/evt/tools/Deferred.js
+var Deferred = __webpack_require__(50689);
+;// CONCATENATED MODULE: ./dist/bin/start-keycloak/appBuild.js
+
+
+
+
+
+
+
+
+(0,assert.assert)();
+async function appBuild(params) {
+    const { buildContext } = params;
+    switch (buildContext.bundler) {
+        case "vite":
+            return appBuild_vite({ buildContext });
+        case "webpack":
+            return appBuild_webpack({ buildContext });
+    }
+}
+async function appBuild_vite(params) {
+    const { buildContext } = params;
+    (0,assert.assert)(buildContext.bundler === "vite");
+    const dIsSuccess = new Deferred.Deferred();
+    console.log(source_default().blue("$ npx vite build"));
+    const child = external_child_process_.spawn("npx", ["vite", "build"], {
+        cwd: buildContext.projectDirPath,
+        shell: true
+    });
+    child.stdout.on("data", data => {
+        if (data.toString("utf8").includes("gzip:")) {
+            return;
+        }
+        process.stdout.write(data);
+    });
+    child.stderr.on("data", data => process.stderr.write(data));
+    child.on("exit", code => dIsSuccess.resolve(code === 0));
+    const isSuccess = await dIsSuccess.pr;
+    return { isAppBuildSuccess: isSuccess };
+}
+async function appBuild_webpack(params) {
+    var _a;
+    const { buildContext } = params;
+    (0,assert.assert)(buildContext.bundler === "webpack");
+    const entries = Object.entries(((_a = JSON.parse(external_fs_.readFileSync(buildContext.packageJsonFilePath).toString("utf8"))
+        .scripts) !== null && _a !== void 0 ? _a : {})).filter(([, scriptCommand]) => scriptCommand.includes("keycloakify build"));
+    if (entries.length === 0) {
+        console.log(source_default().red([
+            `You should have a script in your package.json at ${(0,external_path_.relative)(process.cwd(), (0,external_path_.dirname)(buildContext.packageJsonFilePath))}`,
+            `that includes the 'keycloakify build' command`
+        ].join(" ")));
+        process.exit(-1);
+    }
+    const entry = entries.length === 1
+        ? entries[0]
+        : entries.find(([scriptName]) => scriptName === "build-keycloak-theme");
+    if (entry === undefined) {
+        console.log(source_default().red("There's multiple candidate script for building your app, name one 'build-keycloak-theme'"));
+        process.exit(-1);
+    }
+    const [scriptName, scriptCommand] = entry;
+    const { appBuildSubCommands } = (() => {
+        const appBuildSubCommands = [];
+        for (const subCmd of scriptCommand.split("&&").map(s => s.trim())) {
+            if (subCmd.includes("keycloakify build")) {
+                break;
+            }
+            appBuildSubCommands.push(subCmd);
+        }
+        return { appBuildSubCommands };
+    })();
+    if (appBuildSubCommands.length === 0) {
+        console.log(source_default().red(`Your ${scriptName} script should look like "... && keycloakify build ..."`));
+        process.exit(-1);
+    }
+    let commandCwd = (0,external_path_.dirname)(buildContext.packageJsonFilePath);
+    for (const subCommand of appBuildSubCommands) {
+        const dIsSuccess = new Deferred.Deferred();
+        const [command, ...args] = subCommand.split(" ");
+        if (command === "cd") {
+            const [pathIsh] = args;
+            commandCwd = (0,getAbsoluteAndInOsFormatPath/* getAbsoluteAndInOsFormatPath */.c)({
+                pathIsh,
+                cwd: commandCwd
+            });
+            continue;
+        }
+        console.log(source_default().blue(`$ ${subCommand}`));
+        const child = external_child_process_.spawn(command, args, {
+            cwd: commandCwd,
+            env: Object.assign(Object.assign({}, process.env), { PATH: (() => {
+                    var _a;
+                    const separator = external_path_.sep === "/" ? ":" : ";";
+                    return [
+                        (0,external_path_.join)((0,external_path_.dirname)(buildContext.packageJsonFilePath), "node_modules", ".bin"),
+                        ...((_a = process.env.PATH) !== null && _a !== void 0 ? _a : "").split(separator)
+                    ].join(separator);
+                })() }),
+            shell: true
+        });
+        child.stdout.on("data", data => process.stdout.write(data));
+        child.stderr.on("data", data => process.stderr.write(data));
+        child.on("exit", code => dIsSuccess.resolve(code === 0));
+        const isSuccess = await dIsSuccess.pr;
+        if (!isSuccess) {
+            return { isAppBuildSuccess: false };
+        }
+    }
+    return { isAppBuildSuccess: true };
+}
+//# sourceMappingURL=appBuild.js.map
+;// CONCATENATED MODULE: ./dist/bin/start-keycloak/keycloakifyBuild.js
+
+
+
+
+
+(0,assert.assert)();
+async function keycloakifyBuild(params) {
+    const { buildForKeycloakMajorVersionNumber, buildContext } = params;
+    const dResult = new Deferred.Deferred();
+    console.log(source_default().blue("$ npx keycloakify build"));
+    const child = external_child_process_.spawn("npx", ["keycloakify", "build"], {
+        cwd: buildContext.projectDirPath,
+        env: Object.assign(Object.assign({}, process.env), { [constants/* BUILD_FOR_KEYCLOAK_MAJOR_VERSION_ENV_NAME */.ac]: `${buildForKeycloakMajorVersionNumber}` }),
+        shell: true
+    });
+    child.stdout.on("data", data => process.stdout.write(data));
+    child.stderr.on("data", data => process.stderr.write(data));
+    child.on("exit", code => dResult.resolve({ isSuccess: code === 0 }));
+    const { isSuccess } = await dResult.pr;
+    return { isKeycloakifyBuildSuccess: isSuccess };
+}
+//# sourceMappingURL=keycloakifyBuild.js.map
+// EXTERNAL MODULE: ./dist/bin/tools/isInside.js
+var isInside = __webpack_require__(90665);
+// EXTERNAL MODULE: ./dist/bin/tools/fs.existsAsync.js
+var fs_existsAsync = __webpack_require__(43765);
+// EXTERNAL MODULE: ./dist/bin/tools/fs.rm.js
+var fs_rm = __webpack_require__(8699);
+// EXTERNAL MODULE: ./dist/bin/tools/downloadAndExtractArchive.js
+var downloadAndExtractArchive = __webpack_require__(38367);
+;// CONCATENATED MODULE: ./dist/bin/start-keycloak/start-keycloak.js
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+async function command(params) {
+    var _a, _b, _c, _d;
+    exit_if_docker_not_installed: {
+        let commandOutput = undefined;
+        try {
+            commandOutput = external_child_process_.execSync("docker --version", {
+                stdio: ["ignore", "pipe", "ignore"]
+            });
+        }
+        catch (_e) { }
+        if (commandOutput === null || commandOutput === void 0 ? void 0 : commandOutput.toString("utf8").includes("Docker")) {
+            break exit_if_docker_not_installed;
+        }
+        console.log([
+            `${source_default().red("Docker required.")}`,
+            `Install it with Docker Desktop: ${source_default().bold.underline("https://www.docker.com/products/docker-desktop/")}`,
+            `(or any other way)`
+        ].join(" "));
+        process.exit(1);
+    }
+    exit_if_docker_not_running: {
+        let isDockerRunning;
+        try {
+            external_child_process_.execSync("docker info", { stdio: "ignore" });
+            isDockerRunning = true;
+        }
+        catch (_f) {
+            isDockerRunning = false;
+        }
+        if (isDockerRunning) {
+            break exit_if_docker_not_running;
+        }
+        console.log([
+            `${source_default().red("Docker daemon is not running.")}`,
+            `Please start Docker Desktop and try again.`
+        ].join(" "));
+        process.exit(1);
+    }
+    const { cliCommandOptions } = params;
+    const buildContext = (0,shared_buildContext/* getBuildContext */.s)({ cliCommandOptions });
+    const { dockerImageTag } = await (async () => {
+        if (cliCommandOptions.keycloakVersion !== undefined) {
+            return { dockerImageTag: cliCommandOptions.keycloakVersion };
+        }
+        if (buildContext.startKeycloakOptions.dockerImage !== undefined) {
+            return {
+                dockerImageTag: buildContext.startKeycloakOptions.dockerImage.tag
+            };
+        }
+        console.log([
+            source_default().cyan("On which version of Keycloak do you want to test your theme?"),
+            source_default().gray("You can also explicitly provide the version with `npx keycloakify start-keycloak --keycloak-version 25.0.2` (or any other version)")
+        ].join("\n"));
+        const { keycloakVersion } = await (0,promptKeycloakVersion/* promptKeycloakVersion */.s)({
+            startingFromMajor: 18,
+            excludeMajorVersions: [22],
+            buildContext
+        });
+        console.log(`→ ${keycloakVersion}`);
+        return { dockerImageTag: keycloakVersion };
+    })();
+    const keycloakMajorVersionNumber = (() => {
+        if (buildContext.startKeycloakOptions.dockerImage === undefined) {
+            return SemVer/* SemVer.parse */.h.parse(dockerImageTag).major;
+        }
+        const { tag } = buildContext.startKeycloakOptions.dockerImage;
+        const [wrap] = [18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28]
+            .map(majorVersionNumber => ({
+            majorVersionNumber,
+            index: tag.indexOf(`${majorVersionNumber}`)
+        }))
+            .filter(({ index }) => index !== -1)
+            .sort((a, b) => a.index - b.index);
+        if (wrap === undefined) {
+            console.warn(source_default().yellow(`Could not determine the major Keycloak version number from the docker image tag ${tag}. Assuming 25`));
+            return 25;
+        }
+        return wrap.majorVersionNumber;
+    })();
+    {
+        const { isAppBuildSuccess } = await appBuild({
+            buildContext
+        });
+        if (!isAppBuildSuccess) {
+            console.log(source_default().red(`App build failed, exiting. Try building your app (e.g 'npm run build') and see what's wrong.`));
+            process.exit(1);
+        }
+        const { isKeycloakifyBuildSuccess } = await keycloakifyBuild({
+            buildForKeycloakMajorVersionNumber: keycloakMajorVersionNumber,
+            buildContext
+        });
+        if (!isKeycloakifyBuildSuccess) {
+            console.log(source_default().red(`Keycloakify build failed, exiting. Try running 'npx keycloakify build' and see what's wrong.`));
+            process.exit(1);
+        }
+    }
+    const jarFilePath = external_fs_.readdirSync(buildContext.keycloakifyBuildDirPath)
+        .filter(fileBasename => fileBasename.endsWith(".jar"))
+        .map(fileBasename => (0,external_path_.join)(buildContext.keycloakifyBuildDirPath, fileBasename))
+        .sort((a, b) => external_fs_.statSync(b).mtimeMs - external_fs_.statSync(a).mtimeMs)[0];
+    (0,assert.assert)(jarFilePath !== undefined);
+    const extensionJarFilePaths = await Promise.all(buildContext.startKeycloakOptions.extensionJars.map(async (extensionJar) => {
+        switch (extensionJar.type) {
+            case "path": {
+                (0,assert.assert)(await (0,fs_existsAsync/* existsAsync */.o)(extensionJar.path), `${extensionJar.path} does not exist`);
+                return extensionJar.path;
+            }
+            case "url": {
+                const { archiveFilePath } = await (0,downloadAndExtractArchive/* downloadAndExtractArchive */.I)({
+                    cacheDirPath: buildContext.cacheDirPath,
+                    fetchOptions: buildContext.fetchOptions,
+                    urlOrPath: extensionJar.url,
+                    uniqueIdOfOnArchiveFile: "no extraction",
+                    onArchiveFile: async () => { }
+                });
+                return archiveFilePath;
+            }
+        }
+        (0,assert.assert)(false);
+    }));
+    const realmJsonFilePath = await (async () => {
+        if (cliCommandOptions.realmJsonFilePath !== undefined) {
+            if (cliCommandOptions.realmJsonFilePath === "none") {
+                return undefined;
+            }
+            return (0,getAbsoluteAndInOsFormatPath/* getAbsoluteAndInOsFormatPath */.c)({
+                pathIsh: cliCommandOptions.realmJsonFilePath,
+                cwd: process.cwd()
+            });
+        }
+        if (buildContext.startKeycloakOptions.realmJsonFilePath !== undefined) {
+            (0,assert.assert)(await (0,fs_existsAsync/* existsAsync */.o)(buildContext.startKeycloakOptions.realmJsonFilePath), `${(0,external_path_.relative)(process.cwd(), buildContext.startKeycloakOptions.realmJsonFilePath)} does not exist`);
+            return buildContext.startKeycloakOptions.realmJsonFilePath;
+        }
+        const internalFilePath = await (async () => {
+            const dirPath = (0,external_path_.join)((0,getThisCodebaseRootDirPath/* getThisCodebaseRootDirPath */.e)(), "src", "bin", "start-keycloak");
+            const filePath = (0,external_path_.join)(dirPath, `myrealm-realm-${keycloakMajorVersionNumber}.json`);
+            if (external_fs_.existsSync(filePath)) {
+                return filePath;
+            }
+            console.log(`${source_default().yellow(`Keycloakify do not have a realm configuration for Keycloak ${keycloakMajorVersionNumber} yet.`)}`);
+            console.log(source_default().cyan("Select what configuration to use:"));
+            const { value } = await dist_default()({
+                values: [
+                    ...external_fs_.readdirSync(dirPath)
+                        .filter(fileBasename => fileBasename.endsWith(".json")),
+                    "none"
+                ]
+            }).catch(() => {
+                process.exit(-1);
+            });
+            if (value === "none") {
+                return undefined;
+            }
+            return (0,external_path_.join)(dirPath, value);
+        })();
+        if (internalFilePath === undefined) {
+            return undefined;
+        }
+        const filePath = (0,external_path_.join)(buildContext.cacheDirPath, (0,external_path_.basename)(internalFilePath));
+        external_fs_.writeFileSync(filePath, Buffer.from(external_fs_.readFileSync(internalFilePath)
+            .toString("utf8")
+            .replace(/keycloakify\-starter/g, buildContext.themeNames[0])), "utf8");
+        return filePath;
+    })();
+    async function extractThemeResourcesFromJar() {
+        await (0,extractArchive/* extractArchive */.N)({
+            archiveFilePath: jarFilePath,
+            onArchiveFile: async ({ relativeFilePathInArchive, writeFile }) => {
+                if ((0,isInside/* isInside */.V)({ dirPath: "theme", filePath: relativeFilePathInArchive })) {
+                    await writeFile({
+                        filePath: (0,external_path_.join)(buildContext.keycloakifyBuildDirPath, relativeFilePathInArchive)
+                    });
+                }
+            }
+        });
+    }
+    {
+        const destDirPath = (0,external_path_.join)(buildContext.keycloakifyBuildDirPath, "theme");
+        if (await (0,fs_existsAsync/* existsAsync */.o)(destDirPath)) {
+            await (0,fs_rm.rm)(destDirPath, { recursive: true });
+        }
+    }
+    await extractThemeResourcesFromJar();
+    const jarFilePath_cacheDir = (0,external_path_.join)(buildContext.cacheDirPath, (0,external_path_.basename)(jarFilePath));
+    external_fs_.copyFileSync(jarFilePath, jarFilePath_cacheDir);
+    try {
+        external_child_process_.execSync(`docker rm --force ${constants/* CONTAINER_NAME */.sv}`, {
+            stdio: "ignore"
+        });
+    }
+    catch (_g) { }
+    const SPACE_PLACEHOLDER = "SPACE_PLACEHOLDER_xKLmdPd";
+    const dockerRunArgs = [
+        `-p${SPACE_PLACEHOLDER}${(_b = (_a = cliCommandOptions.port) !== null && _a !== void 0 ? _a : buildContext.startKeycloakOptions.port) !== null && _b !== void 0 ? _b : 8080}:8080`,
+        `--name${SPACE_PLACEHOLDER}${constants/* CONTAINER_NAME */.sv}`,
+        `-e${SPACE_PLACEHOLDER}KEYCLOAK_ADMIN=admin`,
+        `-e${SPACE_PLACEHOLDER}KEYCLOAK_ADMIN_PASSWORD=admin`,
+        ...(realmJsonFilePath === undefined
+            ? []
+            : [
+                `-v${SPACE_PLACEHOLDER}".${external_path_.sep}${(0,external_path_.relative)(process.cwd(), realmJsonFilePath)}":/opt/keycloak/data/import/myrealm-realm.json`
+            ]),
+        `-v${SPACE_PLACEHOLDER}"./${(0,external_path_.relative)(process.cwd(), jarFilePath_cacheDir)}":/opt/keycloak/providers/keycloak-theme.jar`,
+        ...extensionJarFilePaths.map(jarFilePath => `-v${SPACE_PLACEHOLDER}".${external_path_.sep}${(0,external_path_.relative)(process.cwd(), jarFilePath)}":/opt/keycloak/providers/${(0,external_path_.basename)(jarFilePath)}`),
+        ...(keycloakMajorVersionNumber <= 20
+            ? [`-e${SPACE_PLACEHOLDER}JAVA_OPTS=-Dkeycloak.profile=preview`]
+            : []),
+        ...[
+            ...buildContext.themeNames,
+            ...(external_fs_.existsSync((0,external_path_.join)(buildContext.keycloakifyBuildDirPath, "theme", constants/* ACCOUNT_V1_THEME_NAME */.ZQ))
+                ? [constants/* ACCOUNT_V1_THEME_NAME */.ZQ]
+                : [])
+        ]
+            .map(themeName => ({
+            localDirPath: (0,external_path_.join)(buildContext.keycloakifyBuildDirPath, "theme", themeName),
+            containerDirPath: `/opt/keycloak/themes/${themeName}`
+        }))
+            .map(({ localDirPath, containerDirPath }) => `-v${SPACE_PLACEHOLDER}".${external_path_.sep}${(0,external_path_.relative)(process.cwd(), localDirPath)}":${containerDirPath}:rw`),
+        ...buildContext.environmentVariables
+            .map(({ name }) => ({ name, envValue: process.env[name] }))
+            .map(({ name, envValue }) => envValue === undefined ? undefined : { name, envValue })
+            .filter((0,exclude.exclude)(undefined))
+            .map(({ name, envValue }) => `--env${SPACE_PLACEHOLDER}${name}='${envValue.replace(/'/g, "'\\''")}'`),
+        ...buildContext.startKeycloakOptions.dockerExtraArgs.join(SPACE_PLACEHOLDER),
+        `${(_d = (_c = buildContext.startKeycloakOptions.dockerImage) === null || _c === void 0 ? void 0 : _c.reference) !== null && _d !== void 0 ? _d : "quay.io/keycloak/keycloak"}:${dockerImageTag}`,
+        "start-dev",
+        ...(21 <= keycloakMajorVersionNumber && keycloakMajorVersionNumber < 24
+            ? ["--features=declarative-user-profile"]
+            : []),
+        ...(realmJsonFilePath === undefined ? [] : ["--import-realm"]),
+        ...buildContext.startKeycloakOptions.keycloakExtraArgs.join(SPACE_PLACEHOLDER)
+    ];
+    console.log(source_default().blue([
+        `$ docker run \\`,
+        ...dockerRunArgs
+            .map(arg => arg.replace(new RegExp(SPACE_PLACEHOLDER, "g"), " "))
+            .map((line, i, arr) => `    ${line}${arr.length - 1 === i ? "" : " \\"}`)
+    ].join("\n")));
+    const child = external_child_process_.spawn("docker", ["run", ...dockerRunArgs.map(line => line.split(SPACE_PLACEHOLDER)).flat()], { shell: true });
+    child.stdout.on("data", data => process.stdout.write(data));
+    child.stderr.on("data", data => process.stderr.write(data));
+    child.on("exit", process.exit);
+    const srcDirPath = (0,external_path_.join)(buildContext.projectDirPath, "src");
+    {
+        const handler = async (data) => {
+            if (!data.toString("utf8").includes("Listening on: http://0.0.0.0:8080")) {
+                return;
+            }
+            child.stdout.off("data", handler);
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            console.log([
+                "",
+                `The ftl files from ${source_default().bold(`.${external_path_.sep}${(0,external_path_.relative)(process.cwd(), (0,external_path_.join)(buildContext.keycloakifyBuildDirPath, "theme"))}`)} are mounted in the Keycloak container.`,
+                "",
+                `Keycloak Admin console: ${source_default().cyan.bold(`http://localhost:${cliCommandOptions.port}`)}`,
+                `- user:     ${source_default().cyan.bold("admin")}`,
+                `- password: ${source_default().cyan.bold("admin")}`,
+                "",
+                "",
+                `${source_default().green("Your theme is accessible at:")}`,
+                `${source_default().green("➜")} ${source_default().cyan.bold(`https://my-theme.keycloakify.dev${cliCommandOptions.port === 8080 ? "" : `?port=${cliCommandOptions.port}`}`)}`,
+                "",
+                "You can login with the following credentials:",
+                `- username: ${source_default().cyan.bold("testuser")}`,
+                `- password: ${source_default().cyan.bold("password123")}`,
+                "",
+                `Watching for changes in ${source_default().bold(`.${external_path_.sep}${(0,external_path_.relative)(process.cwd(), buildContext.projectDirPath)}`)}`
+            ].join("\n"));
+        };
+        child.stdout.on("data", handler);
+    }
+    {
+        const runFullBuild = runExclusive.build(async () => {
+            console.log(source_default().cyan("Detected changes in the theme. Rebuilding ..."));
+            const { isAppBuildSuccess } = await appBuild({
+                buildContext
+            });
+            if (!isAppBuildSuccess) {
+                return;
+            }
+            const { isKeycloakifyBuildSuccess } = await keycloakifyBuild({
+                buildForKeycloakMajorVersionNumber: keycloakMajorVersionNumber,
+                buildContext
+            });
+            if (!isKeycloakifyBuildSuccess) {
+                return;
+            }
+            await extractThemeResourcesFromJar();
+            console.log(source_default().green("Theme rebuilt and updated in Keycloak."));
+        });
+        const { waitForDebounce } = (0,tools_waitForDebounce/* waitForDebounceFactory */.z)({ delay: 400 });
+        chokidar.watch([
+            srcDirPath,
+            buildContext.publicDirPath,
+            (0,external_path_.join)(buildContext.projectDirPath, "package.json"),
+            (0,external_path_.join)(buildContext.projectDirPath, "vite.config.ts"),
+            (0,external_path_.join)(buildContext.projectDirPath, "vite.config.js"),
+            (0,external_path_.join)(buildContext.projectDirPath, "index.html"),
+            (0,external_path_.join)((0,getThisCodebaseRootDirPath/* getThisCodebaseRootDirPath */.e)(), "src")
+        ], {
+            ignoreInitial: true
+        })
+            .on("all", async (...[, filePath]) => {
+            console.log(`Detected changes in ${filePath}`);
+            await waitForDebounce();
+            runFullBuild();
+        });
+    }
+}
+//# sourceMappingURL=start-keycloak.js.map
+;// CONCATENATED MODULE: ./dist/bin/start-keycloak/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__(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 { urlOrPath, uniqueIdOfOnArchiveFile, onArchiveFile, cacheDirPath, fetchOptions } = params;
+    const isUrl = /^https?:\/\//.test(urlOrPath);
+    const archiveFileBasename = isUrl
+        ? urlOrPath.split("?")[0].split("/").reverse()[0]
+        : (0,path__WEBPACK_IMPORTED_MODULE_2__.basename)(urlOrPath);
+    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 (!isUrl) {
+            await fs_promises__WEBPACK_IMPORTED_MODULE_1__.copyFile(urlOrPath, archiveFilePath);
+            break download;
+        }
+        const url = urlOrPath;
+        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__) => {
+
+/* 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
+
+/***/ }),
+
+/***/ 90665:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "V": () => (/* binding */ isInside)
+/* 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__);
+
+function isInside(params) {
+    const { dirPath, filePath } = params;
+    return !(0,path__WEBPACK_IMPORTED_MODULE_0__.relative)(dirPath, filePath).startsWith("..");
+}
+//# sourceMappingURL=isInside.js.map
+
+/***/ })
+
+};
+;