@rsdoctor/utils 1.1.10 → 1.2.0-beta.1

package/dist/esm/common/graph/assets.mjs

@@ -0,0 +1,238 @@
+import { Client, Constants } from "@rsdoctor/types";
+import { getChunksByAsset } from "./chunk.mjs";
+import { getModulesByAsset } from "./modules.mjs";
+const EXT = 'js|css|html';
+const hashPattern = /[a-z|A-Z|0-9]{4,32}/;
+const hashSeparatorPattern = /[-|.]/;
+const fileExtensionPattern = /(?:\.[a-z｜A-Z|0-9]{2,}){1,}/;
+const filenamePattern = new RegExp(`(.*)${hashSeparatorPattern.source}${hashPattern.source}(${fileExtensionPattern.source})$`);
+function formatAssetName(assetName, fileConfig) {
+    var _splitFilesList_;
+    const splitFilesList = null == fileConfig ? void 0 : fileConfig.split('.');
+    let outputFileTailName = '';
+    let unHashedFileName = assetName;
+    if ((null == splitFilesList ? void 0 : splitFilesList.length) && splitFilesList.length >= 3 && (null == (_splitFilesList_ = splitFilesList[splitFilesList.length - 2]) ? void 0 : _splitFilesList_.indexOf('[')) < 0 && EXT.indexOf(splitFilesList[splitFilesList.length - 1]) > -1) {
+        outputFileTailName = splitFilesList[splitFilesList.length - 2];
+        const _regPattern = /(.*)(\.[a-f0-9]{4,32})([^.]*.[^.]+){2,}/g;
+        unHashedFileName = assetName.replace(_regPattern, '$1');
+        return `${unHashedFileName}.${outputFileTailName}.${assetName.substring(assetName.lastIndexOf('.') + 1)}`;
+    }
+    return assetName.replace(filenamePattern, '$1$2');
+}
+function isAssetMatchExtension(asset, ext) {
+    return asset.path.slice(-ext.length) === ext || extname(asset.path) === ext;
+}
+function isAssetMatchExtensions(asset, exts) {
+    if (!exts.length) return false;
+    return exts.some((ext)=>isAssetMatchExtension(asset, ext));
+}
+function filterAssetsByExtensions(assets, exts) {
+    if ('string' == typeof exts) return assets.filter((e)=>isAssetMatchExtension(e, exts));
+    if (Array.isArray(exts)) return assets.filter((e)=>isAssetMatchExtensions(e, exts));
+    return [];
+}
+function filterAssets(assets, filterOrExtensions) {
+    if (filterOrExtensions) assets = 'function' == typeof filterOrExtensions ? assets.filter(filterOrExtensions) : filterAssetsByExtensions(assets, filterOrExtensions);
+    return assets;
+}
+function getAssetsSizeInfo(assets, chunks, options = {}) {
+    const { withFileContent = true, filterOrExtensions } = options;
+    assets = assets.filter((e)=>!isAssetMatchExtensions(e, Constants.MapExtensions));
+    if (filterOrExtensions) assets = filterAssets(assets, filterOrExtensions);
+    if (assets.length) return {
+        count: assets.length,
+        size: assets.reduce((t, c)=>t + c.size, 0),
+        files: assets.map((e)=>({
+                path: e.path,
+                size: e.size,
+                gzipSize: e.gzipSize,
+                initial: isInitialAsset(e, chunks),
+                content: withFileContent ? e.content : void 0
+            }))
+    };
+    return {
+        count: 0,
+        size: 0,
+        files: []
+    };
+}
+function isInitialAsset(asset, chunks) {
+    const cks = getChunksByAsset(asset, chunks);
+    return cks.some((e)=>Boolean(e.initial));
+}
+function getInitialAssetsSizeInfo(assets, chunks, options = {}) {
+    if (options.filterOrExtensions) assets = filterAssets(assets, options.filterOrExtensions);
+    return getAssetsSizeInfo(assets, chunks, {
+        ...options,
+        filterOrExtensions: (asset)=>isInitialAsset(asset, chunks)
+    });
+}
+function getAssetsDiffResult(baseline, current) {
+    return {
+        all: {
+            total: diffAssetsByExtensions(baseline, current)
+        },
+        js: {
+            total: diffAssetsByExtensions(baseline, current, Constants.JSExtension),
+            initial: diffAssetsByExtensions(baseline, current, Constants.JSExtension, true)
+        },
+        css: {
+            total: diffAssetsByExtensions(baseline, current, Constants.CSSExtension),
+            initial: diffAssetsByExtensions(baseline, current, Constants.CSSExtension, true)
+        },
+        imgs: {
+            total: diffAssetsByExtensions(baseline, current, Constants.ImgExtensions)
+        },
+        html: {
+            total: diffAssetsByExtensions(baseline, current, Constants.HtmlExtension)
+        },
+        media: {
+            total: diffAssetsByExtensions(baseline, current, Constants.MediaExtensions)
+        },
+        fonts: {
+            total: diffAssetsByExtensions(baseline, current, Constants.FontExtensions)
+        },
+        others: {
+            total: diffAssetsByExtensions(baseline, current, (asset)=>!isAssetMatchExtensions(asset, [
+                    Constants.JSExtension,
+                    Constants.CSSExtension,
+                    Constants.HtmlExtension
+                ].concat(Constants.ImgExtensions, Constants.MediaExtensions, Constants.FontExtensions, Constants.MapExtensions)))
+        }
+    };
+}
+function diffSize(bSize, cSize) {
+    const isEqual = bSize === cSize;
+    const percent = isEqual ? 0 : 0 === bSize ? 100 : Math.abs(cSize - bSize) / bSize * 100;
+    const state = isEqual ? Client.RsdoctorClientDiffState.Equal : bSize > cSize ? Client.RsdoctorClientDiffState.Down : Client.RsdoctorClientDiffState.Up;
+    return {
+        percent,
+        state
+    };
+}
+function diffAssetsByExtensions(baseline, current, filterOrExtensions, isInitial = false) {
+    const { size: bSize, count: bCount } = isInitial ? getInitialAssetsSizeInfo(baseline.assets, baseline.chunks, {
+        filterOrExtensions
+    }) : getAssetsSizeInfo(baseline.assets, baseline.chunks, {
+        filterOrExtensions
+    });
+    let cSize;
+    let cCount;
+    if (baseline === current) {
+        cSize = bSize;
+        cCount = bCount;
+    } else {
+        const { size, count } = isInitial ? getInitialAssetsSizeInfo(current.assets, current.chunks, {
+            filterOrExtensions
+        }) : getAssetsSizeInfo(current.assets, current.chunks, {
+            filterOrExtensions
+        });
+        cSize = size;
+        cCount = count;
+    }
+    const { percent, state } = diffSize(bSize, cSize);
+    return {
+        size: {
+            baseline: bSize,
+            current: cSize
+        },
+        count: {
+            baseline: bCount,
+            current: cCount
+        },
+        percent,
+        state
+    };
+}
+function getAssetsSummary(assets, chunks, options = {}) {
+    const jsOpt = {
+        ...options,
+        filterOrExtensions: Constants.JSExtension
+    };
+    const cssOpt = {
+        ...options,
+        filterOrExtensions: Constants.CSSExtension
+    };
+    const imgOpt = {
+        ...options,
+        filterOrExtensions: Constants.ImgExtensions
+    };
+    const htmlOpt = {
+        ...options,
+        filterOrExtensions: Constants.HtmlExtension
+    };
+    const mediaOpt = {
+        ...options,
+        filterOrExtensions: Constants.MediaExtensions
+    };
+    const fontOpt = {
+        ...options,
+        filterOrExtensions: Constants.FontExtensions
+    };
+    const otherOpt = {
+        ...options,
+        filterOrExtensions: (asset)=>!isAssetMatchExtensions(asset, [
+                Constants.JSExtension,
+                Constants.CSSExtension,
+                Constants.HtmlExtension
+            ].concat(Constants.ImgExtensions, Constants.MediaExtensions, Constants.FontExtensions, Constants.MapExtensions))
+    };
+    return {
+        all: {
+            total: getAssetsSizeInfo(assets, chunks, options)
+        },
+        js: {
+            total: getAssetsSizeInfo(assets, chunks, jsOpt),
+            initial: getInitialAssetsSizeInfo(assets, chunks, jsOpt)
+        },
+        css: {
+            total: getAssetsSizeInfo(assets, chunks, cssOpt),
+            initial: getInitialAssetsSizeInfo(assets, chunks, cssOpt)
+        },
+        imgs: {
+            total: getAssetsSizeInfo(assets, chunks, imgOpt)
+        },
+        html: {
+            total: getAssetsSizeInfo(assets, chunks, htmlOpt)
+        },
+        media: {
+            total: getAssetsSizeInfo(assets, chunks, mediaOpt)
+        },
+        fonts: {
+            total: getAssetsSizeInfo(assets, chunks, fontOpt)
+        },
+        others: {
+            total: getAssetsSizeInfo(assets, chunks, otherOpt)
+        }
+    };
+}
+function getAssetDetails(assetPath, assets, chunks, modules) {
+    const asset = assets.find((e)=>e.path === assetPath);
+    return {
+        asset,
+        chunks: getChunksByAsset(asset, chunks),
+        modules: getModulesByAsset(asset, chunks, modules)
+    };
+}
+function getAllBundleData(assets, chunks, modules, filtersModules) {
+    const result = [];
+    try {
+        for(let i = 0; i < assets.length; i++){
+            const asset = assets[i];
+            result.push({
+                asset,
+                modules: getModulesByAsset(asset, chunks, modules, filtersModules)
+            });
+        }
+        return result;
+    } catch (error) {
+        console.error(error);
+        return [];
+    }
+}
+function extname(filename) {
+    const baseName = filename.split('?')[0];
+    const matches = baseName.match(/\.([0-9a-z]+)(?:[\?#]|$)/i);
+    return matches ? `.${matches[1]}` : '';
+}
+export { diffAssetsByExtensions, diffSize, extname, filterAssets, filterAssetsByExtensions, formatAssetName, getAllBundleData, getAssetDetails, getAssetsDiffResult, getAssetsSizeInfo, getAssetsSummary, getInitialAssetsSizeInfo, isAssetMatchExtension, isAssetMatchExtensions, isInitialAsset };

package/dist/esm/common/graph/chunk.mjs

@@ -0,0 +1,32 @@
+function getChunkIdsByAsset(asset) {
+    if (asset.chunks) return asset.chunks;
+    return [];
+}
+function getChunksByModule(module, chunks) {
+    if (module.chunks.length) return getChunksByChunkIds(module.chunks, chunks);
+    return [];
+}
+function getChunkByChunkId(chunkId, chunks) {
+    return chunks.find((e)=>e.id === chunkId);
+}
+function getChunksByChunkIds(chunkIds, chunks, filters) {
+    if (!chunkIds.length) return [];
+    const result = chunkIds.map((id)=>chunks.find((e)=>e.id === id)).filter(Boolean).map((chunk)=>{
+        if (filters && filters.length > 0) {
+            const filtered = {};
+            for (const key of filters)if (void 0 !== chunk[key]) filtered[key] = chunk[key];
+            return filtered;
+        }
+        return chunk;
+    });
+    return result;
+}
+function getChunksByAsset(asset, chunks, filters) {
+    return getChunksByChunkIds(getChunkIdsByAsset(asset), chunks, filters);
+}
+function getChunksByModuleId(id, modules, chunks) {
+    const mod = modules.find((e)=>e.id === id);
+    if (!mod) return [];
+    return getChunksByModule(mod, chunks);
+}
+export { getChunkByChunkId, getChunkIdsByAsset, getChunksByAsset, getChunksByChunkIds, getChunksByModule, getChunksByModuleId };

package/dist/esm/common/graph/dependency.mjs

@@ -0,0 +1,10 @@
+function getDependencyByPackageData(dep, dependencies) {
+    return dependencies.find((item)=>item.id === dep.dependencyId);
+}
+function getDependenciesByModule(module, dependencies) {
+    return module.dependencies.map((id)=>dependencies.find((dep)=>dep.id === id)).filter(Boolean);
+}
+function getDependencyByResolvedRequest(resolvedRequest, dependencies) {
+    return dependencies.find((e)=>e.resolvedRequest === resolvedRequest);
+}
+export { getDependenciesByModule, getDependencyByPackageData, getDependencyByResolvedRequest };

package/dist/esm/common/graph/entrypoints.mjs

@@ -0,0 +1,4 @@
+function getEntryPoints(entrypoints) {
+    return entrypoints;
+}
+export { getEntryPoints };

package/dist/esm/common/graph/index.mjs

@@ -0,0 +1,5 @@
+export * from "./assets.mjs";
+export * from "./chunk.mjs";
+export * from "./modules.mjs";
+export * from "./dependency.mjs";
+export * from "./entrypoints.mjs";

package/dist/esm/common/graph/modules.mjs

@@ -0,0 +1,78 @@
+import { getChunkIdsByAsset, getChunksByChunkIds } from "./chunk.mjs";
+import { getDependenciesByModule, getDependencyByPackageData } from "./dependency.mjs";
+import { logger } from "../../logger.mjs";
+import { isJsExt, isStyleExt } from "../file.mjs";
+function getModulesByAsset(asset, chunks, modules, filterModules) {
+    const ids = getChunkIdsByAsset(asset);
+    const cks = getChunksByChunkIds(ids, chunks);
+    const res = getModulesByChunks(asset.path, cks, modules, filterModules);
+    return res;
+}
+function getModuleIdsByChunk(chunk) {
+    const { modules = [] } = chunk;
+    return modules;
+}
+function getModuleIdsByModulesIds(moduleIds, modules) {
+    return moduleIds.map((id)=>modules.find((m)=>m.id === id)).filter(Boolean);
+}
+function getModulesByChunk(chunk, modules, filterModules) {
+    const ids = getModuleIdsByChunk(chunk);
+    return ids.map((id)=>{
+        const module = modules.find((e)=>e.id === id);
+        if (filterModules && filterModules.length > 0) {
+            if (!module) return null;
+            const filtered = {};
+            for (const key of filterModules)if (void 0 !== module[key]) filtered[key] = module[key];
+            return filtered;
+        }
+        return module;
+    }).filter(Boolean);
+}
+function getTypeChecker(assetPath) {
+    if (isStyleExt(assetPath)) return isStyleExt;
+    if (isJsExt(assetPath)) return isJsExt;
+    return ()=>true;
+}
+function getModulesByChunks(assetPath, chunks, modules, filterModules) {
+    const res = [];
+    const typeChecker = getTypeChecker(assetPath);
+    try {
+        chunks.forEach((chunk)=>{
+            getModulesByChunk(chunk, modules, filterModules).forEach((md)=>{
+                const name = md.path || '';
+                if (!typeChecker(name)) return;
+                if (!res.filter((_m)=>_m.id === md.id).length) res.push(md);
+            });
+        });
+    } catch (error) {
+        logger.debug(error);
+    }
+    return res;
+}
+function getModuleByDependency(dep, modules) {
+    return modules.find((item)=>item.id === dep.module);
+}
+function filterModulesAndDependenciesByPackageDeps(deps, dependencies, modules) {
+    const _dependencies = [];
+    const _modules = [];
+    for(let i = 0; i < deps.length; i++){
+        const dep = getDependencyByPackageData(deps[i], dependencies);
+        if (dep) {
+            _dependencies.push(dep);
+            const module = getModuleByDependency(dep, modules);
+            if (module) _modules.push(module);
+        }
+    }
+    return {
+        dependencies: _dependencies,
+        modules: _modules
+    };
+}
+function getModuleDetails(moduleId, modules, dependencies) {
+    const module = modules.find((e)=>e.id === moduleId);
+    return {
+        module,
+        dependencies: getDependenciesByModule(module, dependencies)
+    };
+}
+export { filterModulesAndDependenciesByPackageDeps, getModuleByDependency, getModuleDetails, getModuleIdsByChunk, getModuleIdsByModulesIds, getModulesByAsset, getModulesByChunk, getModulesByChunks };

package/dist/esm/common/index.mjs

@@ -0,0 +1,19 @@
+import * as __WEBPACK_EXTERNAL_MODULE__summary_mjs_54f58833__ from "./summary.mjs";
+import * as __WEBPACK_EXTERNAL_MODULE__crypto_mjs_252a9c2c__ from "./crypto.mjs";
+import * as __WEBPACK_EXTERNAL_MODULE__manifest_mjs_2d750078__ from "./manifest.mjs";
+import * as __WEBPACK_EXTERNAL_MODULE__loader_mjs_ab87ced3__ from "./loader.mjs";
+import * as __WEBPACK_EXTERNAL_MODULE__time_mjs_7d968bf1__ from "./time.mjs";
+import * as __WEBPACK_EXTERNAL_MODULE__algorithm_mjs_ed543360__ from "./algorithm.mjs";
+import * as __WEBPACK_EXTERNAL_MODULE__resolver_mjs_24d6f61e__ from "./resolver.mjs";
+import * as __WEBPACK_EXTERNAL_MODULE__graph_index_mjs_4e5a8d12__ from "./graph/index.mjs";
+import * as __WEBPACK_EXTERNAL_MODULE__bundle_mjs_804f0b3a__ from "./bundle.mjs";
+import * as __WEBPACK_EXTERNAL_MODULE__url_mjs_0b48a1db__ from "./url.mjs";
+import * as __WEBPACK_EXTERNAL_MODULE__plugin_mjs_ee4957f9__ from "./plugin.mjs";
+import * as __WEBPACK_EXTERNAL_MODULE__data_index_mjs_870691a9__ from "./data/index.mjs";
+import * as __WEBPACK_EXTERNAL_MODULE__alerts_mjs_af8e297e__ from "./alerts.mjs";
+import * as __WEBPACK_EXTERNAL_MODULE__rspack_mjs_fb7d03b6__ from "./rspack.mjs";
+import * as __WEBPACK_EXTERNAL_MODULE__package_mjs_f12bd493__ from "./package.mjs";
+import * as __WEBPACK_EXTERNAL_MODULE__lodash_mjs_5081b560__ from "./lodash.mjs";
+import * as __WEBPACK_EXTERNAL_MODULE__global_config_mjs_ce875cc9__ from "./global-config.mjs";
+import * as __WEBPACK_EXTERNAL_MODULE__file_mjs_bb53e012__ from "./file.mjs";
+export { __WEBPACK_EXTERNAL_MODULE__alerts_mjs_af8e297e__ as Alerts, __WEBPACK_EXTERNAL_MODULE__algorithm_mjs_ed543360__ as Algorithm, __WEBPACK_EXTERNAL_MODULE__bundle_mjs_804f0b3a__ as Bundle, __WEBPACK_EXTERNAL_MODULE__crypto_mjs_252a9c2c__ as Crypto, __WEBPACK_EXTERNAL_MODULE__data_index_mjs_870691a9__ as Data, __WEBPACK_EXTERNAL_MODULE__file_mjs_bb53e012__ as File, __WEBPACK_EXTERNAL_MODULE__global_config_mjs_ce875cc9__ as GlobalConfig, __WEBPACK_EXTERNAL_MODULE__graph_index_mjs_4e5a8d12__ as Graph, __WEBPACK_EXTERNAL_MODULE__loader_mjs_ab87ced3__ as Loader, __WEBPACK_EXTERNAL_MODULE__lodash_mjs_5081b560__ as Lodash, __WEBPACK_EXTERNAL_MODULE__manifest_mjs_2d750078__ as Manifest, __WEBPACK_EXTERNAL_MODULE__package_mjs_f12bd493__ as Package, __WEBPACK_EXTERNAL_MODULE__plugin_mjs_ee4957f9__ as Plugin, __WEBPACK_EXTERNAL_MODULE__resolver_mjs_24d6f61e__ as Resolver, __WEBPACK_EXTERNAL_MODULE__rspack_mjs_fb7d03b6__ as Rspack, __WEBPACK_EXTERNAL_MODULE__summary_mjs_54f58833__ as Summary, __WEBPACK_EXTERNAL_MODULE__time_mjs_7d968bf1__ as Time, __WEBPACK_EXTERNAL_MODULE__url_mjs_0b48a1db__ as Url };

package/dist/esm/common/loader.mjs

@@ -0,0 +1,247 @@
+import { mergeIntervals } from "./algorithm.mjs";
+function findLoaderTotalTiming(loaders) {
+    let start = 1 / 0;
+    let end = -1 / 0;
+    for(let i = 0; i < loaders.length; i++){
+        const loader = loaders[i];
+        if (loader.startAt <= start) start = loader.startAt;
+        if (loader.endAt >= end) end = loader.endAt;
+    }
+    return {
+        start,
+        end
+    };
+}
+function getLoadersCosts(filter, loaders) {
+    const match = {};
+    const others = {};
+    loaders.forEach((e)=>{
+        if (filter(e)) {
+            if (!match[e.pid]) match[e.pid] = [];
+            match[e.pid].push([
+                e.startAt,
+                e.endAt
+            ]);
+        } else {
+            if (!others[e.pid]) others[e.pid] = [];
+            others[e.pid].push([
+                e.startAt,
+                e.endAt
+            ]);
+        }
+    });
+    let costs = 0;
+    const pids = Object.keys(match);
+    for(let i = 0; i < pids.length; i++){
+        const pid = pids[i];
+        const _match = mergeIntervals(match[pid]);
+        const _others = mergeIntervals(others[pid] || []).filter(([s, e])=>_match.some((el)=>s >= el[0] && e <= el[1]));
+        const matchSum = _match.length ? _match.reduce((t, c)=>t += c[1] - c[0], 0) : 0;
+        const othersSum = _others.length ? _others.reduce((t, c)=>t += c[1] - c[0], 0) : 0;
+        costs += matchSum - othersSum;
+    }
+    return costs;
+}
+function getLoaderCosts(loader, loaders) {
+    const blocked = loaders.filter((e)=>{
+        if (e.loader.includes('builtin')) return false;
+        if (e !== loader && e.pid === loader.pid) {
+            if (e.startAt >= loader.startAt) {
+                if (e.endAt <= loader.endAt) return true;
+            }
+        }
+        return false;
+    });
+    let costs = loader.endAt - loader.startAt;
+    if (blocked.length) {
+        const intervals = blocked.map((e)=>[
+                Math.max(e.startAt, loader.startAt),
+                Math.min(e.endAt, loader.endAt)
+            ]);
+        mergeIntervals(intervals).forEach((e)=>{
+            const sub = e[1] - e[0];
+            costs -= sub;
+        });
+    }
+    return costs;
+}
+function getLoaderNames(loaders) {
+    const names = new Set();
+    loaders.forEach((e)=>e.loaders.forEach((l)=>names.add(getLoadrName(l.loader))));
+    return [
+        ...names
+    ];
+}
+function getLoadersTransformData(loaders) {
+    const res = [];
+    for(let i = 0; i < loaders.length; i++){
+        const item = loaders[i];
+        for(let j = 0; j < item.loaders.length; j++){
+            const loader = item.loaders[j];
+            res.push(loader);
+        }
+    }
+    return res;
+}
+function getLoaderChartData(loaders) {
+    const res = [];
+    const list = getLoadersTransformData(loaders);
+    loaders.forEach((item)=>{
+        item.loaders.forEach((el)=>{
+            res.push({
+                layer: item.resource.layer,
+                loader: getLoadrName(el.loader),
+                isPitch: el.isPitch,
+                startAt: el.startAt,
+                endAt: el.endAt,
+                pid: el.pid,
+                sync: el.sync,
+                resource: item.resource.path,
+                costs: getLoaderCosts(el, list)
+            });
+        });
+    });
+    return res;
+}
+function getLoaderFileTree(loaders) {
+    const list = getLoadersTransformData(loaders);
+    return loaders.map((data)=>{
+        const { loaders: arr, resource } = data;
+        return {
+            path: resource.path,
+            layer: resource.layer,
+            loaders: arr.map((l)=>({
+                    key: l.path,
+                    loader: getLoadrName(l.loader),
+                    path: l.path,
+                    errors: l.errors,
+                    costs: getLoaderCosts(l, list)
+                }))
+        };
+    });
+}
+function getLoaderFileDetails(path, loaders) {
+    const data = loaders.find((e)=>e.resource.path === path);
+    if (!data) throw new Error(`"${path}" not match any loader data`);
+    const list = getLoadersTransformData(loaders);
+    return {
+        ...data,
+        loaders: data.loaders.map((el)=>({
+                ...el,
+                loader: getLoadrName(el.loader),
+                costs: getLoaderCosts(el, list)
+            }))
+    };
+}
+function getLoaderFolderStatistics(folder, loaders) {
+    const datas = loaders.filter((data)=>{
+        const { path } = data.resource;
+        return path.startsWith(folder);
+    });
+    const filteredLoaders = [];
+    const uniqueLoaders = new Map();
+    datas.forEach((data)=>{
+        data.loaders.forEach((fl)=>{
+            const uniqueLoader = uniqueLoaders.get(fl.loader);
+            if (uniqueLoader) uniqueLoaders.set(fl.loader, {
+                files: uniqueLoader.files + 1,
+                path: fl.path
+            });
+            else uniqueLoaders.set(fl.loader, {
+                files: 1,
+                path: fl.path
+            });
+            return filteredLoaders.push({
+                loader: fl.loader,
+                startAt: fl.startAt,
+                endAt: fl.endAt,
+                pid: fl.pid
+            });
+        });
+    });
+    const loaderCosts = Array.from(uniqueLoaders).map((uniqueLoader)=>{
+        const filter = (l)=>l.loader === uniqueLoader[0];
+        const costs = getLoadersCosts(filter, filteredLoaders);
+        return {
+            loader: uniqueLoader[0],
+            files: uniqueLoader[1].files,
+            path: uniqueLoader[1].path,
+            costs
+        };
+    });
+    return loaderCosts;
+}
+function collectResourceDirectories(loaders, root) {
+    const directories = new Set();
+    loaders.forEach((item)=>{
+        if (item.resource.path.startsWith(root)) {
+            const pathParts = item.resource.path.split(root).slice(1).join('/').split('/');
+            if (pathParts.length >= 2) {
+                const twoLevelDir = pathParts.slice(0, 2).join('/');
+                directories.add(`${root}/${twoLevelDir}`);
+            }
+        } else {
+            const pathParts = item.resource.path.split('/');
+            const twoLevelDir = pathParts.slice(0, pathParts.length - 1).join('/');
+            directories.add(twoLevelDir);
+        }
+    });
+    return Array.from(directories);
+}
+function getDirectoriesLoaders(loaders, root) {
+    const rootPath = root || process.cwd();
+    const directories = collectResourceDirectories(loaders, rootPath);
+    return directories.map((directory)=>{
+        const stats = getLoaderFolderStatistics(directory, loaders);
+        return {
+            directory,
+            stats
+        };
+    });
+}
+function getLoaderFileFirstInput(file, loaders) {
+    for(let i = 0; i < loaders.length; i++){
+        const item = loaders[i];
+        if (item.resource.path === file) {
+            const nonPitchLoaders = item.loaders.filter((e)=>!e.isPitch);
+            if (!nonPitchLoaders.length) return '';
+            return nonPitchLoaders[0].input || '';
+        }
+    }
+    return '';
+}
+function getLoaderFileInputAndOutput(file, loader, loaderIndex, loaders) {
+    for(let i = 0; i < loaders.length; i++){
+        const item = loaders[i];
+        if (item.resource.path === file) for(let j = 0; j < item.loaders.length; j++){
+            const l = item.loaders[j];
+            if (l.loader === loader && l.loaderIndex === loaderIndex) return {
+                input: l.input || '',
+                output: l.result || ''
+            };
+            return {
+                input: '',
+                output: ''
+            };
+        }
+    }
+    return {
+        input: '',
+        output: ''
+    };
+}
+const LoaderInternalPropertyName = '__l__';
+const isVue = (compiler)=>{
+    const rules = 'module' in compiler.options && compiler.options.module.rules || [];
+    const hasVueRule = rules.some((rule)=>{
+        var _rule_test;
+        if (rule && 'object' == typeof rule && rule.test instanceof RegExp && (null == (_rule_test = rule.test) ? void 0 : _rule_test.test('.vue'))) return true;
+        return false;
+    });
+    return hasVueRule;
+};
+const getLoadrName = (loader)=>{
+    const regResults = loader.includes('node_modules') ? loader.split('node_modules') : null;
+    return regResults ? regResults[regResults.length - 1] : loader;
+};
+export { LoaderInternalPropertyName, findLoaderTotalTiming, getDirectoriesLoaders, getLoaderChartData, getLoaderCosts, getLoaderFileDetails, getLoaderFileFirstInput, getLoaderFileInputAndOutput, getLoaderFileTree, getLoaderFolderStatistics, getLoaderNames, getLoadersCosts, getLoadersTransformData, isVue };

package/dist/esm/common/lodash.mjs

@@ -0,0 +1,32 @@
+function isUndefined(value) {
+    return void 0 === value;
+}
+function isNumber(value) {
+    return 'number' == typeof value && !Number.isNaN(value);
+}
+function isObject(value) {
+    return 'object' == typeof value && null !== value;
+}
+function isEmpty(value) {
+    return null == value || Array.isArray(value) && 0 === value.length || 'object' == typeof value && 0 === Object.keys(value).length;
+}
+function last(array) {
+    return array[array.length - 1];
+}
+function compact(array) {
+    return array.filter((item)=>null != item || !item);
+}
+function isNil(value) {
+    return null == value;
+}
+const isPlainObject = (obj)=>null !== obj && 'object' == typeof obj && Object.getPrototypeOf(obj) === Object.prototype;
+const isString = (v)=>'string' == typeof v || !!v && 'object' == typeof v && !Array.isArray(v) && '[object String]' === ({}).toString.call(v);
+function pick(obj, keys) {
+    const result = {};
+    for(let i = 0; i < keys.length; i++){
+        const key = keys[i];
+        if (Object.hasOwn(obj, key)) result[key] = obj[key];
+    }
+    return result;
+}
+export { compact, isEmpty, isNil, isNumber, isObject, isPlainObject, isString, isUndefined, last, pick };