@rsdoctor/core 2.0.0-alpha.0 → 2.0.0-alpha.2

package/dist/630.js

@@ -0,0 +1,1269 @@
+/*! LICENSE: 630.js.LICENSE.txt */
+import { createRequire } from "node:module";
+import { __webpack_require__ } from "./rslib-runtime.js";
+import { color, createLogger, logger as external_rslog_logger } from "rslog";
+import { Constants } from "@rsdoctor/shared/types";
+import { Readable, Transform } from "stream";
+import path_0, { dirname, extname, join } from "path";
+import { Loader, Lodash, Package } from "@rsdoctor/shared/common-browser";
+import node_path from "node:path";
+import { fileURLToPath } from "node:url";
+import fs_extra from "fs-extra";
+import { find as collection_find, mapValues, omit } from "@rsdoctor/shared/collection";
+import fs from "fs";
+import { LinesAndColumns } from "lines-and-columns";
+import { Parser, parse } from "acorn";
+import { importAttributes } from "acorn-import-attributes";
+import * as __rspack_external_acorn_walk_1e4235a7 from "acorn-walk";
+var Types, esm_Types, utils_namespaceObject = {};
+__webpack_require__.r(utils_namespaceObject), __webpack_require__.d(utils_namespaceObject, {
+    canParse: ()=>canParse,
+    detectECMAVersion: ()=>detectECMAVersion,
+    getDefaultImports: ()=>getDefaultImports,
+    getIdentifierInDeclaration: ()=>getIdentifierInDeclaration,
+    getIdentifierInExport: ()=>getIdentifierInExport,
+    getIdentifierInImport: ()=>getIdentifierInImport,
+    getIdentifierInPattern: ()=>getIdentifierInPattern,
+    isES5: ()=>isES5,
+    isES6: ()=>isES6,
+    isSameSemantics: ()=>function isSameSemantics(node1, node2) {
+            if (node1.type !== node2.type) return !1;
+            switch(node1.type){
+                case 'CallExpression':
+                    return node1.arguments.length === node2.arguments.length && !!node1.optional == !!node2.optional && isSameSemantics(node1.callee, node2.callee) && node1.arguments.every((node, i)=>isSameSemantics(node, node2.arguments[i]));
+                case 'MemberExpression':
+                    return node1.computed === node2.computed && !!node1.optional == !!node2.optional && isSameSemantics(node1.object, node2.object) && isSameSemantics(node1.property, node2.property);
+                case 'Identifier':
+                    return node1.name === node2.name;
+                case 'Literal':
+                    if (asserts.isSimpleLiteral(node1) && asserts.isSimpleLiteral(node2)) return node1.value === node2.value;
+                    return node1.raw === node2.raw;
+                case 'ObjectExpression':
+                    return node1.properties.length === node2.properties.length && node1.properties.every((prop, i)=>isSameSemantics(prop, node2.properties[i]));
+                case 'Property':
+                    return node1.computed === node2.computed && node1.kind === node2.kind && node1.method === node2.method && isSameSemantics(node1.key, node2.key) && isSameSemantics(node1.value, node2.value);
+                default:
+                    throw Error(`Unknown node type: ${node1.type}`);
+            }
+        }
+});
+let rsdoctorLogger = createLogger();
+rsdoctorLogger.override({
+    log: (message)=>{
+        console.log(`${color.green('[RSDOCTOR LOG]')} ${message}`);
+    },
+    info: (message)=>{
+        console.log(`${color.yellow('[RSDOCTOR INFO]')} ${message}`);
+    },
+    warn: (message)=>{
+        console.warn(`${color.yellow('[RSDOCTOR WARN]')} ${message}`);
+    },
+    start: (message)=>{
+        console.log(`${color.green('[RSDOCTOR START]')} ${message}`);
+    },
+    ready: (message)=>{
+        console.log(`${color.green('[RSDOCTOR READY]')} ${message}`);
+    },
+    error: (message)=>{
+        console.error(`${color.red('[RSDOCTOR ERROR]')} ${message}`);
+    },
+    success: (message)=>{
+        console.error(`${color.green('[RSDOCTOR SUCCESS]')} ${message}`);
+    },
+    debug: (message)=>{
+        process.env.DEBUG && console.log(`${color.blue('[RSDOCTOR DEBUG]')} ${message}`);
+    }
+});
+let _timers = new Map();
+function logger_time(label) {
+    process.env.DEBUG !== Constants.RsdoctorProcessEnvDebugKey || _timers.has(label) || _timers.set(label, Date.now());
+}
+function timeEnd(label) {
+    if (process.env.DEBUG !== Constants.RsdoctorProcessEnvDebugKey) return;
+    let start = _timers.get(label);
+    if (null == start) return void external_rslog_logger.debug(`Timer '${label}' does not exist.`);
+    let duration = Date.now() - start;
+    external_rslog_logger.debug(`Timer '${label}' ended: ${duration}ms`), _timers.delete(label);
+}
+function _typeof(obj) {
+    return (_typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj) {
+        return typeof obj;
+    } : function(obj) {
+        return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+    })(obj);
+}
+function _defineProperty(obj, key, value) {
+    return key in obj ? Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: !0,
+        configurable: !0,
+        writable: !0
+    }) : obj[key] = value, obj;
+}
+function esm_getPrototypeOf(o) {
+    return (esm_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    })(o);
+}
+function esm_setPrototypeOf(o, p) {
+    return (esm_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(o, p) {
+        return o.__proto__ = p, o;
+    })(o, p);
+}
+function _assertThisInitialized(self) {
+    if (void 0 === self) throw ReferenceError("this hasn't been initialised - super() hasn't been called");
+    return self;
+}
+var rxEscapable = /[\\"\u0000-\u001f\u007f-\u009f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g, meta = {
+    '\b': '\\b',
+    '\t': '\\t',
+    '\n': '\\n',
+    '\f': '\\f',
+    '\r': '\\r',
+    '"': '\\"',
+    '\\': '\\\\'
+};
+function getType(value) {
+    return value ? 'function' == typeof value.then ? esm_Types.Promise : 'function' == typeof value.read && 'function' == typeof value.pause && 'function' == typeof value.resume && 'function' == typeof value.pipe && 'function' == typeof value.once && 'function' == typeof value.removeListener ? value._readableState.objectMode ? esm_Types.ReadableObject : esm_Types.ReadableString : Array.isArray(value) ? esm_Types.Array : 'object' === _typeof(value) || value instanceof Object ? esm_Types.Object : esm_Types.Primitive : esm_Types.Primitive;
+}
+(Types = esm_Types || (esm_Types = {}))[Types.Array = 0] = "Array", Types[Types.Object = 1] = "Object", Types[Types.ReadableString = 2] = "ReadableString", Types[Types.ReadableObject = 3] = "ReadableObject", Types[Types.Primitive = 4] = "Primitive", Types[Types.Promise = 5] = "Promise";
+var stackItemOpen = [];
+stackItemOpen[esm_Types.Array] = '[', stackItemOpen[esm_Types.Object] = '{', stackItemOpen[esm_Types.ReadableString] = '"', stackItemOpen[esm_Types.ReadableObject] = '[';
+var stackItemEnd = [];
+stackItemEnd[esm_Types.Array] = ']', stackItemEnd[esm_Types.Object] = '}', stackItemEnd[esm_Types.ReadableString] = '"', stackItemEnd[esm_Types.ReadableObject] = ']';
+var processFunctionLookupTable = [
+    'processArray',
+    'processObject',
+    'processReadableString',
+    'processReadableObject',
+    'processPrimitive',
+    'processPromise'
+];
+function escapeString(string) {
+    return string.replace(rxEscapable, function(a) {
+        var c = meta[a];
+        return 'string' == typeof c ? c : "\\u".concat(a.charCodeAt(0).toString(16).padStart(4, '0'));
+    });
+}
+function quoteString(string) {
+    return "\"".concat(escapeString(string), "\"");
+}
+function readAsPromised(stream, size) {
+    var value = stream.read(size);
+    return null === value ? new Promise(function(resolve, reject) {
+        var endListener = function() {
+            return resolve(null);
+        };
+        stream.once('end', endListener), stream.once('error', reject), stream.once('readable', function() {
+            stream.removeListener('end', endListener), stream.removeListener('error', reject), resolve(stream.read());
+        });
+    }) : Promise.resolve(value);
+}
+var esm_JsonStreamStringify = function(_Readable) {
+    if ("function" != typeof _Readable && null !== _Readable) throw TypeError("Super expression must either be null or a function");
+    JsonStreamStringify.prototype = Object.create(_Readable && _Readable.prototype, {
+        constructor: {
+            value: JsonStreamStringify,
+            writable: !0,
+            configurable: !0
+        }
+    }), Object.defineProperty(JsonStreamStringify, "prototype", {
+        writable: !1
+    }), _Readable && esm_setPrototypeOf(JsonStreamStringify, _Readable);
+    var hasNativeReflectConstruct, protoProps, _super = (hasNativeReflectConstruct = function() {
+        if ("u" < typeof Reflect || !Reflect.construct || Reflect.construct.sham) return !1;
+        if ("function" == typeof Proxy) return !0;
+        try {
+            return Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {})), !0;
+        } catch (e) {
+            return !1;
+        }
+    }(), function() {
+        var result, Super = esm_getPrototypeOf(JsonStreamStringify);
+        result = hasNativeReflectConstruct ? Reflect.construct(Super, arguments, esm_getPrototypeOf(this).constructor) : Super.apply(this, arguments);
+        if (result && ("object" == typeof result || "function" == typeof result)) return result;
+        if (void 0 !== result) throw TypeError("Derived constructors may only return object or undefined");
+        return _assertThisInitialized(this);
+    });
+    function JsonStreamStringify(value, replacer, spaces) {
+        var _this, cycle = arguments.length > 3 && void 0 !== arguments[3] && arguments[3];
+        if (!(this instanceof JsonStreamStringify)) throw TypeError("Cannot call a class as a function");
+        _defineProperty(_assertThisInitialized(_this = _super.call(this, {
+            encoding: 'utf8'
+        })), "cycle", void 0), _defineProperty(_assertThisInitialized(_this), "visited", void 0), _defineProperty(_assertThisInitialized(_this), "stack", []), _defineProperty(_assertThisInitialized(_this), "replacerFunction", void 0), _defineProperty(_assertThisInitialized(_this), "replacerArray", void 0), _defineProperty(_assertThisInitialized(_this), "gap", void 0), _defineProperty(_assertThisInitialized(_this), "depth", 0), _defineProperty(_assertThisInitialized(_this), "error", void 0), _defineProperty(_assertThisInitialized(_this), "pushCalled", !1), _defineProperty(_assertThisInitialized(_this), "end", !1), _defineProperty(_assertThisInitialized(_this), "isReading", !1), _defineProperty(_assertThisInitialized(_this), "readMore", !1), _this.cycle = cycle;
+        var spaceType = _typeof(spaces);
+        return ('string' === spaceType || 'number' === spaceType) && (_this.gap = Number.isFinite(spaces) ? ' '.repeat(spaces) : spaces), Object.assign(_assertThisInitialized(_this), {
+            visited: cycle ? new WeakMap() : new WeakSet(),
+            replacerFunction: replacer instanceof Function && replacer,
+            replacerArray: Array.isArray(replacer) && replacer
+        }), replacer instanceof Function && (_this.replacerFunction = replacer), Array.isArray(replacer) && (_this.replacerArray = replacer), _this.addToStack(value), _this;
+    }
+    return protoProps = [
+        {
+            key: "cycler",
+            value: function(key, value) {
+                var existingPath = this.visited.get(value);
+                if (existingPath) return {
+                    $ref: existingPath
+                };
+                var path = this.path();
+                return void 0 !== key && path.push(key), path = path.map(function(v) {
+                    return "[".concat(Number.isInteger(v) ? v : quoteString(v), "]");
+                }), this.visited.set(value, path.length ? "$".concat(path.join('')) : '$'), value;
+            }
+        },
+        {
+            key: "addToStack",
+            value: function(value, key, index, parent) {
+                var _realValue$_readableS, _realValue$_readableS2, _this2 = this, realValue = value;
+                this.replacerFunction && (realValue = this.replacerFunction(key || index, realValue, this)), realValue && realValue.toJSON instanceof Function && (realValue = realValue.toJSON()), (realValue instanceof Function || 'symbol' === _typeof(value)) && (realValue = void 0), void 0 !== key && this.replacerArray && !this.replacerArray.includes(key) && (realValue = void 0);
+                var type = getType(realValue);
+                if ((parent && parent.type === esm_Types.Array || void 0 !== realValue) && type !== esm_Types.Promise && (parent && !parent.first && this._push(','), parent && (parent.first = !1)), void 0 !== realValue && type !== esm_Types.Promise && void 0 !== key && (this.gap ? this._push("\n".concat(this.gap.repeat(this.depth), "\"").concat(escapeString(key), "\": ")) : this._push("\"".concat(escapeString(key), "\":"))), type !== esm_Types.Primitive) if (this.cycle) type = getType(realValue = this.cycler(key || index, realValue));
+                else {
+                    if (this.visited.has(realValue)) throw Object.assign(Error('Converting circular structure to JSON'), {
+                        realValue: realValue,
+                        key: key || index
+                    });
+                    this.visited.add(realValue);
+                }
+                !key && index > -1 && this.depth && this.gap && this._push("\n".concat(this.gap.repeat(this.depth)));
+                var open = stackItemOpen[type];
+                open && this._push(open);
+                var obj = {
+                    key: key,
+                    index: index,
+                    type: type,
+                    parent: parent,
+                    value: realValue,
+                    first: !0
+                };
+                return type === esm_Types.Object ? (this.depth += 1, obj.unread = Object.keys(realValue), obj.isEmpty = !obj.unread.length) : type === esm_Types.Array ? (this.depth += 1, obj.unread = realValue.length, obj.arrayLength = obj.unread, obj.isEmpty = !obj.unread) : (type === esm_Types.ReadableString || type === esm_Types.ReadableObject) && (this.depth += 1, realValue.readableEnded || null != (_realValue$_readableS = realValue._readableState) && _realValue$_readableS.endEmitted ? this.emit('error', Error('Readable Stream has ended before it was serialized. All stream data have been lost'), realValue, key || index) : (realValue.readableFlowing || null != (_realValue$_readableS2 = realValue._readableState) && _realValue$_readableS2.flowing) && (realValue.pause(), this.emit('error', Error('Readable Stream is in flowing mode, data may have been lost. Trying to pause stream.'), realValue, key || index)), obj.readCount = 0, realValue.once('end', function() {
+                    obj.end = !0, _this2.__read();
+                }), realValue.once('error', function(err) {
+                    _this2.error = !0, _this2.emit('error', err);
+                })), this.stack.unshift(obj), obj;
+            }
+        },
+        {
+            key: "removeFromStack",
+            value: function(item) {
+                var type = item.type, isObject = type === esm_Types.Object || type === esm_Types.Array || type === esm_Types.ReadableString || type === esm_Types.ReadableObject;
+                type !== esm_Types.Primitive && (this.cycle || this.visited.delete(item.value), isObject && (this.depth -= 1));
+                var end = stackItemEnd[type];
+                isObject && !item.isEmpty && this.gap && this._push("\n".concat(this.gap.repeat(this.depth))), end && this._push(end);
+                var stackIndex = this.stack.indexOf(item);
+                this.stack.splice(stackIndex, 1);
+            }
+        },
+        {
+            key: "_push",
+            value: function(data) {
+                this.pushCalled = !0, this.push(data);
+            }
+        },
+        {
+            key: "processReadableObject",
+            value: function(current, size) {
+                var _this3 = this;
+                return current.end ? void this.removeFromStack(current) : readAsPromised(current.value, size).then(function(value) {
+                    null !== value && (current.first || _this3._push(','), current.first = !1, _this3.addToStack(value, void 0, current.readCount), current.readCount += 1);
+                });
+            }
+        },
+        {
+            key: "processObject",
+            value: function(current) {
+                if (!current.unread.length) return void this.removeFromStack(current);
+                var key = current.unread.shift(), value = current.value[key];
+                this.addToStack(value, key, void 0, current);
+            }
+        },
+        {
+            key: "processArray",
+            value: function(current) {
+                var key = current.unread;
+                if (!key) return void this.removeFromStack(current);
+                var index = current.arrayLength - key, value = current.value[index];
+                current.unread -= 1, this.addToStack(value, void 0, index, current);
+            }
+        },
+        {
+            key: "processPrimitive",
+            value: function(current) {
+                if (void 0 !== current.value) {
+                    var value, type = _typeof(current.value);
+                    switch(type){
+                        case 'string':
+                            value = quoteString(current.value);
+                            break;
+                        case 'number':
+                            value = Number.isFinite(current.value) ? String(current.value) : 'null';
+                            break;
+                        case 'bigint':
+                        case 'boolean':
+                            value = String(current.value);
+                            break;
+                        case 'object':
+                            if (!current.value) {
+                                value = 'null';
+                                break;
+                            }
+                        default:
+                            throw Object.assign(Error("Unknown type \"".concat(type, "\". Please file an issue!")), {
+                                value: current.value
+                            });
+                    }
+                    this._push(value);
+                } else this.stack[1] && (this.stack[1].type === esm_Types.Array || this.stack[1].type === esm_Types.ReadableObject) ? this._push('null') : current.addSeparatorAfterEnd = !1;
+                this.removeFromStack(current);
+            }
+        },
+        {
+            key: "processReadableString",
+            value: function(current, size) {
+                var _this4 = this;
+                return current.end ? void this.removeFromStack(current) : readAsPromised(current.value, size).then(function(value) {
+                    value && _this4._push(escapeString(value.toString()));
+                });
+            }
+        },
+        {
+            key: "processPromise",
+            value: function(current) {
+                var _this5 = this;
+                return (function recursiveResolve(promise) {
+                    return promise.then(function(res) {
+                        return getType(res) === esm_Types.Promise ? recursiveResolve(res) : res;
+                    });
+                })(current.value).then(function(value) {
+                    _this5.removeFromStack(current), _this5.addToStack(value, current.key, current.index, current.parent);
+                });
+            }
+        },
+        {
+            key: "processStackTopItem",
+            value: function(size) {
+                var out, _this6 = this, current = this.stack[0];
+                if (!current || this.error) return Promise.resolve();
+                try {
+                    out = this[processFunctionLookupTable[current.type]](current, size);
+                } catch (err) {
+                    return Promise.reject(err);
+                }
+                return Promise.resolve(out).then(function() {
+                    0 === _this6.stack.length && (_this6.end = !0, _this6._push(null));
+                });
+            }
+        },
+        {
+            key: "__read",
+            value: function(size) {
+                var _this7 = this;
+                if (this.isReading || this.error) {
+                    this.readMore = !0;
+                    return;
+                }
+                return this.isReading = !0, this.readMore = !1, this.processStackTopItem(size).then(function() {
+                    _this7.end || _this7.error || !_this7.readMore && _this7.pushCalled ? _this7.isReading = !1 : setImmediate(function() {
+                        _this7.isReading = !1, _this7.__read();
+                    });
+                }).catch(function(err) {
+                    _this7.error = !0, _this7.emit('error', err);
+                });
+            }
+        },
+        {
+            key: "_read",
+            value: function(size) {
+                this.pushCalled = !1, this.__read(size);
+            }
+        },
+        {
+            key: "path",
+            value: function() {
+                return this.stack.map(function(_ref) {
+                    var key = _ref.key, index = _ref.index;
+                    return key || index;
+                }).filter(function(v) {
+                    return v || v > -1;
+                }).reverse();
+            }
+        }
+    ], function(target, props) {
+        for(var i = 0; i < props.length; i++){
+            var descriptor = props[i];
+            descriptor.enumerable = descriptor.enumerable || !1, descriptor.configurable = !0, "value" in descriptor && (descriptor.writable = !0), Object.defineProperty(target, descriptor.key, descriptor);
+        }
+    }(JsonStreamStringify.prototype, protoProps), Object.defineProperty(JsonStreamStringify, "prototype", {
+        writable: !1
+    }), JsonStreamStringify;
+}(Readable);
+function stringify(json, replacer, space, cycle) {
+    let jsonList = [];
+    return json && 'object' == typeof json ? new Promise((resolve, reject)=>{
+        let stream = new esm_JsonStreamStringify(json, replacer, space, cycle), currentLength = 0, currentContent = '', batchProcessor = new Transform({
+            readableObjectMode: !0,
+            transform (chunk, _encoding, callback) {
+                chunk.toString().split('\\n').forEach((line)=>{
+                    currentLength + line.length > 419430400 && (jsonList.push(currentContent), currentContent = '', currentLength = 0), line.length && (currentContent += line, currentLength += line.length);
+                }), callback();
+            }
+        });
+        stream.pipe(batchProcessor).on('data', (line)=>{
+            currentLength + line.length > 419430400 && (jsonList.push(currentContent), currentContent = '', currentLength = 0), line.length && (currentContent += line, currentLength += line.length);
+        }).on('end', ()=>{
+            jsonList.length < 1 && jsonList.push(currentContent), resolve(jsonList);
+        }).on('error', (err)=>reject(err));
+    }) : Promise.resolve(JSON.stringify(json, replacer, space));
+}
+let readPackageJson = (file, readFile)=>{
+    let result, current = file;
+    for(; '/' !== current && !result;){
+        let parent = dirname(current);
+        if (parent === current) break;
+        current = parent, 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);
+}, JEDEC = "jedec", BYTE = "byte", ARRAY = "array", OBJECT = "object", EXPONENT = "exponent", STRINGS_symbol = {
+    iec: {
+        bits: [
+            "bit",
+            "Kibit",
+            "Mibit",
+            "Gibit",
+            "Tibit",
+            "Pibit",
+            "Eibit",
+            "Zibit",
+            "Yibit"
+        ],
+        bytes: [
+            "B",
+            "KiB",
+            "MiB",
+            "GiB",
+            "TiB",
+            "PiB",
+            "EiB",
+            "ZiB",
+            "YiB"
+        ]
+    },
+    jedec: {
+        bits: [
+            "bit",
+            "Kbit",
+            "Mbit",
+            "Gbit",
+            "Tbit",
+            "Pbit",
+            "Ebit",
+            "Zbit",
+            "Ybit"
+        ],
+        bytes: [
+            "B",
+            "KB",
+            "MB",
+            "GB",
+            "TB",
+            "PB",
+            "EB",
+            "ZB",
+            "YB"
+        ]
+    }
+}, STRINGS_fullform = {
+    iec: [
+        "",
+        "kibi",
+        "mebi",
+        "gibi",
+        "tebi",
+        "pebi",
+        "exbi",
+        "zebi",
+        "yobi"
+    ],
+    jedec: [
+        "",
+        "kilo",
+        "mega",
+        "giga",
+        "tera",
+        "peta",
+        "exa",
+        "zetta",
+        "yotta"
+    ]
+}, BINARY_POWERS = [
+    1,
+    1024,
+    1048576,
+    1073741824,
+    1099511627776,
+    1125899906842624,
+    1152921504606846976,
+    1180591620717411303424,
+    1208925819614629174706176
+], DECIMAL_POWERS = [
+    1,
+    1000,
+    1000000,
+    1000000000,
+    1000000000000,
+    1000000000000000,
+    1000000000000000000,
+    1000000000000000000000,
+    1000000000000000000000000
+], LOG_2_1024 = Math.log(1024), LOG_10_1000 = Math.log(1000), STANDARD_CONFIGS = {
+    si: {
+        isDecimal: !0,
+        ceil: 1000,
+        actualStandard: JEDEC
+    },
+    iec: {
+        isDecimal: !1,
+        ceil: 1024,
+        actualStandard: "iec"
+    },
+    [JEDEC]: {
+        isDecimal: !1,
+        ceil: 1024,
+        actualStandard: JEDEC
+    }
+};
+function calculateOptimizedValue(num, e, isDecimal, bits, ceil, autoExponent = !0) {
+    let d, result = num / (d = isDecimal ? DECIMAL_POWERS[e] : BINARY_POWERS[e]);
+    return bits && (result *= 8, autoExponent && result >= ceil && e < 8 && (result /= ceil, e++)), {
+        result,
+        e
+    };
+}
+function filesize(arg, { bits = !1, pad = !1, base = -1, round = 2, locale = "", localeOptions = {}, separator = "", spacer = " ", symbols = {}, standard = "", output = "string", fullform = !1, fullforms = [], exponent = -1, roundingMethod = "round", precision = 0 } = {}) {
+    let p, r, symbolTable, numericValue, e = exponent, num, result = [], val = 0, u = "";
+    if ("bigint" == typeof arg) num = Number(arg);
+    else if (isNaN(num = Number(arg)) || !isFinite(num)) throw TypeError("Invalid number");
+    let { isDecimal, ceil, actualStandard } = STANDARD_CONFIGS[standard] ? STANDARD_CONFIGS[standard] : 2 === base ? {
+        isDecimal: !1,
+        ceil: 1024,
+        actualStandard: "iec"
+    } : {
+        isDecimal: !0,
+        ceil: 1000,
+        actualStandard: JEDEC
+    }, full = !0 === fullform, neg = num < 0, roundingFunc = Math[roundingMethod];
+    if ("function" != typeof roundingFunc) throw TypeError("Invalid rounding method");
+    if (neg && (num = -num), 0 === num) {
+        let value;
+        return (value = precision > 0 ? 0..toPrecision(precision) : pad && round > 0 ? 0..toFixed(round) : 0, output === EXPONENT) ? 0 : (symbol || (symbol = bits ? STRINGS_symbol[actualStandard].bits[0] : STRINGS_symbol[actualStandard].bytes[0]), symbols[symbol] && (symbol = symbols[symbol]), full && (fullforms[0] ? symbol = fullforms[0] : (symbol = STRINGS_fullform[actualStandard][0], bits ? symbol += "bit" : symbol += BYTE)), output === ARRAY) ? [
+            value,
+            symbol
+        ] : output === OBJECT ? {
+            value,
+            symbol,
+            exponent: 0,
+            unit: symbol
+        } : value + spacer + symbol;
+    }
+    let { e: calculatedE, precision: precisionAdjusted } = (num1 = num, e1 = e, precision1 = precision, (-1 === e1 || isNaN(e1) ? (e1 = isDecimal ? Math.floor(Math.log(num1) / LOG_10_1000) : Math.floor(Math.log(num1) / LOG_2_1024)) < 0 && (e1 = 0) : e1 < 0 && (e1 = 0), e1 > 8) ? (precision1 > 0 && (precision1 += 8 - e1), {
+        e: 8,
+        precision: precision1
+    }) : {
+        e: e1,
+        precision: precision1
+    });
+    e = calculatedE;
+    let autoExponent = -1 === exponent || isNaN(exponent), { result: valueResult, e: valueExponent } = calculateOptimizedValue(num, e, isDecimal, bits, ceil, autoExponent);
+    val = valueResult, e = valueExponent;
+    let rounded = (val1 = val, (r = 1 === (p = (e2 = e) > 0 && round > 0 ? Math.pow(10, round) : 1) ? roundingFunc(val1) : roundingFunc(val1 * p) / p) === ceil && e2 < 8 && autoExponent && (r = 1, e2++), {
+        value: r,
+        e: e2
+    });
+    if (result[0] = rounded.value, e = rounded.e, precisionAdjusted > 0) {
+        let precisionResult = function(value, precision, e, num, isDecimal, bits, ceil, roundingFunc, round, exponent) {
+            "string" == typeof value && (value = parseFloat(value));
+            let result = value.toPrecision(precision), autoExponent = -1 === exponent || isNaN(exponent);
+            if (result.includes("e") && e < 8 && autoExponent) {
+                let p, { result: valueResult } = calculateOptimizedValue(num, ++e, isDecimal, bits, ceil);
+                result = (1 === (p = round > 0 ? Math.pow(10, round) : 1) ? roundingFunc(valueResult) : roundingFunc(valueResult * p) / p).toPrecision(precision);
+            }
+            return {
+                value: result,
+                e
+            };
+        }(result[0], precisionAdjusted, e, num, isDecimal, bits, ceil, roundingFunc, round, exponent);
+        result[0] = precisionResult.value, e = precisionResult.e;
+    }
+    if (output === EXPONENT) return e;
+    e3 = e, symbolTable = STRINGS_symbol[actualStandard][bits ? "bits" : "bytes"], u = isDecimal && 1 === e3 ? bits ? "kbit" : "kB" : symbolTable[e3], result[1] = u;
+    var symbol, num1, e1, precision1, val1, e2, e3, e4, u1, e5 = e;
+    if (neg && (result[0] = -result[0]), symbols[result[1]] && (result[1] = symbols[result[1]]), numericValue = "string" == typeof result[0] ? parseFloat(result[0]) : result[0], result[0] = function(value, locale, localeOptions, separator, pad, round, roundingFunc) {
+        let result = value, localePad = pad && round > 0 ? {
+            minimumFractionDigits: round,
+            maximumFractionDigits: round
+        } : void 0;
+        if (!0 === locale) result = result.toLocaleString(void 0, localePad);
+        else if (locale.length > 0) result = result.toLocaleString(locale, {
+            ...localeOptions,
+            ...localePad
+        });
+        else if (separator.length > 0) {
+            if (pad && round > 0) {
+                let p = Math.pow(10, round);
+                result = roundingFunc(result * p) / p;
+            }
+            result = result.toString().replace(".", separator);
+        }
+        if (pad && round > 0 && !0 !== locale && 0 === locale.length) {
+            let resultStr = result.toString(), x = separator || ".", tmp = resultStr.split(x), s = tmp[1] || "";
+            result = `${tmp[0]}${x}${s.padEnd(round, "0")}`;
+        }
+        return result;
+    }(result[0], locale, localeOptions, separator, pad, round, roundingFunc), full) {
+        let unit;
+        unit = bits ? "bit" : BYTE, fullforms[e5] ? result[1] = fullforms[e5] : result[1] = STRINGS_fullform[actualStandard][e5] + unit + (1 === numericValue ? "" : "s");
+    }
+    return e4 = e, u1 = u, output === ARRAY ? result : output === OBJECT ? {
+        value: result[0],
+        symbol: result[1],
+        exponent: e4,
+        unit: u1
+    } : " " === spacer ? `${result[0]} ${result[1]}` : result.join(spacer);
+}
+let loader_filename = fileURLToPath(import.meta.url), loader_dirname = node_path.dirname(loader_filename), loader_require = createRequire(import.meta.url), PATH_QUERY_FRAGMENT_REGEXP = /^((?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/;
+function parsePathQueryFragment(str) {
+    let match = PATH_QUERY_FRAGMENT_REGEXP.exec(str);
+    return {
+        path: match?.[1].replace(/\0(.)/g, '$1') || '',
+        query: match?.[2] ? match[2].replace(/\0(.)/g, '$1') : '',
+        fragment: match?.[3] || ''
+    };
+}
+function loadLoaderModule(loaderPath, cwd = process.cwd()) {
+    let cleanLoaderPath = parsePathQueryFragment(loaderPath).path, mod = loader_require(process.env.DOCTOR_TEST ? node_path.resolve(cwd, cleanLoaderPath) : loader_require.resolve(cleanLoaderPath, {
+        paths: [
+            cwd,
+            node_path.resolve(cwd, 'node_modules')
+        ]
+    }));
+    return {
+        default: mod.__esModule && 'function' == typeof mod.default ? mod.default : 'function' == typeof mod ? mod : null,
+        pitch: mod.default?.pitch || mod.pitch,
+        raw: mod.default?.raw || mod.raw || !1
+    };
+}
+function extractLoaderName(loaderPath, cwd = '') {
+    let res = loaderPath.replace(cwd, '');
+    if (!node_path.isAbsolute(res)) return res;
+    let nms = '/node_modules/', idx = res.lastIndexOf(nms);
+    if (-1 !== idx) {
+        res = res.slice(idx + nms.length);
+        let ln = 'loader', lnIdx = res.lastIndexOf(ln);
+        lnIdx > -1 && (res = res.slice(0, lnIdx + ln.length));
+    }
+    return res;
+}
+function mapEachRules(rules, callback) {
+    return rules.filter(Boolean).map((rule)=>{
+        if ('string' == typeof rule) return callback({
+            loader: rule
+        });
+        if (rule.loader && 'string' == typeof rule.loader) return callback(rule);
+        if (Array.isArray(rule.loaders)) {
+            let { loaders, ...rest } = rule;
+            return {
+                ...rest,
+                use: mapEachRules(loaders, callback)
+            };
+        }
+        if (rule.use && (!Array.isArray(rule.use) || 0 !== rule.use.length)) {
+            if ('string' == typeof rule.use) return {
+                ...rule,
+                use: mapEachRules([
+                    {
+                        loader: rule.use,
+                        options: rule.options
+                    }
+                ], callback)
+            };
+            if ('function' == typeof rule.use) {
+                let funcUse = rule.use;
+                return {
+                    ...rule,
+                    use: (...args)=>mapEachRules(funcUse(...args), callback)
+                };
+            }
+            return Array.isArray(rule.use) ? {
+                ...rule,
+                use: mapEachRules(rule.use, callback)
+            } : {
+                ...rule,
+                use: mapEachRules([
+                    rule.use
+                ], callback)
+            };
+        }
+        return 'rules' in rule && Array.isArray(rule.rules) ? {
+            ...rule,
+            rules: mapEachRules(rule.rules, callback)
+        } : Array.isArray(rule.oneOf) ? {
+            ...rule,
+            oneOf: mapEachRules(rule.oneOf, callback)
+        } : rule;
+    });
+}
+function isESMLoader(r) {
+    let _loaderName = 'object' == typeof r && 'string' == typeof r?.loader ? r.loader : 'string' == typeof r ? r : '';
+    if (!_loaderName) return !1;
+    if (node_path.isAbsolute(_loaderName) || _loaderName.startsWith('./') || _loaderName.startsWith('../')) {
+        let packageJsonData = readPackageJson(_loaderName, (file)=>{
+            try {
+                return fs_extra.readJsonSync(file, {
+                    encoding: 'utf8'
+                });
+            } catch (e) {
+                rsdoctorLogger.debug(`isESMLoader function error：${e}`);
+            }
+        });
+        if (packageJsonData?.type === 'module' && !packageJsonData?.name.includes('@rsdoctor/')) return !0;
+    }
+    return !1;
+}
+function appendProbeLoaders(compiler, loaderConfig) {
+    let _options = 'object' == typeof loaderConfig ? 'string' == typeof loaderConfig.options ? {
+        options: loaderConfig.options
+    } : loaderConfig.options : {}, loaderPath = process.env.DOCTOR_TEST ? node_path.resolve(loader_dirname, '../loader/probeLoader.ts') : loader_require.resolve(node_path.join(loader_dirname, 'probe-loader')), loader = 'string' == typeof loaderConfig ? loaderConfig : 'object' == typeof loaderConfig && loaderConfig.loader, createProbeLoader = (type)=>({
+            loader: loaderPath,
+            options: {
+                ..._options,
+                loader,
+                ident: void 0,
+                type,
+                builderName: compiler.options.name
+            }
+        });
+    return [
+        createProbeLoader('end'),
+        loaderConfig,
+        createProbeLoader('start')
+    ];
+}
+function getLoaderNameMatch(r, loaderName, strict = !0) {
+    return strict ? 'object' == typeof r && 'string' == typeof r?.loader && r.loader === loaderName || 'string' == typeof r && r === loaderName : 'object' == typeof r && 'string' == typeof r?.loader && r.loader.includes(loaderName) || 'string' == typeof r && r.includes(loaderName);
+}
+function addProbeLoader2Rules(rules, compiler, fn) {
+    return rules.map((rule)=>{
+        if (!rule || 'string' == typeof rule) return rule;
+        if (fn(rule) && !rule.use) {
+            let loaderConfig = {
+                loader: rule.loader ?? '',
+                options: rule.options,
+                ident: 'ident' in rule && 'string' == typeof rule.ident ? rule.ident : void 0
+            };
+            return {
+                ...rule,
+                use: appendProbeLoaders(compiler, loaderConfig),
+                loader: void 0,
+                options: void 0
+            };
+        }
+        return (rule.use && (Array.isArray(rule.use) ? rule.use = rule.use.flatMap((loaderConfig)=>('string' == typeof loaderConfig || 'object' == typeof loaderConfig && loaderConfig && 'loader' in loaderConfig) && fn(loaderConfig) ? appendProbeLoaders(compiler, loaderConfig) : [
+                loaderConfig
+            ]) : 'object' != typeof rule.use || Array.isArray(rule.use) || 'function' == typeof rule.use ? 'string' == typeof rule.use && (rule.use = fn(rule.use) ? appendProbeLoaders(compiler, {
+            loader: rule.use
+        }) : [
+            {
+                loader: rule.use
+            }
+        ]) : 'loader' in rule.use && (rule.use = fn(rule.use) ? appendProbeLoaders(compiler, rule.use) : [
+            rule.use
+        ])), 'oneOf' in rule && rule.oneOf) ? {
+            ...rule,
+            oneOf: addProbeLoader2Rules(rule.oneOf, compiler, fn)
+        } : 'rules' in rule && rule.rules ? {
+            ...rule,
+            rules: addProbeLoader2Rules(rule.rules, compiler, fn)
+        } : rule;
+    });
+}
+function createLoaderContextTrap(final) {
+    let cb = this.callback, callback = (...args)=>(final(args[0], args[1] ?? null, args[2]), cb.call(this, ...args)), ac = this.async, async = (...args)=>{
+        let cb = ac(...args);
+        return (...args)=>(final(args[0], args[1] ?? null, args[2]), cb(...args));
+    };
+    return new Proxy(this, {
+        get (target, key, receiver) {
+            switch(key){
+                case 'async':
+                    return async;
+                case 'callback':
+                    return callback;
+                case 'query':
+                    if (target.query) {
+                        if ('string' == typeof target.query) return target.query.replace(RegExp(`"${Loader.LoaderInternalPropertyName}":{[^}]*},{0,1}`), '');
+                        if ('object' == typeof target.query) {
+                            let options = target.query[Loader.LoaderInternalPropertyName];
+                            if (options.hasOptions) return omit(target.query, [
+                                Loader.LoaderInternalPropertyName
+                            ]);
+                            return parsePathQueryFragment(options?.loader).query;
+                        }
+                    }
+                    return Reflect.get(target, key, receiver);
+                case 'getOptions':
+                    return 'function' == typeof target.getOptions ? ()=>omit(target.getOptions(), [
+                            Loader.LoaderInternalPropertyName
+                        ]) : Reflect.get(target, key, receiver);
+                default:
+                    return target[key];
+            }
+        },
+        set (target, key, value, receiver) {
+            switch(key){
+                case 'async':
+                    return async = value, !0;
+                case 'callback':
+                    return callback = value, !0;
+                default:
+                    return Reflect.set(target, key, value, receiver);
+            }
+        },
+        defineProperty: (target, p, attrs)=>Reflect.defineProperty(target, p, attrs)
+    });
+}
+function parseQuery(query) {
+    return query.startsWith('?') && (query = query.slice(1)), Object.fromEntries(new URLSearchParams(query).entries());
+}
+function shouldInterceptPluginHook(hook) {
+    return (!hook || !hook._fakeHook) && (hook?.isUsed && 'function' == typeof hook.isUsed ? hook.isUsed() : !hook?._map || 0 !== hook._map.size);
+}
+function interceptCompilerHooks(compiler, interceptor) {
+    Object.keys(compiler.hooks).forEach((hook)=>{
+        let v = compiler.hooks[hook];
+        shouldInterceptPluginHook(v) && interceptor(hook, v, 'compiler');
+    });
+}
+function interceptCompilationHooks(compilation, interceptor) {
+    Object.keys(compilation.hooks).forEach((hook)=>{
+        if ('normalModuleLoader' === hook) return;
+        let v = compilation.hooks[hook];
+        shouldInterceptPluginHook(v) && interceptor(hook, v, 'compilation');
+    });
+}
+class Document {
+    constructor(content){
+        this._text = '', this._text = content, this.createFinder();
+    }
+    createFinder() {
+        let find = new LinesAndColumns(this._text);
+        this.positionAt = (offset)=>{
+            offset >= this._text.length && (offset = this._text.length - 1), offset < 0 && (offset = 0);
+            let result = find.locationForIndex(offset);
+            if (result) return {
+                line: result.line + 1,
+                column: result.column
+            };
+        }, this.offsetAt = (position)=>find.indexForLocation({
+                line: position.line - 1,
+                column: position.column
+            }) ?? void 0;
+    }
+    getText(range) {
+        if (!range) return this._text;
+        let start = 'number' == typeof range.start ? range.start : this.offsetAt(range.start), end = 'number' == typeof range.end ? range.end : this.offsetAt(range.end);
+        if (Lodash.isUndefined(start)) throw Error(`Location ${JSON.stringify(start)} is illegal`);
+        if (Lodash.isUndefined(end)) throw Error(`Location ${JSON.stringify(end)} is illegal`);
+        return this._text.slice(start, end);
+    }
+    edit(data) {
+        let { _text: content } = this, startOffset = Lodash.isNumber(data.start) ? data.start : this.offsetAt(data.start), endOffset = Lodash.isNumber(data.end) ? data.end : this.offsetAt(data.end);
+        if (Lodash.isUndefined(startOffset) || Lodash.isUndefined(endOffset)) return;
+        let startTxt = content.substring(0, startOffset), endTxt = content.substring(endOffset, content.length);
+        return startTxt + data.newText + endTxt;
+    }
+}
+let store = new Map();
+function getDocument(content) {
+    if (store.has(content)) return store.get(content);
+    let doc = new Document(content);
+    return store.set(content, doc), doc;
+}
+function isSyntaxNode(node) {
+    return Lodash.isObject(node) && 'type' in node;
+}
+function assertCreator(type) {
+    return (node)=>isSyntaxNode(node) && node.type === type;
+}
+let asserts = {
+    isProgram: assertCreator('Program'),
+    isEmptyStatement: assertCreator('EmptyStatement'),
+    isBlockStatement: assertCreator('BlockStatement'),
+    isStaticBlock: assertCreator('StaticBlock'),
+    isExpressionStatement: assertCreator('ExpressionStatement'),
+    isIfStatement: assertCreator('IfStatement'),
+    isLabeledStatement: assertCreator('LabeledStatement'),
+    isBreakStatement: assertCreator('BreakStatement'),
+    isContinueStatement: assertCreator('ContinueStatement'),
+    isWithStatement: assertCreator('WithStatement'),
+    isSwitchStatement: assertCreator('SwitchStatement'),
+    isReturnStatement: assertCreator('ReturnStatement'),
+    isThrowStatement: assertCreator('ThrowStatement'),
+    isTryStatement: assertCreator('TryStatement'),
+    isWhileStatement: assertCreator('WhileStatement'),
+    isDoWhileStatement: assertCreator('DoWhileStatement'),
+    isForStatement: assertCreator('ForStatement'),
+    isForInStatement: assertCreator('ForInStatement'),
+    isForOfStatement: assertCreator('ForOfStatement'),
+    isDebuggerStatement: assertCreator('DebuggerStatement'),
+    isFunctionDeclaration: assertCreator('FunctionDeclaration'),
+    isVariableDeclaration: assertCreator('VariableDeclaration'),
+    isVariableDeclarator: assertCreator('VariableDeclarator'),
+    isChainExpression: assertCreator('ChainExpression'),
+    isThisExpression: assertCreator('ThisExpression'),
+    isArrayExpression: assertCreator('ArrayExpression'),
+    isObjectExpression: assertCreator('ObjectExpression'),
+    isPrivateIdentifier: assertCreator('PrivateIdentifier'),
+    isProperty: assertCreator('Property'),
+    isPropertyDefinition: assertCreator('PropertyDefinition'),
+    isFunctionExpression: assertCreator('FunctionExpression'),
+    isSequenceExpression: assertCreator('SequenceExpression'),
+    isUnaryExpression: assertCreator('UnaryExpression'),
+    isBinaryExpression: assertCreator('BinaryExpression'),
+    isAssignmentExpression: assertCreator('AssignmentExpression'),
+    isUpdateExpression: assertCreator('UpdateExpression'),
+    isLogicalExpression: assertCreator('LogicalExpression'),
+    isConditionalExpression: assertCreator('ConditionalExpression'),
+    isNewExpression: assertCreator('NewExpression'),
+    isSwitchCase: assertCreator('SwitchCase'),
+    isCatchClause: assertCreator('CatchClause'),
+    isIdentifier: assertCreator('Identifier'),
+    isLiteral: assertCreator('Literal'),
+    isSuper: assertCreator('Super'),
+    isSpreadElement: assertCreator('SpreadElement'),
+    isArrowFunctionExpression: assertCreator('ArrowFunctionExpression'),
+    isYieldExpression: assertCreator('YieldExpression'),
+    isTemplateLiteral: assertCreator('TemplateLiteral'),
+    isTaggedTemplateExpression: assertCreator('TaggedTemplateExpression'),
+    isTemplateElement: assertCreator('TemplateElement'),
+    isObjectPattern: assertCreator('ObjectPattern'),
+    isArrayPattern: assertCreator('ArrayPattern'),
+    isRestElement: assertCreator('RestElement'),
+    isAssignmentPattern: assertCreator('AssignmentPattern'),
+    isClassBody: assertCreator('ClassBody'),
+    isClassDeclaration: assertCreator('ClassDeclaration'),
+    isClassExpression: assertCreator('ClassExpression'),
+    isMetaProperty: assertCreator('MetaProperty'),
+    isImportDeclaration: assertCreator('ImportDeclaration'),
+    isImportSpecifier: assertCreator('ImportSpecifier'),
+    isImportExpression: assertCreator('ImportExpression'),
+    isImportDefaultSpecifier: assertCreator('ImportDefaultSpecifier'),
+    isImportNamespaceSpecifier: assertCreator('ImportNamespaceSpecifier'),
+    isExportNamedDeclaration: assertCreator('ExportNamedDeclaration'),
+    isExportSpecifier: assertCreator('ExportSpecifier'),
+    isExportDefaultDeclaration: assertCreator('ExportDefaultDeclaration'),
+    isExportAllDeclaration: assertCreator('ExportAllDeclaration'),
+    isAwaitExpression: assertCreator('AwaitExpression'),
+    isMethodDefinition: assertCreator('MethodDefinition'),
+    isMemberExpression: assertCreator('MemberExpression'),
+    isComment: (node)=>isSyntaxNode(node) && ('Line' === node.type || 'Block' === node.type),
+    isDirective: (node)=>asserts.isExpressionStatement(node) && 'directive' in node,
+    isSimpleCallExpression: (node)=>isSyntaxNode(node) && 'CallExpression' === node.type,
+    isAssignmentProperty: (node)=>asserts.isProperty(node) && 'init' === node.kind,
+    isSimpleLiteral: (node)=>asserts.isLiteral(node) && !asserts.isRegExpLiteral(node) && !asserts.isBigIntLiteral(node),
+    isRegExpLiteral: (node)=>asserts.isLiteral(node) && 'regex' in node,
+    isBigIntLiteral: (node)=>asserts.isLiteral(node) && 'bigint' in node,
+    isExportStatement: (node)=>asserts.isExportAllDeclaration(node) || asserts.isExportDefaultDeclaration(node) || asserts.isExportNamedDeclaration(node)
+};
+function getDefaultImports(node) {
+    return node.body.filter((statement)=>{
+        if ('ImportDeclaration' !== statement.type) return !1;
+        let specifier = statement?.specifiers?.[0];
+        return specifier?.type === 'ImportDefaultSpecifier';
+    });
+}
+function getIdentifierInPattern(name, node) {
+    if (asserts.isIdentifier(node) && node.name === name) return node;
+    if (asserts.isObjectPattern(node)) for (let prop of node.properties){
+        if (asserts.isAssignmentProperty(prop)) return getIdentifierInPattern(name, prop.value);
+        if (asserts.isRestElement(prop)) return getIdentifierInPattern(name, prop);
+    }
+    if (asserts.isArrayPattern(node)) {
+        for (let el of node.elements)if (el) {
+            let result = getIdentifierInPattern(name, el);
+            if (result) return result;
+        }
+    }
+    return asserts.isRestElement(node) ? getIdentifierInPattern(name, node.argument) : asserts.isAssignmentPattern(node) ? getIdentifierInPattern(name, node.left) : void 0;
+}
+function getIdentifierInDeclaration(name, node) {
+    var node1;
+    return asserts.isFunctionDeclaration(node) || asserts.isClassDeclaration(node) ? (node1 = node, asserts.isIdentifier(node1.id) && node1.id.name === name ? node1.id : void 0) : asserts.isVariableDeclaration(node) ? node.declarations.find((item)=>getIdentifierInPattern(name, item.id))?.id : void 0;
+}
+function getIdentifierInImport(name, node) {
+    if (asserts.isImportDeclaration(node)) {
+        for (let specifier of node.specifiers ?? [])if (specifier.local.name === name) return specifier.local;
+    }
+}
+function getIdentifierInExport(name, node) {
+    if (asserts.isExportNamedDeclaration(node)) {
+        if (node.declaration) return getIdentifierInDeclaration(name, node.declaration);
+        for (let specifier of node.specifiers ?? [])if (specifier.exported.name === name) return specifier.exported;
+    }
+    if (asserts.isExportAllDeclaration(node) && node.exported && node.exported.name === name) return node.exported;
+}
+function canParse(code, ecmaVersion) {
+    try {
+        return parse(code, {
+            ecmaVersion,
+            sourceType: 'number' == typeof ecmaVersion && ecmaVersion <= 5 ? "script" : 'module'
+        }), !0;
+    } catch  {
+        return !1;
+    }
+}
+function isES5(code) {
+    return canParse(code, 5);
+}
+function isES6(code) {
+    return canParse(code, 6);
+}
+function detectECMAVersion(code) {
+    return isES6(code) ? isES5(code) ? "ES5" : "ES6" : "ES7+";
+}
+let acornParserInternal = Parser.extend(importAttributes), acornParserExport = Parser.extend(importAttributes), parser = {
+    walk: __rspack_external_acorn_walk_1e4235a7,
+    parse: (input, options)=>acornParserExport.parse(input, options),
+    parseExpressionAt: (input, pos, options)=>acornParserExport.parseExpressionAt(input, pos, options),
+    extend: (...args)=>acornParserExport = acornParserExport.extend(...args),
+    asserts: asserts,
+    utils: utils_namespaceObject,
+    internal: {
+        parse: (input, options)=>acornParserInternal.parse(input, options),
+        parseExpressionAt: (input, pos, options)=>acornParserInternal.parseExpressionAt(input, pos, options)
+    }
+}, parseBundle = (bundlePath, modulesData)=>{
+    let modules;
+    if (bundlePath.indexOf('.worker.') > 0) return {};
+    let ext = extname(bundlePath);
+    if (!Constants.JSExtensions.includes(ext)) return {};
+    let content = fs.readFileSync(bundlePath, 'utf8'), tagCache = new Map(), hasBannerPlugin = (content = content.replace(/\/\/# sourceMappingURL=[^\n]*$/m, '')).indexOf('RSDOCTOR_START::') > 0;
+    if (hasBannerPlugin && !tagCache.get(bundlePath)) {
+        let tagMatchResult = function(raw, start, end) {
+            try {
+                let matchStart = raw.match(start), startFlagIndex = matchStart?.length ? raw.indexOf(matchStart[0], 0) : -1;
+                if (-1 === startFlagIndex || !matchStart?.length) return {
+                    result: null,
+                    remain: 0
+                };
+                let startTagLength = matchStart[0].length, matchEnd = raw.match(end), endFlagIndex = matchEnd?.length ? raw.indexOf(matchEnd[0], startFlagIndex + startTagLength) : -1;
+                if (-1 === endFlagIndex || !matchEnd?.length) return {
+                    result: null,
+                    remain: 0
+                };
+                let innerContent = raw.slice(startFlagIndex + startTagLength, endFlagIndex).trim();
+                return innerContent.endsWith(',') && (innerContent = innerContent.slice(0, -1)), {
+                    result: innerContent,
+                    remain: matchEnd?.length ? endFlagIndex + matchEnd[0].length : endFlagIndex,
+                    loc: {
+                        start: startFlagIndex + startTagLength,
+                        end: endFlagIndex
+                    }
+                };
+            } catch (e) {
+                return rsdoctorLogger.debug(()=>e), {
+                    result: null,
+                    remain: 0
+                };
+            }
+        }(content, /([a-z|A-Z|_]+\.[a-z]+)\(\SRSDOCTOR_START::(.*?)[;,]/, /([a-z|A-Z|_]+\.[a-z]+)\(\SRSDOCTOR_END::(.*?)\)/);
+        content = tagMatchResult.result?.trim() || content, tagCache.set(bundlePath, tagMatchResult.loc), hasBannerPlugin = !0;
+    } else if (hasBannerPlugin && tagCache.get(bundlePath)) {
+        let loc = tagCache.get(bundlePath);
+        content = content.slice(loc.start, loc.end), hasBannerPlugin = !0;
+    }
+    let ast = parser.internal.parse(content, {
+        sourceType: "script",
+        ecmaVersion: 'latest'
+    }), walkState = {
+        locations: null,
+        expressionStatementDepth: 0
+    };
+    parser.walk.recursive(ast, walkState, {
+        ExpressionStatement (node, state, c) {
+            if (!state.locations) {
+                state.expressionStatementDepth++;
+                try {
+                    var node1, node2;
+                    if (1 === state.expressionStatementDepth && (node1 = node, 'ExpressionStatement' === node1.type && ('CallExpression' === node1.expression.type || 'UnaryExpression' === node1.expression.type && 'CallExpression' === node1.expression.argument.type))) {
+                        let fn = (node2 = node, 'UnaryExpression' === node2.expression.type ? node2.expression.argument : node2.expression);
+                        if (0 === fn.arguments.length && 0 === fn.callee.params.length) {
+                            let firstVariableDeclaration = fn.callee.body.body.find((node)=>'VariableDeclaration' === node.type);
+                            if (firstVariableDeclaration) {
+                                for (let declaration of firstVariableDeclaration.declarations)if (declaration.init && (state.locations = getModulesLocations(declaration.init), state.locations)) break;
+                            }
+                        }
+                    }
+                    state.locations || c(node.expression, state);
+                } catch (e) {
+                    rsdoctorLogger.debug(e);
+                }
+                state.expressionStatementDepth--;
+            }
+        },
+        Program (node, state, _c) {
+            if (!state.locations) {
+                try {
+                    if (hasBannerPlugin) {
+                        let firstVariableDeclaration = node.body.find((node)=>'VariableDeclaration' === node.type && node.declarations?.[0]?.init?.type === 'ObjectExpression' && node.declarations?.[0]?.init?.properties?.length);
+                        if (firstVariableDeclaration) {
+                            for (let declaration of firstVariableDeclaration.declarations)if (declaration.init && (state.locations = getModulesLocations(declaration.init), state.locations)) break;
+                        }
+                    }
+                    state.locations || node.body.forEach((n)=>_c(n, state));
+                } catch (e) {
+                    rsdoctorLogger.debug(e);
+                }
+                state.expressionStatementDepth--;
+            }
+        },
+        AssignmentExpression (node, state) {
+            if (state.locations) return;
+            let { left, right } = node;
+            left?.object && 'exports' === left.object.name && left.property && 'modules' === left.property.name && isModulesHash(right) && (state.locations = getModulesLocations(right));
+        },
+        CallExpression (node, state, c) {
+            var node1;
+            if (state.locations) return;
+            let args = node.arguments;
+            if ('FunctionExpression' === node.callee.type && !node.callee.id && 1 === args.length && (isModulesHash(node1 = args[0]) || isModulesArray(node1))) {
+                state.locations = getModulesLocations(args[0]);
+                return;
+            }
+            if ('Identifier' === node.callee.type && mayBeAsyncChunkArguments(args) && isModulesList(args[1])) {
+                state.locations = getModulesLocations(args[1]);
+                return;
+            }
+            if (function(node) {
+                let { callee, arguments: args } = node;
+                return 'MemberExpression' === callee.type && 'push' === callee.property.name && 'AssignmentExpression' === callee.object.type && 1 === args.length && 'ArrayExpression' === args[0].type && mayBeAsyncChunkArguments(args[0].elements) && isModulesList(args[0].elements[1]);
+            }(node)) {
+                state.locations = getModulesLocations(args[0].elements[1]);
+                return;
+            }
+            if (function(node) {
+                let { callee, type, arguments: args } = node;
+                return 'CallExpression' === type && 'MemberExpression' === callee.type && 2 === args.length && isChunkIds(args[0]) && isModulesList(args[1]);
+            }(node)) {
+                state.locations = getModulesLocations(args[1]);
+                return;
+            }
+            args.forEach((arg)=>c(arg, state));
+        }
+    });
+    let modulesObj = {};
+    for(let module in modules = walkState.locations ? mapValues(walkState.locations, (loc)=>content.slice(loc.start, loc.end)) : {}){
+        if (!module) return {};
+        let moduleContent = modules[module], size = moduleContent && Buffer.byteLength(moduleContent);
+        modulesObj[collection_find(modulesData, (item)=>item.renderId === module)?.identifier || ''] = {
+            size,
+            sizeConvert: filesize(size || 0),
+            content: moduleContent
+        };
+    }
+    return {
+        modules: modulesObj,
+        src: content,
+        runtimeSrc: function(content, modulesLocations) {
+            let sortedLocations = Object.values(modulesLocations || {}).sort((a, b)=>a.start - b.start), result = '', lastIndex = 0;
+            for (let { start, end } of sortedLocations)result += content.slice(lastIndex, start), lastIndex = end;
+            return result + content.slice(lastIndex, content.length);
+        }(content, walkState.locations)
+    };
+};
+function isModulesList(node) {
+    var node1, node2;
+    return isModulesHash(node1 = node) || isModulesArray(node1) || 'CallExpression' === (node2 = node).type && 'MemberExpression' === node2.callee.type && 'CallExpression' === node2.callee.object.type && 'Identifier' === node2.callee.object.callee.type && 'Array' === node2.callee.object.callee.name && 1 === node2.callee.object.arguments.length && isNumericId(node2.callee.object.arguments[0]) && 'Identifier' === node2.callee.property.type && 'concat' === node2.callee.property.name && 1 === node2.arguments.length && isModulesArray(node2.arguments[0]);
+}
+function isModulesHash(node) {
+    return 'ObjectExpression' === node.type && node.properties.map((node)=>node.value).every(isModuleWrapper);
+}
+function isModulesArray(node) {
+    return 'ArrayExpression' === node.type && node.elements.every((elem)=>!elem || isModuleWrapper(elem));
+}
+function isModuleWrapper(node) {
+    return ('FunctionExpression' === node.type || 'ArrowFunctionExpression' === node.type) && !node.id || isModuleId(node) || 'ArrayExpression' === node.type && node.elements.length > 1 && isModuleId(node.elements[0]);
+}
+function isModuleId(node) {
+    return 'Literal' === node.type && (isNumericId(node) || 'string' == typeof node.value);
+}
+function isNumericId(node) {
+    return 'Literal' === node.type && Number.isInteger(node.value) && node.value >= 0;
+}
+function isChunkIds(node) {
+    return 'ArrayExpression' === node.type && node.elements.every(isModuleId);
+}
+function mayBeAsyncChunkArguments(args) {
+    return args.length >= 2 && isChunkIds(args[0]);
+}
+function getModulesLocations(node) {
+    if ('ObjectExpression' === node.type) return node.properties.reduce((result, moduleNode)=>(result[moduleNode.key.name || moduleNode.key.value] = getModuleLocation(moduleNode.value), result), {});
+    let isOptimizedArray = 'CallExpression' === node.type;
+    if ('ArrayExpression' === node.type || isOptimizedArray) {
+        let minId = isOptimizedArray ? node.callee.object.arguments[0].value : 0;
+        return (isOptimizedArray ? node.arguments[0].elements : node.elements).reduce((result, moduleNode, i)=>(moduleNode && (result[i + minId] = getModuleLocation(moduleNode)), result), {});
+    }
+    return {};
+}
+function getModuleLocation(node) {
+    return {
+        start: node.start,
+        end: node.end
+    };
+}
+function setSDK(t) {
+    globalThis.__rsdoctor_sdks__ || (globalThis.__rsdoctor_sdks__ = []), globalThis.__rsdoctor_sdks__.push(t), globalThis.__rsdoctor_sdk__ = t;
+}
+function getSDK(builderName) {
+    let sdks = globalThis.__rsdoctor_sdks__ || [], sdk = globalThis.__rsdoctor_sdk__;
+    if (sdk && sdk.name !== builderName && (sdk = builderName && sdks.find((s)=>s.name === builderName) || sdk), sdk && builderName && 'parent' in sdk) {
+        let parent = sdk.parent;
+        return parent?.slaves.find((_sdk)=>_sdk.name === builderName) || sdk;
+    }
+    return sdk;
+}
+export default function(...args) {
+    let time = Date.now(), code = args[0], _options = this.getOptions(), sdk = getSDK(_options.builderName), loaderData = {
+        resource: {
+            path: this._module?.layer ? `${this.resourcePath}[${this._module.layer}]` : this.resourcePath,
+            query: parseQuery(this.resourceQuery),
+            queryRaw: this.resourceQuery,
+            ext: path_0.extname(this.resourcePath).slice(1),
+            ...this._module?.layer ? {
+                layer: this._module.layer
+            } : {}
+        },
+        loaders: [
+            {
+                loader: _options.loader,
+                loaderIndex: this.loaderIndex,
+                path: _options.loader,
+                input: 'start' === _options.type ? code : null,
+                result: 'end' === _options.type ? code : null,
+                startAt: 'start' === _options.type ? time : 0,
+                endAt: 'end' === _options.type ? time : 0,
+                options: omit(_options.options, 'type'),
+                isPitch: !1,
+                sync: !1,
+                errors: [],
+                pid: process.pid,
+                ppid: process.ppid
+            }
+        ]
+    };
+    sdk?.reportLoaderStartOrEnd(loaderData), this.callback(null, ...args);
+};
+export { addProbeLoader2Rules, color, createLoaderContextTrap, extractLoaderName, filesize, getDocument, getLoaderNameMatch, getSDK, interceptCompilationHooks, interceptCompilerHooks, isESMLoader, loadLoaderModule, logger_time, mapEachRules, parseBundle, parseQuery, parser, rsdoctorLogger as logger, setSDK, stringify, timeEnd };