keycloakify 11.3.19 → 11.3.21

package/bin/356.index.js

@@ -0,0 +1,700 @@
+"use strict";
+exports.id = 356;
+exports.ids = [356];
+exports.modules = {
+
+/***/ 6385:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "X": () => (/* binding */ getUiModuleFileSourceCodeReadyToBeCopied)
+/* harmony export */ });
+/* harmony import */ var _tools_runPrettier__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(48433);
+/* 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 _shared_constants__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(173);
+
+
+
+
+
+(0,tsafe_assert__WEBPACK_IMPORTED_MODULE_3__/* .assert */ .h)();
+async function getUiModuleFileSourceCodeReadyToBeCopied(params) {
+    const { buildContext, uiModuleDirPath, fileRelativePath, isForEjection, uiModuleName, uiModuleVersion } = params;
+    let sourceCode = (await fs_promises__WEBPACK_IMPORTED_MODULE_1__.readFile((0,path__WEBPACK_IMPORTED_MODULE_2__.join)(uiModuleDirPath, _shared_constants__WEBPACK_IMPORTED_MODULE_4__/* .KEYCLOAK_THEME */ .PC, fileRelativePath))).toString("utf8");
+    const comment = (() => {
+        if (isForEjection) {
+            return [
+                `/*`,
+                ` * This file was ejected from ${uiModuleName} version ${uiModuleVersion}.`,
+                ` */`
+            ].join("\n");
+        }
+        else {
+            return [
+                `/*`,
+                ` *`,
+                ` * WARNING: Before modifying this file run the following command:`,
+                ` * `,
+                ` * $ npx keycloakify eject-file --file ${fileRelativePath.split(path__WEBPACK_IMPORTED_MODULE_2__.sep).join("/")}`,
+                ` * `,
+                ` * This file comes from ${uiModuleName} version ${uiModuleVersion}.`,
+                ` *`,
+                ` */`
+            ].join("\n");
+        }
+    })();
+    sourceCode = [comment, ``, sourceCode].join("\n");
+    const destFilePath = (0,path__WEBPACK_IMPORTED_MODULE_2__.join)(buildContext.themeSrcDirPath, fileRelativePath);
+    format: {
+        if (!(await (0,_tools_runPrettier__WEBPACK_IMPORTED_MODULE_0__/* .getIsPrettierAvailable */ .MT)())) {
+            break format;
+        }
+        sourceCode = await (0,_tools_runPrettier__WEBPACK_IMPORTED_MODULE_0__/* .runPrettier */ .eY)({
+            filePath: destFilePath,
+            sourceCode
+        });
+    }
+    return Buffer.from(sourceCode, "utf8");
+}
+//# sourceMappingURL=getUiModuleFileSourceCodeReadyToBeCopied.js.map
+
+/***/ }),
+
+/***/ 36843:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "Y": () => (/* binding */ writeManagedGitignoreFile),
+/* harmony export */   "w": () => (/* binding */ readManagedGitignoreFile)
+/* 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 tsafe_assert__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(29041);
+/* harmony import */ var _tools_fs_existsAsync__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(43765);
+/* harmony import */ var _tools_getAbsoluteAndInOsFormatPath__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(84794);
+
+
+
+
+
+(0,tsafe_assert__WEBPACK_IMPORTED_MODULE_2__/* .assert */ .h)();
+const DELIMITER_START = `# === Ejected files start ===`;
+const DELIMITER_END = `# === Ejected files end =====`;
+async function writeManagedGitignoreFile(params) {
+    const { buildContext, uiModuleMetas, ejectedFilesRelativePaths } = params;
+    if (uiModuleMetas.length === 0) {
+        return;
+    }
+    const filePath = (0,path__WEBPACK_IMPORTED_MODULE_1__.join)(buildContext.themeSrcDirPath, ".gitignore");
+    const content_new = Buffer.from([
+        `# This file is managed by Keycloakify, do not edit it manually.`,
+        ``,
+        DELIMITER_START,
+        ...ejectedFilesRelativePaths
+            .map(fileRelativePath => fileRelativePath.split(path__WEBPACK_IMPORTED_MODULE_1__.sep).join("/"))
+            .map(line => `# ${line}`),
+        DELIMITER_END,
+        ``,
+        ...uiModuleMetas
+            .map(uiModuleMeta => [
+            `# === ${uiModuleMeta.moduleName} v${uiModuleMeta.version} ===`,
+            ...uiModuleMeta.files
+                .map(({ fileRelativePath }) => fileRelativePath)
+                .filter(fileRelativePath => !ejectedFilesRelativePaths.includes(fileRelativePath))
+                .map(fileRelativePath => `/${fileRelativePath.split(path__WEBPACK_IMPORTED_MODULE_1__.sep).join("/").replace(/^\.\//, "")}`),
+            ``
+        ])
+            .flat()
+    ].join("\n"), "utf8");
+    const content_current = await (async () => {
+        if (!(await (0,_tools_fs_existsAsync__WEBPACK_IMPORTED_MODULE_3__/* .existsAsync */ .o)(filePath))) {
+            return undefined;
+        }
+        return await fs_promises__WEBPACK_IMPORTED_MODULE_0__.readFile(filePath);
+    })();
+    if (content_current !== undefined && content_current.equals(content_new)) {
+        return;
+    }
+    create_dir: {
+        const dirPath = (0,path__WEBPACK_IMPORTED_MODULE_1__.dirname)(filePath);
+        if (await (0,_tools_fs_existsAsync__WEBPACK_IMPORTED_MODULE_3__/* .existsAsync */ .o)(dirPath)) {
+            break create_dir;
+        }
+        await fs_promises__WEBPACK_IMPORTED_MODULE_0__.mkdir(dirPath, { recursive: true });
+    }
+    await fs_promises__WEBPACK_IMPORTED_MODULE_0__.writeFile(filePath, content_new);
+}
+async function readManagedGitignoreFile(params) {
+    const { buildContext } = params;
+    const filePath = (0,path__WEBPACK_IMPORTED_MODULE_1__.join)(buildContext.themeSrcDirPath, ".gitignore");
+    if (!(await (0,_tools_fs_existsAsync__WEBPACK_IMPORTED_MODULE_3__/* .existsAsync */ .o)(filePath))) {
+        return { ejectedFilesRelativePaths: [] };
+    }
+    const contentStr = (await fs_promises__WEBPACK_IMPORTED_MODULE_0__.readFile(filePath)).toString("utf8");
+    const payload = (() => {
+        const index_start = contentStr.indexOf(DELIMITER_START);
+        const index_end = contentStr.indexOf(DELIMITER_END);
+        if (index_start === -1 || index_end === -1) {
+            return undefined;
+        }
+        return contentStr.slice(index_start + DELIMITER_START.length, index_end).trim();
+    })();
+    if (payload === undefined) {
+        return { ejectedFilesRelativePaths: [] };
+    }
+    const ejectedFilesRelativePaths = payload
+        .split("\n")
+        .map(line => line.trim())
+        .map(line => line.replace(/^# /, ""))
+        .filter(line => line !== "")
+        .map(line => (0,_tools_getAbsoluteAndInOsFormatPath__WEBPACK_IMPORTED_MODULE_4__/* .getAbsoluteAndInOsFormatPath */ .c)({
+        cwd: buildContext.themeSrcDirPath,
+        pathIsh: line
+    }))
+        .map(filePath => (0,path__WEBPACK_IMPORTED_MODULE_1__.relative)(buildContext.themeSrcDirPath, filePath));
+    return { ejectedFilesRelativePaths };
+}
+//# sourceMappingURL=managedGitignoreFile.js.map
+
+/***/ }),
+
+/***/ 5038:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "x": () => (/* binding */ computeHash),
+  "j": () => (/* binding */ getUiModuleMetas)
+});
+
+// EXTERNAL MODULE: ./node_modules/tsafe/esm/assert.mjs + 1 modules
+var assert = __webpack_require__(29041);
+// EXTERNAL MODULE: ./node_modules/tsafe/esm/id.mjs
+var id = __webpack_require__(38469);
+// EXTERNAL MODULE: ./node_modules/zod/lib/index.mjs
+var lib = __webpack_require__(52300);
+// EXTERNAL MODULE: external "path"
+var external_path_ = __webpack_require__(71017);
+// EXTERNAL MODULE: external "fs/promises"
+var promises_ = __webpack_require__(73292);
+// EXTERNAL MODULE: ./node_modules/tsafe/esm/is.mjs
+var is = __webpack_require__(16453);
+// EXTERNAL MODULE: ./dist/bin/tools/fs.existsAsync.js
+var fs_existsAsync = __webpack_require__(43765);
+// EXTERNAL MODULE: ./dist/bin/tools/getInstalledModuleDirPath.js
+var getInstalledModuleDirPath = __webpack_require__(21022);
+// EXTERNAL MODULE: ./node_modules/tsafe/esm/exclude.mjs
+var exclude = __webpack_require__(83101);
+;// CONCATENATED MODULE: ./dist/bin/tools/listInstalledModules.js
+
+
+
+
+
+
+
+
+async function listInstalledModules(params) {
+    const { packageJsonFilePath, projectDirPath, filter } = params;
+    const parsedPackageJson = await readPackageJsonDependencies({
+        packageJsonFilePath
+    });
+    const uiModuleNames = [parsedPackageJson.dependencies, parsedPackageJson.devDependencies]
+        .filter((0,exclude/* exclude */.D)(undefined))
+        .map(obj => Object.keys(obj))
+        .flat()
+        .filter(moduleName => filter({ moduleName }));
+    const result = await Promise.all(uiModuleNames.map(async (moduleName) => {
+        const dirPath = await (0,getInstalledModuleDirPath/* getInstalledModuleDirPath */.p)({
+            moduleName,
+            packageJsonDirPath: (0,external_path_.dirname)(packageJsonFilePath),
+            projectDirPath
+        });
+        const { version, peerDependencies } = await readPackageJsonVersionAndPeerDependencies({
+            packageJsonFilePath: (0,external_path_.join)(dirPath, "package.json")
+        });
+        return { moduleName, version, peerDependencies, dirPath };
+    }));
+    return result;
+}
+const { readPackageJsonDependencies } = (() => {
+    const zParsedPackageJson = (() => {
+        const zTargetType = lib.z.object({
+            dependencies: lib.z.record(lib.z.string()).optional(),
+            devDependencies: lib.z.record(lib.z.string()).optional()
+        });
+        (0,assert/* assert */.h)();
+        return (0,id.id)(zTargetType);
+    })();
+    async function readPackageJsonDependencies(params) {
+        const { packageJsonFilePath } = params;
+        const parsedPackageJson = JSON.parse((await promises_.readFile(packageJsonFilePath)).toString("utf8"));
+        zParsedPackageJson.parse(parsedPackageJson);
+        (0,assert/* assert */.h)((0,is.is)(parsedPackageJson));
+        return parsedPackageJson;
+    }
+    return { readPackageJsonDependencies };
+})();
+const { readPackageJsonVersionAndPeerDependencies } = (() => {
+    const zParsedPackageJson = (() => {
+        const zTargetType = lib.z.object({
+            version: lib.z.string(),
+            peerDependencies: lib.z.record(lib.z.string()).optional()
+        });
+        (0,assert/* assert */.h)();
+        return (0,id.id)(zTargetType);
+    })();
+    async function readPackageJsonVersionAndPeerDependencies(params) {
+        var _a;
+        const { packageJsonFilePath } = params;
+        const parsedPackageJson = JSON.parse((await promises_.readFile(packageJsonFilePath)).toString("utf8"));
+        zParsedPackageJson.parse(parsedPackageJson);
+        (0,assert/* assert */.h)((0,is.is)(parsedPackageJson));
+        return {
+            version: parsedPackageJson.version,
+            peerDependencies: (_a = parsedPackageJson.peerDependencies) !== null && _a !== void 0 ? _a : {}
+        };
+    }
+    return { readPackageJsonVersionAndPeerDependencies };
+})();
+//# sourceMappingURL=listInstalledModules.js.map
+;// CONCATENATED MODULE: ./dist/bin/tools/crawlAsync.js
+
+
+
+/** List all files in a given directory return paths relative to the dir_path */
+async function crawlAsync(params) {
+    const { dirPath, returnedPathsType, onFileFound } = params;
+    await crawlAsyncRec({
+        dirPath,
+        onFileFound: async ({ filePath }) => {
+            switch (returnedPathsType) {
+                case "absolute":
+                    await onFileFound(filePath);
+                    return;
+                case "relative to dirPath":
+                    await onFileFound((0,external_path_.relative)(dirPath, filePath));
+                    return;
+            }
+            (0,assert/* assert */.h)();
+        }
+    });
+}
+async function crawlAsyncRec(params) {
+    const { dirPath, onFileFound } = params;
+    await Promise.all((await promises_.readdir(dirPath)).map(async (basename) => {
+        const fileOrDirPath = (0,external_path_.join)(dirPath, basename);
+        const isDirectory = await promises_.lstat(fileOrDirPath)
+            .then(stat => stat.isDirectory());
+        if (isDirectory) {
+            await crawlAsyncRec({ dirPath: fileOrDirPath, onFileFound });
+            return;
+        }
+        await onFileFound({ filePath: fileOrDirPath });
+    }));
+}
+//# sourceMappingURL=crawlAsync.js.map
+// EXTERNAL MODULE: ./dist/bin/tools/runPrettier.js
+var runPrettier = __webpack_require__(48433);
+// EXTERNAL MODULE: ./dist/bin/tools/readThisNpmPackageVersion.js
+var readThisNpmPackageVersion = __webpack_require__(64795);
+// EXTERNAL MODULE: ./dist/bin/postinstall/getUiModuleFileSourceCodeReadyToBeCopied.js
+var getUiModuleFileSourceCodeReadyToBeCopied = __webpack_require__(6385);
+// EXTERNAL MODULE: external "crypto"
+var external_crypto_ = __webpack_require__(6113);
+// EXTERNAL MODULE: ./dist/bin/shared/constants.js
+var constants = __webpack_require__(173);
+;// CONCATENATED MODULE: ./dist/bin/postinstall/uiModuleMeta.js
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const zUiModuleMeta = (() => {
+    const zTargetType = lib.z.object({
+        moduleName: lib.z.string(),
+        version: lib.z.string(),
+        files: lib.z.array(lib.z.object({
+            fileRelativePath: lib.z.string(),
+            hash: lib.z.string(),
+            copyableFilePath: lib.z.string()
+        })),
+        peerDependencies: lib.z.record(lib.z.string())
+    });
+    (0,assert/* assert */.h)();
+    return (0,id.id)(zTargetType);
+})();
+const zParsedCacheFile = (() => {
+    const zTargetType = lib.z.object({
+        keycloakifyVersion: lib.z.string(),
+        prettierConfigHash: lib.z.union([lib.z.string(), lib.z["null"]()]),
+        thisFilePath: lib.z.string(),
+        uiModuleMetas: lib.z.array(zUiModuleMeta)
+    });
+    (0,assert/* assert */.h)();
+    return (0,id.id)(zTargetType);
+})();
+const CACHE_FILE_RELATIVE_PATH = (0,external_path_.join)("ui-modules", "cache.json");
+(0,assert/* assert */.h)();
+async function getUiModuleMetas(params) {
+    const { buildContext } = params;
+    const cacheFilePath = (0,external_path_.join)(buildContext.cacheDirPath, CACHE_FILE_RELATIVE_PATH);
+    const keycloakifyVersion = (0,readThisNpmPackageVersion/* readThisNpmPackageVersion */.K)();
+    const prettierConfigHash = await (async () => {
+        if (!(await (0,runPrettier/* getIsPrettierAvailable */.MT)())) {
+            return null;
+        }
+        const { configHash } = await (0,runPrettier/* getPrettier */.LG)();
+        return configHash;
+    })();
+    const installedUiModules = await (async () => {
+        const installedModulesWithKeycloakifyInTheName = await listInstalledModules({
+            packageJsonFilePath: buildContext.packageJsonFilePath,
+            projectDirPath: buildContext.packageJsonFilePath,
+            filter: ({ moduleName }) => moduleName.includes("keycloakify") && moduleName !== "keycloakify"
+        });
+        return (await Promise.all(installedModulesWithKeycloakifyInTheName.map(async (entry) => {
+            if (!(await (0,fs_existsAsync/* existsAsync */.o)((0,external_path_.join)(entry.dirPath, constants/* KEYCLOAK_THEME */.PC)))) {
+                return undefined;
+            }
+            return entry;
+        }))).filter((0,exclude/* exclude */.D)(undefined));
+    })();
+    const cacheContent = await (async () => {
+        if (!(await (0,fs_existsAsync/* existsAsync */.o)(cacheFilePath))) {
+            return undefined;
+        }
+        return await promises_.readFile(cacheFilePath);
+    })();
+    const uiModuleMetas_cacheUpToDate = await (async () => {
+        const parsedCacheFile = await (async () => {
+            if (cacheContent === undefined) {
+                return undefined;
+            }
+            const cacheContentStr = cacheContent.toString("utf8");
+            let parsedCacheFile;
+            try {
+                parsedCacheFile = JSON.parse(cacheContentStr);
+            }
+            catch (_a) {
+                return undefined;
+            }
+            try {
+                zParsedCacheFile.parse(parsedCacheFile);
+            }
+            catch (_b) {
+                return undefined;
+            }
+            (0,assert/* assert */.h)((0,is.is)(parsedCacheFile));
+            return parsedCacheFile;
+        })();
+        if (parsedCacheFile === undefined) {
+            return [];
+        }
+        if (parsedCacheFile.keycloakifyVersion !== keycloakifyVersion) {
+            return [];
+        }
+        if (parsedCacheFile.prettierConfigHash !== prettierConfigHash) {
+            return [];
+        }
+        if (parsedCacheFile.thisFilePath !== cacheFilePath) {
+            return [];
+        }
+        const uiModuleMetas_cacheUpToDate = parsedCacheFile.uiModuleMetas.filter(uiModuleMeta => {
+            const correspondingInstalledUiModule = installedUiModules.find(installedUiModule => installedUiModule.moduleName === uiModuleMeta.moduleName);
+            if (correspondingInstalledUiModule === undefined) {
+                return false;
+            }
+            return correspondingInstalledUiModule.version === uiModuleMeta.version;
+        });
+        return uiModuleMetas_cacheUpToDate;
+    })();
+    const uiModuleMetas = await Promise.all(installedUiModules.map(async ({ moduleName, version, peerDependencies, dirPath }) => {
+        use_cache: {
+            const uiModuleMeta_cache = uiModuleMetas_cacheUpToDate.find(uiModuleMeta => uiModuleMeta.moduleName === moduleName);
+            if (uiModuleMeta_cache === undefined) {
+                break use_cache;
+            }
+            return uiModuleMeta_cache;
+        }
+        const files = [];
+        {
+            const srcDirPath = (0,external_path_.join)(dirPath, constants/* KEYCLOAK_THEME */.PC);
+            await crawlAsync({
+                dirPath: srcDirPath,
+                returnedPathsType: "relative to dirPath",
+                onFileFound: async (fileRelativePath) => {
+                    const sourceCode = await (0,getUiModuleFileSourceCodeReadyToBeCopied/* getUiModuleFileSourceCodeReadyToBeCopied */.X)({
+                        buildContext,
+                        fileRelativePath,
+                        isForEjection: false,
+                        uiModuleDirPath: dirPath,
+                        uiModuleName: moduleName,
+                        uiModuleVersion: version
+                    });
+                    const hash = computeHash(sourceCode);
+                    const copyableFilePath = (0,external_path_.join)((0,external_path_.dirname)(cacheFilePath), constants/* KEYCLOAK_THEME */.PC, fileRelativePath);
+                    {
+                        const dirPath = (0,external_path_.dirname)(copyableFilePath);
+                        if (!(await (0,fs_existsAsync/* existsAsync */.o)(dirPath))) {
+                            await promises_.mkdir(dirPath, { recursive: true });
+                        }
+                    }
+                    promises_.writeFile(copyableFilePath, sourceCode);
+                    files.push({
+                        fileRelativePath,
+                        hash,
+                        copyableFilePath
+                    });
+                }
+            });
+        }
+        return (0,id.id)({
+            moduleName,
+            version,
+            files,
+            peerDependencies
+        });
+    }));
+    update_cache: {
+        const parsedCacheFile = (0,id.id)({
+            keycloakifyVersion,
+            prettierConfigHash,
+            thisFilePath: cacheFilePath,
+            uiModuleMetas
+        });
+        const cacheContent_new = Buffer.from(JSON.stringify(parsedCacheFile, null, 2), "utf8");
+        if (cacheContent !== undefined && cacheContent_new.equals(cacheContent)) {
+            break update_cache;
+        }
+        create_dir: {
+            const dirPath = (0,external_path_.dirname)(cacheFilePath);
+            if (await (0,fs_existsAsync/* existsAsync */.o)(dirPath)) {
+                break create_dir;
+            }
+            await promises_.mkdir(dirPath, { recursive: true });
+        }
+        await promises_.writeFile(cacheFilePath, cacheContent_new);
+    }
+    return uiModuleMetas;
+}
+function computeHash(data) {
+    return external_crypto_.createHash("sha256").update(data).digest("hex");
+}
+//# sourceMappingURL=uiModuleMeta.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
+
+/***/ }),
+
+/***/ 21022:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "p": () => (/* binding */ getInstalledModuleDirPath)
+/* harmony export */ });
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(71017);
+/* harmony import */ var path__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(path__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _fs_existsAsync__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(43765);
+/* harmony import */ var child_process__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(32081);
+/* harmony import */ var child_process__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(child_process__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var tsafe_assert__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(29041);
+
+
+
+
+async function getInstalledModuleDirPath(params) {
+    const { moduleName, packageJsonDirPath, projectDirPath } = params;
+    common_case: {
+        const dirPath = (0,path__WEBPACK_IMPORTED_MODULE_0__.join)(...[packageJsonDirPath, "node_modules", ...moduleName.split("/")]);
+        if (!(await (0,_fs_existsAsync__WEBPACK_IMPORTED_MODULE_1__/* .existsAsync */ .o)(dirPath))) {
+            break common_case;
+        }
+        return dirPath;
+    }
+    node_modules_at_root_case: {
+        if (projectDirPath === packageJsonDirPath) {
+            break node_modules_at_root_case;
+        }
+        const dirPath = (0,path__WEBPACK_IMPORTED_MODULE_0__.join)(...[projectDirPath, "node_modules", ...moduleName.split("/")]);
+        if (!(await (0,_fs_existsAsync__WEBPACK_IMPORTED_MODULE_1__/* .existsAsync */ .o)(dirPath))) {
+            break node_modules_at_root_case;
+        }
+        return dirPath;
+    }
+    const dirPath = child_process__WEBPACK_IMPORTED_MODULE_2__.execSync(`npm list ${moduleName}`, {
+        cwd: packageJsonDirPath
+    })
+        .toString("utf8")
+        .trim();
+    (0,tsafe_assert__WEBPACK_IMPORTED_MODULE_3__/* .assert */ .h)(dirPath !== "");
+    return dirPath;
+}
+//# sourceMappingURL=getInstalledModuleDirPath.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
+
+/***/ }),
+
+/***/ 48433:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "LG": () => (/* binding */ getPrettier),
+/* harmony export */   "MT": () => (/* binding */ getIsPrettierAvailable),
+/* harmony export */   "eY": () => (/* binding */ runPrettier)
+/* harmony export */ });
+/* harmony import */ var _nodeModulesBinDirPath__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(73776);
+/* 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 fs_promises__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(73292);
+/* harmony import */ var fs_promises__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(fs_promises__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var tsafe_id__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(38469);
+/* harmony import */ var tsafe_assert__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(29041);
+/* harmony import */ var chalk__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(78818);
+/* harmony import */ var chalk__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(chalk__WEBPACK_IMPORTED_MODULE_4__);
+/* harmony import */ var crypto__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(6113);
+/* harmony import */ var crypto__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(crypto__WEBPACK_IMPORTED_MODULE_5__);
+
+
+
+
+
+
+
+getIsPrettierAvailable.cache = (0,tsafe_id__WEBPACK_IMPORTED_MODULE_6__.id)(undefined);
+async function getIsPrettierAvailable() {
+    var _a;
+    if (getIsPrettierAvailable.cache !== undefined) {
+        return getIsPrettierAvailable.cache;
+    }
+    const nodeModulesBinDirPath = (0,_nodeModulesBinDirPath__WEBPACK_IMPORTED_MODULE_0__/* .getNodeModulesBinDirPath */ .K)();
+    const prettierBinPath = (0,path__WEBPACK_IMPORTED_MODULE_1__.join)(nodeModulesBinDirPath, "prettier");
+    const stats = await fs_promises__WEBPACK_IMPORTED_MODULE_2__.stat(prettierBinPath).catch(() => undefined);
+    const isPrettierAvailable = (_a = stats === null || stats === void 0 ? void 0 : stats.isFile()) !== null && _a !== void 0 ? _a : false;
+    getIsPrettierAvailable.cache = isPrettierAvailable;
+    return isPrettierAvailable;
+}
+getPrettier.cache = (0,tsafe_id__WEBPACK_IMPORTED_MODULE_6__.id)(undefined);
+async function getPrettier() {
+    (0,tsafe_assert__WEBPACK_IMPORTED_MODULE_3__/* .assert */ .h)(getIsPrettierAvailable());
+    if (getPrettier.cache !== undefined) {
+        return getPrettier.cache;
+    }
+    const prettier = await Promise.resolve(/* import() */).then(__webpack_require__.t.bind(__webpack_require__, 79421, 23));
+    const configHash = await (async () => {
+        const configFilePath = await prettier.resolveConfigFile((0,path__WEBPACK_IMPORTED_MODULE_1__.join)((0,_nodeModulesBinDirPath__WEBPACK_IMPORTED_MODULE_0__/* .getNodeModulesBinDirPath */ .K)(), ".."));
+        if (configFilePath === null) {
+            return "";
+        }
+        const data = await fs_promises__WEBPACK_IMPORTED_MODULE_2__.readFile(configFilePath);
+        return crypto__WEBPACK_IMPORTED_MODULE_5__.createHash("sha256").update(data).digest("hex");
+    })();
+    const prettierAndConfig = {
+        prettier,
+        configHash
+    };
+    getPrettier.cache = prettierAndConfig;
+    return prettierAndConfig;
+}
+async function runPrettier(params) {
+    const { sourceCode, filePath } = params;
+    let formattedSourceCode;
+    try {
+        const { prettier } = await getPrettier();
+        const { ignored, inferredParser } = await prettier.getFileInfo(filePath, {
+            resolveConfig: true
+        });
+        if (ignored) {
+            return sourceCode;
+        }
+        const config = await prettier.resolveConfig(filePath);
+        formattedSourceCode = await prettier.format(sourceCode, Object.assign(Object.assign({}, config), { filePath, parser: inferredParser !== null && inferredParser !== void 0 ? inferredParser : undefined }));
+    }
+    catch (error) {
+        console.log(chalk__WEBPACK_IMPORTED_MODULE_4___default().red(`You probably need to upgrade the version of prettier in your project`));
+        throw error;
+    }
+    return formattedSourceCode;
+}
+//# sourceMappingURL=runPrettier.js.map
+
+/***/ })
+
+};
+;