@rsdoctor/graph 1.2.3 → 1.2.4-beta.1

package/dist/index.js

@@ -0,0 +1,1452 @@
+import { SDK } from "@rsdoctor/types";
+import { gzipSync as external_node_zlib_gzipSync } from "node:zlib";
+import path_0, { dirname, join, relative, resolve } from "path";
+import { File, Lodash, Package } from "@rsdoctor/utils/common";
+import lodash_unionby from "lodash.unionby";
+import { logger, time, timeEnd } from "@rsdoctor/utils/logger";
+import path_browserify from "path-browserify";
+var __webpack_require__ = {};
+__webpack_require__.d = (exports, definition)=>{
+    for(var key in definition)__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key) && Object.defineProperty(exports, key, {
+        enumerable: !0,
+        get: definition[key]
+    });
+}, __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop), __webpack_require__.r = (exports)=>{
+    'undefined' != typeof Symbol && Symbol.toStringTag && Object.defineProperty(exports, Symbol.toStringTag, {
+        value: 'Module'
+    }), Object.defineProperty(exports, '__esModule', {
+        value: !0
+    });
+};
+var chunks_namespaceObject = {};
+__webpack_require__.r(chunks_namespaceObject), __webpack_require__.d(chunks_namespaceObject, {
+    assetsContents: ()=>assetsContents,
+    chunkTransform: ()=>chunkTransform,
+    getAssetsModulesData: ()=>getAssetsModulesData,
+    transformAssetsModulesData: ()=>transformAssetsModulesData
+});
+var transform_module_graph_namespaceObject = {};
+__webpack_require__.r(transform_module_graph_namespaceObject), __webpack_require__.d(transform_module_graph_namespaceObject, {
+    getImportKind: ()=>getImportKind,
+    getModuleGraphByStats: ()=>getModuleGraphByStats,
+    getModulesFromArray: ()=>getModulesFromArray,
+    getPositionByStatsLocation: ()=>getPositionByStatsLocation,
+    isImportDependency: ()=>isImportDependency,
+    isWebpack5orRspack: ()=>isWebpack5orRspack,
+    removeNoImportStyle: ()=>removeNoImportStyle
+});
+var trans_utils_namespaceObject = {};
+__webpack_require__.r(trans_utils_namespaceObject), __webpack_require__.d(trans_utils_namespaceObject, {
+    transStats: ()=>transStats
+});
+var webpack_compatible_namespaceObject = {};
+__webpack_require__.r(webpack_compatible_namespaceObject), __webpack_require__.d(webpack_compatible_namespaceObject, {
+    getAllModules: ()=>getAllModules,
+    getDependencyPosition: ()=>getDependencyPosition,
+    getEntryModule: ()=>getEntryModule,
+    getExportDependency: ()=>getExportDependency,
+    getExportStatement: ()=>getExportStatement,
+    getLastExportInfo: ()=>getLastExportInfo,
+    getModuleSource: ()=>getModuleSource,
+    getResolveRequest: ()=>getResolveRequest,
+    getSdkDependencyByWebpackDependency: ()=>getSdkDependencyByWebpackDependency,
+    getWebpackDependencyRequest: ()=>getWebpackDependencyRequest,
+    getWebpackModuleId: ()=>getWebpackModuleId,
+    getWebpackModulePath: ()=>getWebpackModulePath,
+    isExternalModule: ()=>isExternalModule,
+    isNormalModule: ()=>isNormalModule
+});
+class Chunk {
+    constructor(id, name, size, initial, entry){
+        this._assets = [], this._modules = [], this._dependencies = [], this._imported = [], this.id = id, this.name = name, this.size = size, this.initial = initial, this.entry = entry;
+    }
+    isEntry() {
+        return this.entry;
+    }
+    isChunkEntryModule(module) {
+        return module.isEntry || module.getImported().every((item)=>!this.hasModule(item));
+    }
+    hasModule(module) {
+        return this._modules.includes(module);
+    }
+    addModule(module) {
+        this.hasModule(module) || (this._modules.push(module), module.addChunk(this));
+    }
+    addAsset(asset) {
+        this._assets.push(asset);
+    }
+    addModules(modules) {
+        modules.forEach((module)=>{
+            this.hasModule(module) || (this._modules.push(module), module.addChunk(this));
+        });
+    }
+    addDependency(dep) {
+        this._dependencies.includes(dep) || this._dependencies.push(dep);
+    }
+    addImported(imported) {
+        this._imported.includes(imported) || this._imported.push(imported);
+    }
+    getAssets() {
+        return this._assets.slice();
+    }
+    getModules() {
+        return this._modules.slice();
+    }
+    getDependencies() {
+        return this._dependencies.slice();
+    }
+    getImported() {
+        return this._imported.slice();
+    }
+    setParsedSize(parsedSize) {
+        this._parsedSize = parsedSize;
+    }
+    toData() {
+        return {
+            id: this.id,
+            name: this.name,
+            initial: this.initial,
+            size: this.size,
+            parsedSize: this._parsedSize || 0,
+            entry: this.isEntry(),
+            assets: this._assets.map(({ path })=>path),
+            modules: this._modules.map(({ id })=>id),
+            dependencies: this._dependencies.map(({ id })=>id),
+            imported: this._imported.map(({ id })=>id)
+        };
+    }
+    setDependencies(dependencies) {
+        this._dependencies = dependencies;
+    }
+    setImported(imported) {
+        this._imported = imported;
+    }
+    setModules(modules) {
+        this._modules = modules;
+    }
+    setAssets(assets) {
+        this._assets = assets;
+    }
+}
+class ChunkGraph {
+    getAssets() {
+        return Array.from(this._assetMap.values());
+    }
+    getChunks() {
+        return Array.from(this._chunkMap.values());
+    }
+    addAsset(...assets) {
+        assets.forEach((asset)=>{
+            this._assetMap.set(asset.id, asset), this._assetPathMap.set(asset.path, asset);
+        });
+    }
+    addChunk(...chunks) {
+        chunks.forEach((chunk)=>{
+            this._chunkMap.set(chunk.id, chunk);
+        });
+    }
+    getChunkById(id) {
+        return this._chunkMap.get(id);
+    }
+    getAssetByPath(path) {
+        return this._assetPathMap.get(path);
+    }
+    getAssetById(id) {
+        return this._assetMap.get(id);
+    }
+    getEntryPoints() {
+        return Array.from(this._entrypointMap.values());
+    }
+    getEntryPointById(id) {
+        return this._entrypointMap.get(id);
+    }
+    addEntryPoint(...entrypoints) {
+        entrypoints.forEach((entrypoint)=>{
+            this._entrypointMap.set(entrypoint.id, entrypoint);
+        });
+    }
+    toData(type) {
+        return {
+            assets: Array.from(this._assetMap.values()).map((item)=>item.toData(type)),
+            chunks: Array.from(this._chunkMap.values()).map((item)=>item.toData()),
+            entrypoints: Array.from(this._entrypointMap.values()).map((item)=>item.toData())
+        };
+    }
+    setChunks(chunks) {
+        this._chunkMap = new Map(chunks.map((item)=>[
+                item.id,
+                item
+            ]));
+    }
+    setEntrypoints(entrypoints) {
+        this._entrypointMap = new Map(entrypoints.map((item)=>[
+                item.id,
+                item
+            ]));
+    }
+    setAssets(assets) {
+        this._assetMap = new Map(assets.map((item)=>[
+                item.id,
+                item
+            ])), this._assetPathMap = new Map(assets.map((item)=>[
+                item.path,
+                item
+            ]));
+    }
+    constructor(){
+        this._assetMap = new Map(), this._assetPathMap = new Map(), this._chunkMap = new Map(), this._entrypointMap = new Map();
+    }
+}
+let asset_id = 1;
+class Asset {
+    static init() {
+        asset_id = 1;
+    }
+    constructor(path, size, chunks, content){
+        this.id = asset_id++, this.path = path, this.size = size, this.chunks = chunks, this.content = content;
+    }
+    toData(types) {
+        return {
+            id: this.id,
+            path: this.path,
+            size: this.size,
+            gzipSize: this.gzipSize,
+            chunks: this.chunks?.map((ck)=>ck.id),
+            content: types === SDK.ToDataType.NoSourceAndAssets || types === SDK.ToDataType.NoCode ? '' : this.content
+        };
+    }
+    setChunks(chunks) {
+        this.chunks = chunks;
+    }
+    setId(id) {
+        this.id = id;
+    }
+    setGzipSize(content) {
+        this.gzipSize = external_node_zlib_gzipSync(content, {
+            level: 9
+        }).length;
+    }
+}
+let entrypoint_id = 1;
+class EntryPoint {
+    static init() {
+        entrypoint_id = 1;
+    }
+    constructor(name){
+        this.name = name, this._chunks = [], this._assets = [], this.id = entrypoint_id++;
+    }
+    addChunk(chunk) {
+        this._chunks.includes(chunk) || this._chunks.push(chunk);
+    }
+    addAsset(asset) {
+        this._assets.includes(asset) || this._assets.push(asset);
+    }
+    toData() {
+        return {
+            id: this.id,
+            name: this.name,
+            chunks: this._chunks.map((e)=>e.id),
+            assets: this._assets.map((e)=>e.path),
+            size: this._assets.length ? this._assets.reduce((t, e)=>t + e.size, 0) : 0
+        };
+    }
+    setChunks(chunks) {
+        this._chunks = chunks;
+    }
+    setAssets(assets) {
+        this._assets = assets;
+    }
+    setId(id) {
+        this.id = id;
+    }
+}
+let dependency_id = 1;
+class Dependency {
+    static{
+        this.kind = SDK.DependencyKind;
+    }
+    static init() {
+        dependency_id = 1;
+    }
+    constructor(request, module, dependency, kind, statements){
+        this.statements = [], this.meta = {
+            exportsType: 'default-with-named'
+        }, this.id = dependency_id++, this.request = request, this.module = module, this._originDependency = dependency, this.kind = kind, this.statements = statements ?? [];
+    }
+    get resolvedRequest() {
+        return this.dependency.path;
+    }
+    get dependency() {
+        return this.originDependency.rootModule ?? this.originDependency;
+    }
+    get originDependency() {
+        return this._originDependency;
+    }
+    get kindString() {
+        return SDK.DependencyKind[this.kind];
+    }
+    get resolveConcatenationModule() {
+        return this.dependency.kind === SDK.ModuleKind.Concatenation;
+    }
+    isSameWithoutStatements(dep) {
+        return this.request === dep.request && this.kind === dep.kind && this.module.id === dep.module.id && this.dependency.id === dep.dependency.id;
+    }
+    addStatement(statement) {
+        this.hasStatement(statement) || this.statements.push(statement);
+    }
+    hasStatement(statement) {
+        return this.statements.some((item)=>item.isSame(statement));
+    }
+    setBuildMeta(data) {
+        this.meta = {
+            ...this.meta,
+            ...data
+        };
+    }
+    toData() {
+        return {
+            id: this.id,
+            request: this.request,
+            resolvedRequest: this.resolvedRequest,
+            kind: this.kind,
+            module: this.module.id,
+            dependency: this.dependency.id,
+            originDependency: this.originDependency.id,
+            statements: this.statements.map((item)=>item.toData())
+        };
+    }
+    setId(id) {
+        this.id = id;
+    }
+}
+function isSamePosition(po1, po2) {
+    return po1.line === po2.line && po1.column === po2.column;
+}
+let NAME_WITH_LOADERS = /!/, NAME_WITH_MODULES = /\s\+\s\d*\smodules$/, INVALID_CSS_PREFIX = /^css\s.*node_modules(?!\/)/;
+class Statement {
+    static getDefaultStatement(module) {
+        let defaultPosition = {
+            line: 1,
+            column: 0
+        }, defaultRange = {
+            start: {
+                ...defaultPosition
+            },
+            end: {
+                ...defaultPosition
+            }
+        };
+        return new Statement(module, {
+            source: {
+                ...defaultRange
+            },
+            transformed: {
+                ...defaultRange
+            }
+        });
+    }
+    constructor(module, position){
+        this.module = module, this.position = position;
+    }
+    isSame(statement) {
+        var po1, po2;
+        return this.module.id === statement.module.id && (po1 = this.position.transformed, po2 = statement.position.transformed, !!isSamePosition(po1.start, po2.start) && (Lodash.isNil(po1.end) || Lodash.isNil(po2.end) ? Lodash.isUndefined(po1.end) && Lodash.isUndefined(po2.end) : isSamePosition(po1.end, po2.end)));
+    }
+    getSourcePosition() {
+        let { module, position } = this;
+        return position.source ? position.source : module.getSourceMap() ? (position.source = module.getSourceRange(position.transformed), position.source) : void 0;
+    }
+    getLineCode() {
+        let useSource = this.module.isPreferSource && this.position.source, sourceCode = this.module.getSource(), source = useSource ? sourceCode.source : sourceCode.transformed, line = useSource ? this.position.source.start.line : this.position.transformed.start.line;
+        if ('number' == typeof line) return source.split('\n')[line - 1];
+    }
+    toData() {
+        let position = {
+            transformed: this.position.transformed
+        };
+        return this.position.source && (position.source = this.position.source), {
+            position,
+            module: this.module.id
+        };
+    }
+}
+let module_id = 1;
+class Module {
+    static{
+        this.kind = SDK.ModuleKind;
+    }
+    static init() {
+        module_id = 1;
+    }
+    constructor(webpackId, path, isEntry = !1, kind = SDK.ModuleKind.Normal, renderId, layer = ''){
+        this.issuerPath = [], this.bailoutReason = [], this.source = {
+            source: '',
+            transformed: '',
+            parsedSource: ''
+        }, this.size = {
+            sourceSize: 0,
+            transformedSize: 0,
+            parsedSize: 0,
+            gzipSize: 0
+        }, this.chunks = [], this.dependencies = [], this.imported = [], this.modules = [], this.concatenationModules = [], this.meta = {
+            hasSetEsModuleStatement: !1,
+            strictHarmonyModule: !1
+        }, this.id = module_id++, this.webpackId = webpackId, this.path = path, this.isEntry = isEntry, this.kind = kind, this.renderId = renderId, this.layer = layer;
+    }
+    get rootModule() {
+        return this.modules.find((item)=>item.path === this.path);
+    }
+    get isPreferSource() {
+        if ('boolean' == typeof this._isPreferSource) return this._isPreferSource;
+        let result = this.source.source.length > 0 && 'test code' !== this.source.source && !!this.sourceMap;
+        return this._isPreferSource = result, result;
+    }
+    addBailoutReason(reason) {
+        this.bailoutReason.push(reason);
+    }
+    getBailoutReason() {
+        return this.bailoutReason;
+    }
+    getChunks() {
+        return this.chunks.slice();
+    }
+    addChunk(chunk) {
+        this.chunks.includes(chunk) || (this.chunks.push(chunk), chunk.addModule(this));
+    }
+    removeChunk(chunk) {
+        this.chunks = this.chunks.filter((item)=>item !== chunk);
+    }
+    getDependencies() {
+        return this.dependencies.slice();
+    }
+    getDependencyByRequest(request) {
+        return this.dependencies.find((item)=>item.request === request);
+    }
+    getDependencyByModule(module) {
+        return this.dependencies.find((item)=>item.originDependency === module || item.dependency === module);
+    }
+    addDependency(request, module, kind, statements) {
+        let dep = new Dependency(request, this, module, kind, statements);
+        if (this.dependencies.every((item)=>!item.isSameWithoutStatements(dep))) return this.dependencies.push(dep), module.addImported(this), module.rootModule && module.rootModule.addImported(this), dep;
+    }
+    removeDependency(dep) {
+        this.dependencies = this.dependencies.filter((item)=>item === dep);
+    }
+    removeDependencyByModule(module) {
+        let dep = this.getDependencyByModule(module);
+        dep && this.removeDependency(dep);
+    }
+    getImported() {
+        return this.imported.slice();
+    }
+    addImported(module) {
+        this.imported.includes(module) || this.imported.push(module);
+    }
+    removeImported(module) {
+        this.imported = this.imported.filter((item)=>item === module);
+    }
+    setProgram(program) {
+        this.program = program;
+    }
+    getProgram() {
+        return this.program;
+    }
+    setSource(input) {
+        let { source } = this;
+        source.source = input.source ?? source.source, source.transformed = input.transformed ?? source.transformed, source.parsedSource = input.parsedSource ?? source.parsedSource;
+    }
+    getSource(type = SDK.ToDataType.Normal) {
+        return type === SDK.ToDataType.NoCode ? {
+            source: '',
+            transformed: '',
+            parsedSource: ''
+        } : type === SDK.ToDataType.NoSourceAndAssets || type === SDK.ToDataType.NoSource ? {
+            source: '',
+            transformed: '',
+            parsedSource: this.isPreferSource ? '' : this.source.parsedSource
+        } : type === SDK.ToDataType.All ? {
+            source: this.source.source,
+            transformed: this.source.transformed,
+            parsedSource: this.isPreferSource ? '' : this.source.parsedSource
+        } : {
+            source: this.source.source,
+            transformed: '',
+            parsedSource: this.isPreferSource ? '' : this.source.parsedSource
+        };
+    }
+    setSourceMap(sourceMap) {
+        this.sourceMap = sourceMap;
+    }
+    getSourceMap() {
+        return this.sourceMap;
+    }
+    setSize(input) {
+        let { size } = this;
+        if (size.sourceSize = input.sourceSize ?? size.sourceSize, size.transformedSize = input.transformedSize ?? size.transformedSize, size.parsedSize = input.parsedSize ?? size.parsedSize, 'number' == typeof input.gzipSize) size.gzipSize = input.gzipSize;
+        else {
+            let code = this.source.parsedSource || this.source.source;
+            if (code && 'string' == typeof code && code.length > 0) try {
+                size.gzipSize = external_node_zlib_gzipSync(code, {
+                    level: 9
+                }).length;
+            } catch (e) {
+                size.gzipSize = 0;
+            }
+        }
+    }
+    getSize() {
+        return {
+            ...this.size
+        };
+    }
+    getStatement(transformed) {
+        return new Statement(this, {
+            source: this.getSourceRange(transformed),
+            transformed: {
+                start: {
+                    ...transformed.start
+                },
+                end: transformed.end ? {
+                    ...transformed.end
+                } : void 0
+            }
+        });
+    }
+    getSourceRange(transformed) {
+        let { sourceMap } = this;
+        if (!sourceMap) return;
+        let source = {
+            start: {}
+        }, startInSource = sourceMap.originalPositionFor({
+            line: transformed.start.line ?? 0,
+            column: transformed.start.column ?? 0,
+            bias: 1
+        });
+        if (Lodash.isNumber(startInSource.line) && (source.start = {
+            line: startInSource.line,
+            column: startInSource.column ?? void 0
+        }), transformed.end) {
+            let endInSource = sourceMap.originalPositionFor({
+                line: transformed.end.line ?? 0,
+                column: transformed.end.column ?? 0
+            });
+            Lodash.isNumber(endInSource.line) && (source.end = {
+                line: endInSource.line,
+                column: endInSource.column ?? void 0
+            });
+        }
+        return source;
+    }
+    addNormalModule(module) {
+        this.modules.includes(module) || (this.modules.push(module), module.addConcatenationModule(this));
+    }
+    getNormalModules() {
+        return this.modules.slice();
+    }
+    addConcatenationModule(module) {
+        this.concatenationModules.includes(module) || this.concatenationModules.push(module);
+    }
+    addIssuerPath(issuerPath) {
+        this.issuerPath?.length || (this.issuerPath = issuerPath);
+    }
+    getIssuerPath() {
+        return this.issuerPath;
+    }
+    getConcatenationModules() {
+        return this.concatenationModules.slice();
+    }
+    toData(contextPath, isBrief) {
+        let { isPreferSource } = this, moduleName = function(name) {
+            if (!name) return '';
+            if (NAME_WITH_LOADERS.test(name)) {
+                let normalizedName = Lodash.last(name.split(NAME_WITH_LOADERS));
+                if (normalizedName?.trim()) return normalizedName;
+            }
+            return NAME_WITH_MODULES.test(name) ? name.replace(NAME_WITH_MODULES, '') : INVALID_CSS_PREFIX.test(name) ? name.replace(INVALID_CSS_PREFIX, '') : name;
+        }(this.webpackId), data = {
+            id: this.id,
+            renderId: this.renderId,
+            webpackId: contextPath && moduleName.indexOf('.') > 0 ? path_0.relative(contextPath, moduleName) : this.webpackId,
+            path: this.path,
+            isPreferSource,
+            dependencies: this.dependencies.map((item)=>item.id),
+            imported: this.imported.map((item)=>item.id),
+            chunks: this.chunks.map((item)=>item.id),
+            size: this.getSize(),
+            kind: this.kind,
+            ...this.layer ? {
+                layer: this.layer
+            } : {},
+            issuerPath: isBrief ? void 0 : this.issuerPath?.filter((issuer)=>issuer.moduleId).map((issuer)=>issuer.moduleId) || [],
+            bailoutReason: isBrief ? void 0 : this.bailoutReason
+        };
+        return (this.meta.hasSetEsModuleStatement || this.meta.strictHarmonyModule) && (data.meta = {}, this.meta.hasSetEsModuleStatement && (data.meta.hasSetEsModuleStatement = !0), this.meta.strictHarmonyModule && (data.meta.strictHarmonyModule = !0)), this.isEntry && (data.isEntry = this.isEntry), this.modules.length > 0 && (data.modules = this.modules.map((item)=>item.id)), this.rootModule && (data.rootModule = this.rootModule.id), this.concatenationModules.length > 0 && (data.concatenationModules = this.concatenationModules.map((data)=>data.id)), data;
+    }
+    setId(id) {
+        this.id = id;
+    }
+    setRenderId(renderId) {
+        this.renderId = renderId;
+    }
+    setChunks(chunks) {
+        this.chunks = chunks;
+    }
+    setDependencies(dependencies) {
+        this.dependencies = dependencies;
+    }
+    setImported(imported) {
+        this.imported = imported;
+    }
+    setModules(modules) {
+        this.modules = modules;
+    }
+    setConcatenationModules(modules) {
+        this.concatenationModules = modules;
+    }
+}
+let export_id = 1;
+class ExportInfo {
+    static init() {
+        export_id = 1;
+    }
+    constructor(name, identifier, variable){
+        this.id = export_id++, this._sideEffects = [], this.name = name, this.identifier = identifier, this._variable = variable;
+    }
+    get isReExport() {
+        return !!this.from;
+    }
+    set variable(data) {
+        this._variable = data;
+    }
+    get variable() {
+        if (this._variable) return this._variable;
+        if (!this.from || !1 === this._variable) {
+            this._variable = !1;
+            return;
+        }
+        let result = this.getRecursiveExport()?.variable;
+        return result || (this._variable = !1), result;
+    }
+    addSideEffect(info) {
+        this._sideEffects.every((item)=>item.id !== info.id) && (this._sideEffects.push(info), this.from && this.from.addSideEffect(info));
+    }
+    getSideEffects() {
+        return this._sideEffects.slice();
+    }
+    setFromExport(from) {
+        this.from = from;
+    }
+    getRecursiveExport(depth = 1 / 0) {
+        if (0 === depth) throw Error('`getRecursiveExport` method parameter depth must be greater than 1.');
+        if (!this.from) return this;
+        let currentDepth = 0, current = this;
+        for(; current.from && currentDepth < depth;)currentDepth++, current = current.from;
+        return current;
+    }
+    toData() {
+        let data = {
+            id: this.id,
+            name: this.name,
+            isReExport: this.isReExport,
+            used: this._sideEffects.map((item)=>item.id)
+        };
+        return this.from && (data.from = this.from.id, data.root = this.getRecursiveExport().id), this.variable && (data.variable = this.variable.id), data;
+    }
+}
+let sideEffect_id = 1;
+class SideEffect {
+    static init() {
+        sideEffect_id = 1;
+    }
+    static{
+        this.NamespaceSymbol = Symbol('namespace');
+    }
+    constructor(name, module, identifier, fromRequest, originName){
+        this.id = sideEffect_id++, this._exports = [], this.name = name, this.module = module, this.identifier = identifier, fromRequest && (this.fromDependency = this.module.getDependencyByRequest(fromRequest)), originName === SideEffect.NamespaceSymbol ? this.isNameSpace = !0 : (this.isNameSpace = !1, this.originName = originName);
+    }
+    get variable() {
+        if (void 0 !== this._variable) return this._variable ? this._variable : void 0;
+        let result = this.exports[0]?.getRecursiveExport()?.variable;
+        return this._variable = result ?? !1, result;
+    }
+    get exports() {
+        return this._exports?.slice() ?? [];
+    }
+    setModuleExport(mgm) {
+        mgm.getExports().forEach((info)=>this.setExportInfo(info));
+    }
+    setExportInfo(info) {
+        this._exports.push(info), info.addSideEffect(this);
+    }
+    toData() {
+        let data = {
+            id: this.id,
+            name: this.name,
+            identifier: this.identifier.toData(),
+            module: this.module.id
+        };
+        return this.fromDependency && (data.fromDependency = this.fromDependency.id), this.isNameSpace && (data.isNameSpace = this.isNameSpace), this.exports.length > 0 && (data.exports = this.exports.map((item)=>item.id)), this.variable && (data.variable = this.variable.id), data;
+    }
+}
+let variable_id = 1;
+class Variable {
+    static init() {
+        variable_id = 1;
+    }
+    constructor(name, module, usedInfo, identifier){
+        this.id = variable_id++, this.name = name, this.module = module, this.usedInfo = usedInfo, this.identifier = identifier;
+    }
+    get isUsed() {
+        return !!this._exported && this._exported.getSideEffects().length > 0;
+    }
+    setExportInfo(info) {
+        this._exported = info, info.variable = this;
+    }
+    getExportInfo() {
+        return this._exported;
+    }
+    toData() {
+        let data = {
+            id: this.id,
+            name: this.name,
+            module: this.module.id,
+            identifier: this.identifier.toData(),
+            usedInfo: this.usedInfo
+        };
+        return this._exported && (data.exported = this._exported.id), data;
+    }
+}
+class ModuleGraphModule {
+    static init() {
+        ExportInfo.init(), SideEffect.init(), Variable.init();
+    }
+    constructor(module, graph, dynamic){
+        this.exports = [], this.sideEffects = [], this.variables = [], this.module = module, this._graph = graph, 'boolean' == typeof this._dynamic && (this._dynamic = dynamic);
+    }
+    get dynamic() {
+        return 'boolean' == typeof this._dynamic ? this._dynamic : this.module.getImported().map((item)=>item.getDependencyByModule(this.module)).some((item)=>item && 'dynamic' === item.meta.exportsType);
+    }
+    addExportInfo(data) {
+        this.exports.push(data), this._graph.addExportInfo(data);
+    }
+    addSideEffect(data) {
+        this.sideEffects.push(data), this._graph.addSideEffect(data);
+    }
+    addVariable(data) {
+        this.variables.push(data), this._graph.addVariable(data);
+    }
+    getExports() {
+        return this.exports.slice();
+    }
+    getSideEffects(name) {
+        return name ? this.sideEffects.filter((item)=>item.name === name) : this.sideEffects.slice();
+    }
+    getOwnExports() {
+        return this.exports.filter((item)=>!item.isReExport);
+    }
+    getExport(name) {
+        return this.exports.find((item)=>item.name === name);
+    }
+    getReExports() {
+        return this.exports.filter((item)=>item.isReExport);
+    }
+    getOwnExport(name) {
+        return this.getOwnExports().find((item)=>item.name === name);
+    }
+    getReExport(name) {
+        return this.getReExports().find((item)=>item.name === name);
+    }
+    toData() {
+        return {
+            module: this.module.id,
+            dynamic: this.dynamic,
+            exports: this.exports.map((item)=>item.id),
+            sideEffects: this.sideEffects.map((item)=>item.id),
+            variables: this.variables.map((item)=>item.id)
+        };
+    }
+}
+class ModuleGraph {
+    static init() {
+        Module.init(), Dependency.init(), ModuleGraphModule.init();
+    }
+    static fromData(data) {
+        let moduleGraph = new ModuleGraph(), getStatement = (data)=>new Statement(moduleGraph.getModuleById(data.module), data.position);
+        for (let item of data.modules ?? []){
+            let module = new Module(String(item.id), item.path, item.isEntry, item.kind, item.renderId, item.layer);
+            module.id = item.id, module.setSize(item.size), module.meta = {
+                strictHarmonyModule: item.meta?.strictHarmonyModule ?? !1,
+                hasSetEsModuleStatement: item.meta?.hasSetEsModuleStatement ?? !1
+            }, module._isPreferSource = item.isPreferSource, module.chunks = item.chunks, moduleGraph.addModule(module);
+        }
+        for (let moduleData of data.modules ?? []){
+            let module = moduleGraph.getModuleById(moduleData.id);
+            for (let depId of moduleData.dependencies){
+                let depData = (data.dependencies ?? []).find((item)=>item.id === depId), depModule = depData && moduleGraph.getModuleById(depData.originDependency);
+                if (!depData || !depModule) {
+                    console.warn(`The connection data ID is empty: ${depId}`);
+                    continue;
+                }
+                let dep = module.addDependency(depData.request, depModule, depData.kind, depData.statements.map(getStatement));
+                dep && (dep.id = depData.id, moduleGraph.addDependency(dep));
+            }
+            for (let normalModuleId of moduleData.modules ?? []){
+                let normalModule = moduleGraph.getModuleById(normalModuleId);
+                if (!normalModule) {
+                    console.warn(`Add the ordinary module ID as empty: ${normalModuleId}`);
+                    continue;
+                }
+                module.addNormalModule(normalModule);
+            }
+            for (let concatenationModuleId of moduleData.concatenationModules ?? []){
+                let concatenationModule = moduleGraph.getModuleById(concatenationModuleId);
+                if (!concatenationModule) {
+                    console.warn(`The aggregation module ID is empty: ${concatenationModule}`);
+                    continue;
+                }
+                module.addConcatenationModule(concatenationModule);
+            }
+        }
+        for (let exportData of data.exports ?? []){
+            let info = new ExportInfo(exportData.name, exportData.identifier ? getStatement(exportData.identifier) : void 0);
+            info.id = exportData.id, moduleGraph.addExportInfo(info);
+        }
+        for (let exportData of data.exports ?? [])if (exportData.from) {
+            let current = moduleGraph._exportIdMap.get(exportData.id), from = moduleGraph._exportIdMap.get(exportData.from);
+            current && from && current.setFromExport(from);
+        }
+        for (let varData of data.variables ?? []){
+            let module = moduleGraph.getModuleById(varData.module);
+            if (!module) {
+                console.warn(`The module ID in the variable is empty\u{FF1A}${varData.module}`);
+                continue;
+            }
+            let info = new Variable(varData.name, module, varData.usedInfo, getStatement(varData.identifier)), exportInfo = moduleGraph._exportIdMap.get(varData.exported ?? -1);
+            exportInfo && info.setExportInfo(exportInfo), info.id = varData.id, moduleGraph.addVariable(info);
+        }
+        for (let sideData of data.sideEffects ?? []){
+            let module = moduleGraph.getModuleById(sideData.module);
+            if (!module) {
+                console.warn(`The module ID in the side effects is empty\u{FF1A}${sideData.module}`);
+                continue;
+            }
+            let info = new SideEffect(sideData.name, module, getStatement(sideData.identifier), sideData.originName);
+            for (let exportId of (info.isNameSpace = sideData.isNameSpace, info.id = sideData.id, sideData.exports ?? [])){
+                let exportInfo = moduleGraph._exportIdMap.get(exportId);
+                exportInfo && exportInfo.addSideEffect(info);
+            }
+            if (sideData.variable) {
+                let varInfo = moduleGraph._varIdMap.get(sideData.variable);
+                varInfo && (info._variable = varInfo);
+            }
+            moduleGraph.addSideEffect(info);
+        }
+        for (let mgmData of data.moduleGraphModules ?? []){
+            let module = moduleGraph.getModuleById(mgmData.module);
+            if (!module) {
+                console.warn(`The module ID in ModuleGraphModule is empty: ${mgmData.module}`);
+                continue;
+            }
+            let mgm = new ModuleGraphModule(module, moduleGraph, mgmData.dynamic);
+            moduleGraph.addModuleGraphModule(mgm), mgmData.exports.forEach((id)=>{
+                let info = moduleGraph._exportIdMap.get(id);
+                info && mgm.addExportInfo(info);
+            }), mgmData.sideEffects.forEach((id)=>{
+                let info = moduleGraph._sideEffectIdMap.get(id);
+                info && mgm.addSideEffect(info);
+            }), mgmData.variables.forEach((id)=>{
+                let info = moduleGraph._varIdMap.get(id);
+                info && mgm.addVariable(info);
+            });
+        }
+        return ModuleGraph.init(), moduleGraph;
+    }
+    clear() {
+        this._dependenciesIdMap = new Map(), this._moduleWebpackIdMap = new Map(), this._moduleIdMap = new Map(), this._moduleGraphModules = new Map(), this._exportIdMap = new Map(), this._sideEffectIdMap = new Map(), this._varIdMap = new Map(), this._layers = new Map();
+    }
+    size() {
+        return this._moduleIdMap.size;
+    }
+    fromInstance(data) {
+        this._dependenciesIdMap = new Map(data._dependenciesIdMap), this._moduleWebpackIdMap = new Map(data._moduleWebpackIdMap), this._moduleIdMap = new Map(data._moduleIdMap), this._moduleGraphModules = new Map(data._moduleGraphModules), this._exportIdMap = new Map(data._exportIdMap), this._sideEffectIdMap = new Map(data._sideEffectIdMap), this._varIdMap = new Map(data._varIdMap), this._layers = new Map(data._layers);
+    }
+    getSubGraphByModule(module) {
+        let map = new Set(), result = [
+            module
+        ];
+        map.add(module);
+        for(let i = 0; i < result.length; i++)for (let { dependency: depModule } of result[i].getDependencies())map.has(depModule) || (map.add(depModule), result.push(depModule));
+        return result;
+    }
+    getModules() {
+        return Array.from(this._moduleWebpackIdMap.values());
+    }
+    getDependencies() {
+        return Array.from(this._dependenciesIdMap.values());
+    }
+    getEntryModules() {
+        return this.getModules().filter((item)=>item.isEntry && item.kind !== SDK.ModuleKind.Concatenation);
+    }
+    getModuleById(id) {
+        return this._moduleIdMap.get(id);
+    }
+    getDependencyById(id) {
+        return this._dependenciesIdMap.get(id);
+    }
+    getModuleByWebpackId(id) {
+        return this._moduleWebpackIdMap.get(id);
+    }
+    getModuleByFile(file) {
+        return this.getModules().find((item)=>item.path === file);
+    }
+    addModule(...modules) {
+        for (let module of modules)!this._moduleIdMap.has(module.id) && (this._moduleWebpackIdMap.set(module.webpackId, module), this._moduleIdMap.set(module.id, module), module.layer && this.addLayer(module.layer));
+    }
+    addDependency(...deps) {
+        for (let dep of deps)this._dependenciesIdMap.has(dep.id) || (this._dependenciesIdMap.set(dep.id, dep), this.addModule(dep.module), this.addModule(dep.dependency));
+    }
+    removeModule(module) {
+        for (let dep of (this._moduleIdMap.delete(module.id), this._moduleWebpackIdMap.delete(module.webpackId), module.getDependencies()))this.removeDependency(dep), this._dependenciesIdMap.delete(dep.id);
+        for (let imported of module.getImported())imported.removeDependencyByModule(imported);
+    }
+    removeDependency(dep) {
+        dep.module.removeDependency(dep), dep.dependency.removeImported(dep.module), this._dependenciesIdMap.delete(dep.id);
+    }
+    addModuleGraphModule(mgm) {
+        this._moduleGraphModules.has(mgm.module) || this._moduleGraphModules.set(mgm.module, mgm);
+    }
+    getModuleGraphModule(module) {
+        return this._moduleGraphModules.get(module);
+    }
+    getModuleGraphModules() {
+        return Array.from(this._moduleGraphModules.values());
+    }
+    addExportInfo(data) {
+        this._exportIdMap.set(data.id, data);
+    }
+    addSideEffect(data) {
+        this._sideEffectIdMap.set(data.id, data);
+    }
+    addVariable(data) {
+        this._varIdMap.set(data.id, data);
+    }
+    addLayer(layer) {
+        this._layers.get(layer) || this._layers.set(layer, 1);
+    }
+    getLayers() {
+        return this._layers;
+    }
+    toData(configs) {
+        let isBrief = !!(configs?.briefOptions?.type && configs.briefOptions.type.length);
+        return {
+            dependencies: this.getDependencies().map((item)=>item.toData()),
+            modules: this.getModules().map((item)=>item.toData(configs?.contextPath, isBrief)),
+            moduleGraphModules: isBrief ? [] : Array.from(this._moduleGraphModules.values()).map((item)=>item.toData()),
+            exports: isBrief ? [] : Array.from(this._exportIdMap.values()).map((item)=>item.toData()),
+            sideEffects: isBrief ? [] : Array.from(this._sideEffectIdMap.values()).map((item)=>item.toData()),
+            variables: isBrief ? [] : Array.from(this._varIdMap.values()).map((item)=>item.toData()),
+            layers: Array.from(this._layers.keys())
+        };
+    }
+    toCodeData(type = SDK.ToDataType.Normal) {
+        let codeMap = {};
+        return this.getModules().forEach((item)=>{
+            codeMap[item.id] = item.getSource(type);
+        }), codeMap;
+    }
+    setModules(modules) {
+        this._moduleIdMap = new Map(modules.map((m)=>[
+                m.id,
+                m
+            ])), this._moduleWebpackIdMap = new Map(modules.map((m)=>[
+                m.webpackId,
+                m
+            ])), this._layers = new Map(modules.filter((m)=>m.layer).map((m)=>[
+                m.layer,
+                1
+            ]));
+    }
+    setDependencies(dependencies) {
+        this._dependenciesIdMap = new Map(dependencies.map((d)=>[
+                d.id,
+                d
+            ]));
+    }
+    constructor(){
+        this._dependenciesIdMap = new Map(), this._moduleWebpackIdMap = new Map(), this._moduleIdMap = new Map(), this._moduleGraphModules = new Map(), this._exportIdMap = new Map(), this._sideEffectIdMap = new Map(), this._varIdMap = new Map(), this._layers = new Map();
+    }
+}
+let package_graph_dependency_id = 1;
+class PackageDependency {
+    constructor(pack, dep, refDependency){
+        this.id = package_graph_dependency_id++, this.package = pack, this.dependency = dep, this.refDependency = refDependency;
+    }
+    get name() {
+        return this.dependency.name;
+    }
+    get version() {
+        return this.dependency.version;
+    }
+    get root() {
+        return this.dependency.root;
+    }
+    isSame(dep) {
+        return this.refDependency === dep.refDependency && this.dependency.isSame(dep.dependency);
+    }
+    toData() {
+        return {
+            id: this.id,
+            dependency: this.dependency.id,
+            package: this.package.id,
+            refDependency: this.refDependency.id
+        };
+    }
+}
+let readPackageJson = (file, readFile)=>{
+    let result, current = file;
+    for(; '/' !== current && !result && dirname(current) !== current;)current = dirname(current), readFile && (result = readFile(join(current, 'package.json'))), readFile ? result?.name || (result = void 0) : result = Package.getPackageMetaFromModulePath(file);
+    if (result) return !readFile || result.name && result.version ? {
+        ...result,
+        root: current
+    } : readPackageJson(dirname(current), readFile);
+}, package_id = 1;
+class package_Package {
+    constructor(name, root, version){
+        this.id = package_id++, this._modules = [], this._dependencies = [], this._imported = [], this.name = name, this.root = root, this.version = version, this.duplicates = [];
+    }
+    setDuplicates(data) {
+        this.duplicates.push({
+            module: data.module,
+            chunks: data.chunks
+        });
+    }
+    getModules() {
+        return this._modules.slice();
+    }
+    getDependencies() {
+        return this._dependencies.slice();
+    }
+    getImported() {
+        return this._imported.slice();
+    }
+    addModule(module) {
+        this._modules.includes(module) || this._modules.push(module);
+    }
+    addDependency(dep) {
+        this._dependencies.every((item)=>!item.isSame(dep)) && (this._dependencies.push(dep), dep.dependency.addImported(this));
+    }
+    getDependenciesChain(graph) {
+        return function getImported(pkg, ans) {
+            for (let dep of graph.getDependenciesFromPackage(pkg))if (dep.refDependency && !ans.some((dep)=>dep.dependency === pkg)) {
+                if (!dep.package) return ans.concat(dep);
+                return getImported(dep.package, ans.concat(dep));
+            }
+            return ans;
+        }(this, []);
+    }
+    addImported(pkg) {
+        this._imported.includes(pkg) || this._imported.push(pkg);
+    }
+    contain(file) {
+        var path;
+        return !!file.includes(this.root) && (path = relative(this.root, file), !/(^|[/\\])node_modules[/\\]/.test(path));
+    }
+    isSame(pkg) {
+        return this.root === pkg.root && this.version === pkg.version && this.name === pkg.name;
+    }
+    getSize() {
+        return this._modules.reduce((ans, item)=>{
+            let size = item.getSize();
+            return ans.sourceSize += size.sourceSize, ans.transformedSize += size.transformedSize, ans.parsedSize += size.parsedSize, ans.gzipSize += size.gzipSize, ans;
+        }, {
+            sourceSize: 0,
+            transformedSize: 0,
+            parsedSize: 0,
+            gzipSize: 0
+        });
+    }
+    toData() {
+        return {
+            id: this.id,
+            name: this.name,
+            root: this.root,
+            version: this.version,
+            modules: this.getModules().map((e)=>e.id),
+            size: this.getSize(),
+            duplicates: this.duplicates
+        };
+    }
+}
+class PackageGraph {
+    static fromModuleGraph(graph, root, getPackageFile) {
+        let pkgGraph = new PackageGraph(root);
+        for (let item of graph.getModules().filter((item)=>item.kind === SDK.ModuleKind.Normal)){
+            if (!item.getChunks()) continue;
+            let pkg = pkgGraph.getPackageByModule(item, getPackageFile);
+            pkg && (pkgGraph.addPackage(pkg), pkg.addModule(item));
+        }
+        for (let dep of graph.getDependencies()){
+            let modulePkg = pkgGraph.getPackageByFile(dep.module.path), dependencyPkg = pkgGraph.getPackageByFile(dep.dependency.path);
+            if (modulePkg && dependencyPkg && !modulePkg.isSame(dependencyPkg)) {
+                let pkgDep = new PackageDependency(modulePkg, dependencyPkg, dep);
+                pkgGraph.addDependency(pkgDep), modulePkg.addDependency(pkgDep);
+            }
+        }
+        return pkgGraph;
+    }
+    constructor(root){
+        this._dependencies = [], this._packages = [], this._pkgNameMap = new Map(), this._pkgFileMap = new Map(), this._root = root;
+    }
+    getPackages() {
+        return this._packages.slice();
+    }
+    getPackageByModule(module, readFile) {
+        let { path: file, meta } = module, { _pkgFileMap: pkgsMap } = this, getPackageByData = (data)=>this.getPackageByData(data) ?? new package_Package(data.name, data.root, data.version);
+        if (pkgsMap.has(file)) return pkgsMap.get(file);
+        if (meta.packageData) {
+            let pkg = getPackageByData(meta.packageData);
+            return this.setDuplicates(module, pkg), pkgsMap.set(file, pkg), pkg;
+        }
+        let cache = this.getPackageContainFile(file);
+        if (cache) return pkgsMap.set(file, cache), cache;
+        let data = readPackageJson(file, readFile);
+        if (!data) return;
+        data.root.startsWith('.') && (data.root = resolve(this._root, data.root));
+        let pkg = getPackageByData(data);
+        return this.setDuplicates(module, pkg), this.addPackage(pkg), pkgsMap.set(file, pkg), pkg;
+    }
+    getPackageByFile(file) {
+        return this._pkgFileMap.get(file);
+    }
+    getPackageContainFile(file) {
+        return this._packages.find((pkg)=>pkg.contain(file));
+    }
+    getPackagesByName(name) {
+        return this._pkgNameMap.get(name) ?? [];
+    }
+    getPackageByData(data) {
+        return this._pkgNameMap.get(data.name)?.find((item)=>item.version === data.version && item.root === data.root);
+    }
+    addPackage(pkg) {
+        if (this._packages.every((item)=>!item.isSame(pkg))) {
+            this._packages.push(pkg);
+            let { _pkgNameMap: map } = this, arr = map.get(pkg.name) ?? [];
+            arr.every((item)=>!item.isSame(pkg)) && (arr.push(pkg), map.set(pkg.name, arr));
+        }
+    }
+    setDuplicates(module, pkg) {
+        let assetsList = [], chunksList = module.getChunks();
+        chunksList.forEach((chunk)=>assetsList.push(...chunk.getAssets().filter((asset)=>asset.path.endsWith('.js')))), chunksList.length > 1 && pkg.setDuplicates({
+            module: {
+                id: module.id,
+                path: module.path
+            },
+            chunks: assetsList.map((asset)=>({
+                    name: asset.path
+                }))
+        });
+    }
+    getDependenciesFromPackage(pkg) {
+        return this._dependencies.filter((dep)=>dep.dependency === pkg);
+    }
+    addDependency(dep) {
+        this._dependencies.every((item)=>!item.isSame(dep)) && this._dependencies.push(dep);
+    }
+    getDependenciesFromOrigin() {
+        return this._dependencies.filter((item)=>!item.package);
+    }
+    getDuplicatePackages() {
+        return lodash_unionby(Array.from(this._pkgNameMap.values()).map((pkgs)=>lodash_unionby(pkgs, 'version')).filter((pkgs)=>pkgs.length > 1), (pkgs)=>pkgs[0].name);
+    }
+    toData() {
+        return {
+            packages: this._packages.map((e)=>e.toData()),
+            dependencies: this._dependencies.map((d)=>d.toData())
+        };
+    }
+}
+async function getAssetsModulesData(moduleGraph, chunkGraph, bundleDir, opts, sourceMapSets = new Map()) {
+    if (opts.parseBundle && sourceMapSets.size < 1) {
+        time("Start Parse bundle by AST.");
+        let { parseBundle = ()=>({}) } = opts || {}, assets = chunkGraph.getAssets(), modules = moduleGraph.getModules(), bundlesSources = null, parsedModules = null;
+        if (bundleDir && assets.length) {
+            for (let asset of (bundlesSources = {}, parsedModules = {}, assets)){
+                let bundleInfo, assetFile = path_0.join(bundleDir, asset.path);
+                try {
+                    bundleInfo = parseBundle(assetFile, modules);
+                } catch (err) {
+                    let { code = '', message } = err, msg = 'ENOENT' === code ? 'no such file' : message;
+                    '1' === process.env.DEVTOOLS_NODE_DEV && logger.warn(`Error parsing bundle asset "${assetFile}": ${msg}`);
+                    continue;
+                }
+                bundlesSources[asset.path] = Lodash.pick(bundleInfo, [
+                    'src',
+                    'runtimeSrc'
+                ]), Object.assign(parsedModules, bundleInfo?.modules || {});
+            }
+            Lodash.isEmpty(bundlesSources) && (bundlesSources = null, parsedModules = null, process.env.DEVTOOLS_DEV && logger.warn('\nNo bundles were parsed. Analyzer will show only original module sizes from stats file.\n')), parsedModules && transformAssetsModulesData(parsedModules, moduleGraph);
+        }
+        timeEnd("Start Parse bundle by AST.");
+    } else {
+        for (let [modulePath, codes] of (time("Start Parse bundle by sourcemap."), sourceMapSets.entries())){
+            let gzipSize, module = moduleGraph.getModuleByFile(modulePath);
+            if (module) {
+                try {
+                    if (codes && 'string' == typeof codes && codes.length > 0) {
+                        let { gzipSync } = await import("node:zlib");
+                        gzipSize = gzipSync(codes, {
+                            level: 9
+                        }).length;
+                    }
+                } catch  {}
+                module?.setSize({
+                    parsedSize: codes.length,
+                    gzipSize
+                }), module?.setSource({
+                    parsedSource: codes
+                });
+            }
+        }
+        timeEnd("Start Parse bundle by sourcemap.");
+    }
+}
+function transformAssetsModulesData(parsedModulesData, moduleGraph) {
+    moduleGraph && Object.entries(parsedModulesData).forEach(([moduleId, parsedData])=>{
+        let gzipSize, module = moduleGraph.getModuleByWebpackId(moduleId ?? '');
+        try {
+            parsedData?.content && 'string' == typeof parsedData.content && parsedData.content.length > 0 && (gzipSize = external_node_zlib_gzipSync(parsedData.content, {
+                level: 9
+            }).length);
+        } catch  {}
+        module?.setSize({
+            parsedSize: parsedData?.size,
+            gzipSize
+        }), module?.setSource({
+            parsedSource: parsedData?.content || ''
+        });
+    });
+}
+function chunkTransform(assetMap, bundleStats) {
+    let chunkGraph = new ChunkGraph();
+    if (bundleStats.chunks?.forEach((_chunk)=>{
+        let chunk = new Chunk(String(_chunk.id), _chunk.names?.join('') || _chunk.files?.join('| ') || '', _chunk.size, _chunk.initial, _chunk.entry);
+        chunk.setParsedSize(0), chunkGraph.addChunk(chunk);
+    }), bundleStats.assets?.forEach((_asset)=>{
+        if ('assets by status' === _asset.type) return;
+        let chunks = _asset.chunks?.map((ck)=>chunkGraph.getChunkById(String(ck))).filter((chunk)=>!!chunk) || [], { content = '' } = assetMap.get(_asset.name) || {}, asset = new Asset(_asset.name, _asset.size, chunks, content);
+        chunks.forEach((chunk)=>chunk?.addAsset(asset)), chunkGraph.addAsset(asset);
+    }), bundleStats.entrypoints) for (let [key, _entrypoint] of Object.entries(bundleStats.entrypoints)){
+        let entrypoint = new EntryPoint(_entrypoint.name || key);
+        _entrypoint.chunks?.forEach((chunkId)=>{
+            let ck = chunkGraph.getChunkById(`${chunkId}`);
+            ck && entrypoint.addChunk(ck);
+        }), _entrypoint.assets?.forEach((_asset)=>{
+            let asset = chunkGraph.getAssetByPath(_asset.name);
+            asset && entrypoint.addAsset(asset);
+        }), chunkGraph.addEntryPoint(entrypoint);
+    }
+    return chunkGraph;
+}
+let COMPRESSIBLE_REGEX = /\.(?:js|css|html|json|svg|txt|xml|xhtml|wasm|manifest)$/i;
+function assetsContents(assetMap, chunkGraph, supports) {
+    chunkGraph.getAssets().forEach((asset)=>{
+        let { content = '' } = assetMap.get(asset.path) || {};
+        asset.content = content, COMPRESSIBLE_REGEX.test(asset.path) && supports?.gzip && asset.setGzipSize(content);
+    });
+}
+function isImportDependency({ type }) {
+    return 'harmony side effect evaluation' === type || 'cjs require' === type || 'cjs full require' === type || 'cjs export require' === type || 'provided' === type || 'esm import' === type;
+}
+function getImportKind(dep) {
+    let { type } = dep;
+    return type ? type.includes('harmony') ? SDK.DependencyKind.ImportStatement : type.includes('cjs') ? SDK.DependencyKind.RequireCall : type.includes('import()') ? SDK.DependencyKind.DynamicImport : type.includes('amd') ? SDK.DependencyKind.AMDRequire : SDK.DependencyKind.Unknown : SDK.DependencyKind.Unknown;
+}
+function removeNoImportStyle(graph) {
+    graph.getModules().filter((module)=>File.isStyleExt(module.path)).filter((item)=>0 === item.getImported().length).forEach((item)=>graph.removeModule(item));
+}
+function getPositionByStatsLocation(loc) {
+    function formatPosition(loc) {
+        let [line, column] = loc.split(':');
+        return {
+            line: Number(line),
+            column: Number(column)
+        };
+    }
+    if (loc.includes('-')) {
+        let positionString = loc.split('-'), start = formatPosition(positionString[0]), end = formatPosition(positionString[1]);
+        return {
+            start,
+            end: Number.isNaN(end.column) ? {
+                line: start.line,
+                column: end.line
+            } : end
+        };
+    }
+    return loc.includes(':') ? {
+        start: formatPosition(loc)
+    } : loc.includes('[') ? {
+        start: {
+            index: Number(loc.match(/\[(\d+)\]/)[1])
+        }
+    } : void 0;
+}
+function isWebpack5orRspack(compilation) {
+    return 'moduleGraph' in compilation && !!compilation.moduleGraph;
+}
+function getCanSkip(data) {
+    if (!data.identifier || !(data?.nameForCondition || data.name) || data.identifier.startsWith('webpack/runtime') || data?.name?.startsWith('(webpack)')) return !0;
+}
+function getGetModuleName(root, data) {
+    if (data.nameForCondition) return data.nameForCondition.replace('\x00', '');
+    let name = data.name.replace(/ ?\+ ?\d+ ?modules$/, '');
+    return path_browserify.isAbsolute(name) ? name : path_browserify.join(root, name);
+}
+function getModulesFromArray(modules, collectedModules) {
+    modules.forEach((module)=>{
+        'module' === module.type || void 0 === module.type ? collectedModules.push(module) : 'children' in module && module.children && getModulesFromArray(module.children, collectedModules);
+    });
+}
+function getModuleGraphByStats({ modules, chunks }, root, chunkGraph) {
+    var chunks1;
+    ModuleGraph.init();
+    let moduleGraph = new ModuleGraph(), allModules = [], collectedModules = [];
+    for (let data of (getModulesFromArray(modules ?? [], collectedModules), chunks1 = chunks ?? [], chunks1?.forEach((chunk)=>{
+        chunk.modules?.length && collectedModules.push(...chunk.modules);
+    }), collectedModules ?? [])){
+        if (getCanSkip(data) || moduleGraph.getModuleByWebpackId(data.identifier)) continue;
+        allModules.push(data);
+        let isConcatenated = !!(data.modules && data.modules.length > 0), concatenatedModule = new Module(data.identifier, getGetModuleName(root, data), 0 === data.depth, isConcatenated ? SDK.ModuleKind.Concatenation : SDK.ModuleKind.Normal, data.id ? String(data.id) : void 0, data.layer);
+        for (let normal of (data.optimizationBailout && data.optimizationBailout.forEach((reason)=>concatenatedModule.addBailoutReason(reason)), data.issuerPath && concatenatedModule.addIssuerPath(data.issuerPath), data.chunks?.forEach((_chunkId)=>{
+            let chunk = chunkGraph.getChunkById(String(_chunkId));
+            chunk && concatenatedModule.addChunk(chunk);
+        }), moduleGraph.addModule(concatenatedModule), data.source && concatenatedModule.setSource({
+            transformed: Buffer.isBuffer(data.source) ? data.source.toString() : data.source
+        }), 'number' == typeof data.size && concatenatedModule.setSize({
+            sourceSize: data.size,
+            transformedSize: data.size
+        }), data.modules ?? [])){
+            let normalModule;
+            if (getCanSkip(normal)) continue;
+            allModules.push(normal);
+            let webpackId = normal.identifier, registeredModule = moduleGraph.getModuleByWebpackId(webpackId);
+            normalModule = registeredModule || (moduleGraph.getModuleByWebpackId(webpackId) ?? new Module(webpackId, getGetModuleName(root, normal), 0 === normal.depth, SDK.ModuleKind.Normal, normal.id ? String(normal.id) : void 0, normal.layer)), normal.optimizationBailout && normal.optimizationBailout.forEach((reason)=>normalModule.addBailoutReason(reason)), normal.issuerPath && normalModule.addIssuerPath(normal.issuerPath), normal.chunks?.length ? normal.chunks?.forEach((_chunkId)=>{
+                let chunk = chunkGraph.getChunkById(String(_chunkId));
+                chunk && normalModule.addChunk(chunk);
+            }) : data.chunks?.forEach((_chunkId)=>{
+                let chunk = chunkGraph.getChunkById(String(_chunkId));
+                chunk && normalModule.addChunk(chunk);
+            }), normal.source && normalModule.setSource({
+                transformed: Buffer.isBuffer(normal.source) ? normal.source.toString() : normal.source
+            }), 'number' == typeof normal.size && normalModule.setSize({
+                sourceSize: normal.size,
+                transformedSize: normal.size
+            }), moduleGraph.addModule(normalModule), concatenatedModule.addNormalModule(normalModule);
+        }
+    }
+    for (let module of allModules){
+        let currentModule = moduleGraph.getModuleByWebpackId(module.identifier ?? '');
+        if (!currentModule) continue;
+        let dependencies = (module.reasons ?? []).filter(isImportDependency).filter((item)=>!!(item.moduleIdentifier && item.userRequest));
+        for (let dep of ((module.reasons ?? []).filter((item)=>'from origin' === item.type).forEach((dep)=>dep?.children?.forEach((_d)=>dependencies.push({
+                    ...dep,
+                    ..._d,
+                    children: void 0
+                }))), dependencies)){
+            let rawRequest = dep.userRequest, requestModule = moduleGraph.getModuleByWebpackId(dep.moduleIdentifier);
+            if (!requestModule) continue;
+            if (!requestModule.getDependencyByRequest(rawRequest)) {
+                let data = requestModule.addDependency(rawRequest, currentModule, getImportKind(dep));
+                data && moduleGraph.addDependency(data);
+            }
+            let dependency = requestModule.getDependencyByRequest(rawRequest);
+            if (dependency && dep?.loc) {
+                let position = getPositionByStatsLocation(dep.loc);
+                position && dependency.addStatement(new Statement(requestModule, {
+                    transformed: position
+                }));
+            }
+        }
+    }
+    let moduleCache = new Map();
+    return moduleGraph.getModules().forEach((module)=>{
+        module.issuerPath && module.issuerPath.forEach((issuer)=>{
+            let moduleInstance = moduleCache.get(issuer.identifier);
+            !moduleInstance && (moduleInstance = moduleGraph.getModuleByWebpackId(issuer.identifier)) && moduleCache.set(issuer.identifier, moduleInstance), moduleInstance && (issuer.moduleId = moduleInstance.id);
+        });
+    }), moduleGraph;
+}
+async function transStats(json) {
+    let chunkGraph = chunkTransform(new Map(), json), moduleGraph = getModuleGraphByStats(json, '.', chunkGraph);
+    return await getAssetsModulesData(moduleGraph, chunkGraph, json.outputPath || '', {}), {
+        chunkGraph,
+        moduleGraph
+    };
+}
+function isNormalModule(mod) {
+    return 'request' in mod && 'rawRequest' in mod && 'resource' in mod;
+}
+function getWebpackModuleId(mod) {
+    return mod.identifier();
+}
+function getWebpackModulePath(mod) {
+    return mod.resource ?? mod.nameForCondition?.() ?? getWebpackModuleId(mod);
+}
+function getWebpackDependencyRequest(dep, module) {
+    return dep.request ?? dep.userRequest ?? module?.rawRequest;
+}
+function getResolveRequest(dep, graph) {
+    return getWebpackModulePath(graph.getResolvedModule(dep));
+}
+function isExternalModule(mod) {
+    return !!mod.externalType;
+}
+function getModuleSource(mod) {
+    return isExternalModule(mod) ? '' : mod.originalSource?.()?.source().toString() ?? '';
+}
+function getEntryModule(entryMap) {
+    return Array.from(entryMap.values()).map((entry)=>entry.getRuntimeChunk()).map((chunk)=>chunk ? chunk.entryModule : null).filter(Boolean).map((mod)=>isNormalModule(mod) ? mod : mod.rootModule);
+}
+function getDependencyPosition(dep, module, getSource = !0) {
+    let { loc: depLoc } = dep;
+    if (void 0 === depLoc || !('start' in depLoc)) return;
+    let transformed = {
+        start: {
+            line: depLoc.start.line,
+            column: depLoc.start.column
+        },
+        end: depLoc.end ? {
+            line: depLoc.end.line,
+            column: depLoc.end.column
+        } : void 0
+    };
+    return new Statement(module, {
+        source: getSource ? module.getSourceRange(transformed) : void 0,
+        transformed
+    });
+}
+function getExportDependency(info, module) {
+    let dep = module.dependencies.find((dep)=>dep.name === info.name && ('harmony export imported specifier' === dep.type || 'harmony export specifier' === dep.type));
+    return !dep && info._target && info._target.size > 0 && (dep = info._getMaxTarget().values().next().value.connection.dependency), dep;
+}
+function getSdkDependencyByWebpackDependency(dep, module, graph) {
+    let modulePath = getWebpackModulePath(module), request = getWebpackDependencyRequest(dep);
+    return graph.getDependencies().find((item)=>item.module.path === modulePath && item.request === request);
+}
+function getExportStatement(info, normalModule, graph) {
+    let webpackDependency = getExportDependency(info, normalModule);
+    if (!webpackDependency) return;
+    let modulePath = getWebpackModulePath(normalModule), request = getWebpackDependencyRequest(webpackDependency), sdkDependency = graph.getDependencies().find((item)=>item.module.path === modulePath && item.request === request);
+    if (sdkDependency && 1 === sdkDependency.statements.length) return sdkDependency.statements[0];
+    let sdkModule = graph.getModuleByWebpackId(getWebpackModuleId(normalModule));
+    if (sdkModule) return getDependencyPosition(webpackDependency, sdkModule);
+}
+function getLastExportInfo(info, webpackGraph) {
+    let target = info.findTarget(webpackGraph, ()=>!0);
+    if (target && target.export) return webpackGraph.getExportsInfo(target.module).getExportInfo(target.export[0]);
+}
+function getAllModules(compilation) {
+    let modules = [];
+    for (let mod of compilation.modules)modules.push(...mod.modules ?? []), modules.push(mod);
+    return lodash_unionby(modules.filter((mod)=>!getWebpackModuleId(mod).startsWith('webpack/runtime')), (mod)=>getWebpackModuleId(mod));
+}
+export { Asset, Chunk, ChunkGraph, chunks_namespaceObject as Chunks, Dependency, EntryPoint, ExportInfo, Module, ModuleGraph, ModuleGraphModule, transform_module_graph_namespaceObject as ModuleGraphTrans, package_Package as Package, PackageDependency, PackageGraph, SideEffect, Statement, trans_utils_namespaceObject as TransUtils, Variable, webpack_compatible_namespaceObject as Webpack, readPackageJson };