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

package/dist/build-utils/build/loader/probeLoader.js

@@ -1,44 +0,0 @@
-import "node:module";
-import { parseQuery } from "../utils/index.js";
-import { getSDK } from "../../../inner-plugins/utils/sdk.js";
-import { omit } from "../../../collection.js";
-import path from "path";
-const loaderModule = function(...args) {
-    const time = Date.now();
-    const code = args[0];
-    const _options = this.getOptions();
-    const sdk = getSDK(_options.builderName);
-    const loaderData = {
-        resource: {
-            path: this._module?.layer ? `${this.resourcePath}[${this._module.layer}]` : this.resourcePath,
-            query: parseQuery(this.resourceQuery),
-            queryRaw: this.resourceQuery,
-            ext: path.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: false,
-                sync: false,
-                errors: [],
-                pid: process.pid,
-                ppid: process.ppid
-            }
-        ]
-    };
-    sdk?.reportLoaderStartOrEnd(loaderData);
-    this.callback(null, ...args);
-};
-const probeLoader = loaderModule;
-export default probeLoader;
-export { loaderModule };

package/dist/build-utils/build/loader/probeLoaderPlugin.js

@@ -1,32 +0,0 @@
-import "node:module";
-import { Loader } from "../../../common/index.js";
-import { Build } from "../../index.js";
-import { Utils } from "../index.js";
-const BuiltinLoaderName = 'builtin:swc-loader';
-const BuiltinLightingCssName = 'builtin:lightningcss-loader';
-const ESMLoaderFile = '.mjs';
-class ProbeLoaderPlugin {
-    apply(compiler) {
-        compiler.hooks.beforeRun.tap({
-            name: 'ProbeLoaderPlugin'
-        }, ()=>{
-            this.addProbeLoader(compiler);
-        });
-        compiler.hooks.watchRun.tap({
-            name: 'ProbeLoaderPlugin'
-        }, ()=>{
-            this.addProbeLoader(compiler);
-        });
-    }
-    addProbeLoader(compiler) {
-        let rules = compiler.options.module.rules;
-        if (Loader.isVue(compiler)) {
-            compiler.options.module.rules = Utils.addProbeLoader2Rules(rules, compiler, (r)=>!!r.loader || 'string' == typeof r);
-            return;
-        }
-        rules = Utils.addProbeLoader2Rules(rules, compiler, (r)=>Build.Utils.getLoaderNameMatch(r, BuiltinLoaderName, true));
-        rules = Utils.addProbeLoader2Rules(rules, compiler, (r)=>Build.Utils.getLoaderNameMatch(r, BuiltinLightingCssName, true));
-        compiler.options.module.rules = Utils.addProbeLoader2Rules(rules, compiler, (r)=>Build.Utils.getLoaderNameMatch(r, ESMLoaderFile, false) || Build.Utils.isESMLoader(r));
-    }
-}
-export { ProbeLoaderPlugin };

package/dist/build-utils/build/module-graph/index.js

@@ -1,2 +0,0 @@
-import "node:module";
-export * from "./rspack/transform.js";

package/dist/build-utils/build/module-graph/parser.js

@@ -1,13 +0,0 @@
-import "node:module";
-import { parser } from "../../../rule-utils/index.js";
-const esmLabelStatement = parser.internal.parseExpressionAt('Object.defineProperty(exports, "__esModule", { value: true })', 0, {
-    ecmaVersion: 6,
-    ranges: false,
-    locations: false,
-    sourceType: "script"
-});
-function hasSetEsModuleStatement(program) {
-    const expressions = program.body.filter(parser.asserts.isExpressionStatement).map((item)=>item.expression).filter(parser.asserts.isSimpleCallExpression);
-    return expressions.some((exp)=>parser.utils.isSameSemantics(exp, esmLabelStatement));
-}
-export { hasSetEsModuleStatement };

package/dist/build-utils/build/module-graph/rspack/transform.js

@@ -1,111 +0,0 @@
-import "node:module";
-import { Dependency, Module, extractCodeFromSourceLines, parseLocation } from "../../../../graph/index.js";
-import { SDK } from "@rsdoctor/shared/types";
-const createDependencyKind = (type)=>{
-    if (type.includes('harmony') || 'esm import' === type) return SDK.DependencyKind.ImportStatement;
-    if (type.includes('cjs')) return SDK.DependencyKind.RequireCall;
-    if (type.includes('import()')) return SDK.DependencyKind.DynamicImport;
-    if (type.includes('amd')) return SDK.DependencyKind.AMDRequire;
-    return SDK.DependencyKind.Unknown;
-};
-function patchNativeModuleGraph(mg, cg, rawModuleGraph) {
-    const { modules: rawModules, dependencies: rawDependencies, chunkModules: rawChunkModules } = rawModuleGraph;
-    const modules = rawModules.map((module)=>{
-        const res = new Module(module.identifier, module.path, module.isEntry, 'concatenated' === module.kind ? SDK.ModuleKind.Concatenation : SDK.ModuleKind.Normal, void 0, module.layer);
-        res.setId(module.ukey);
-        return res;
-    });
-    mg.setModules(modules);
-    for (const rawModule of rawModules){
-        const module = mg.getModuleById(rawModule.ukey);
-        if (module) module.setImported(rawModule.imported.map((ukey)=>mg.getModuleById(ukey)).filter(Boolean));
-    }
-    for (const rawModule of rawModules){
-        const module = mg.getModuleById(rawModule.ukey);
-        module.setModules(rawModule.modules.map((ukey)=>mg.getModuleById(ukey)).filter(Boolean));
-    }
-    for (const rawModule of rawModules){
-        const module = mg.getModuleById(rawModule.ukey);
-        if (module) module.setConcatenationModules(rawModule.belongModules.map((ukey)=>mg.getModuleById(ukey)).filter(Boolean));
-    }
-    for (const rawModule of rawModules){
-        const module = mg.getModuleById(rawModule.ukey);
-        if (module) module.setChunks(rawModule.chunks.map((ukey)=>cg.getChunkById(ukey.toString())).filter(Boolean));
-    }
-    for (const rawChunkModule of rawChunkModules){
-        const chunk = cg.getChunkById(rawChunkModule.chunk.toString());
-        if (chunk) chunk.setModules(rawChunkModule.modules.map((ukey)=>mg.getModuleById(ukey)).filter(Boolean));
-    }
-    const deppendencies = rawDependencies.map((dep)=>{
-        const res = new Dependency(dep.request, mg.getModuleById(dep.module), mg.getModuleById(dep.dependency), createDependencyKind(dep.kind));
-        res.setId(dep.ukey);
-        if (void 0 !== dep.kind) res.typeString = dep.kind;
-        return res;
-    });
-    mg.setDependencies(deppendencies);
-    for (const rawModule of rawModules){
-        const module = mg.getModuleById(rawModule.ukey);
-        module.setDependencies(rawModule.dependencies.map((ukey)=>mg.getDependencyById(ukey)).filter(Boolean));
-        if (module && rawModule.bailoutReason) rawModule.bailoutReason.filter((reason)=>!reason.includes('ModuleConcatenation bailout')).forEach((reason)=>module.addBailoutReason(reason));
-        if (module && 'sideEffectsLocations' in rawModule && Array.isArray(rawModule.sideEffectsLocations) && rawModule.sideEffectsLocations.length) rawModule.sideEffectsLocations.forEach((item)=>{
-            module.addSideEffectLocation({
-                location: item.location,
-                nodeType: item.nodeType,
-                module: item.module,
-                request: item.request
-            });
-        });
-    }
-    const rawConnectionsOnlyImports = rawModuleGraph.connectionsOnlyImports;
-    if (rawConnectionsOnlyImports?.length) mg.setConnectionsOnlyImports(rawConnectionsOnlyImports);
-}
-function patchNativeModuleIds(mg, rawModuleIdsPatch) {
-    const { moduleIds: rawModuleIds } = rawModuleIdsPatch;
-    for (const rawModuleId of rawModuleIds){
-        const module = mg.getModuleById(rawModuleId.module);
-        if (module) module.setRenderId(rawModuleId.renderId);
-    }
-}
-function patchNativeModuleSources(mg, rawModuleSourcesPatch) {
-    const { moduleOriginalSources: rawModuleOriginalSources } = rawModuleSourcesPatch;
-    for (const rawModuleOriginalSource of rawModuleOriginalSources){
-        const module = mg.getModuleById(rawModuleOriginalSource.module);
-        if (module) {
-            module.setSource({
-                source: rawModuleOriginalSource.source
-            });
-            module.setSize({
-                sourceSize: rawModuleOriginalSource.size
-            });
-        }
-    }
-    const jsonModuleSizes = rawModuleSourcesPatch.jsonModuleSizes;
-    if (jsonModuleSizes && jsonModuleSizes.length > 0) for (const jsonModuleSize of jsonModuleSizes){
-        const module = mg.getModuleByIdentifier(jsonModuleSize.identifier);
-        if (module) module.setSize({
-            parsedSize: jsonModuleSize.size
-        });
-    }
-}
-function extractSideEffectCodes(mg) {
-    const modules = mg.getModules();
-    for (const module of modules){
-        const sideEffectLocations = module.getSideEffectLocations();
-        if (!sideEffectLocations.length) continue;
-        const moduleSource = module.getSource();
-        const source = moduleSource.source || moduleSource.parsedSource;
-        if (!source) continue;
-        const sourceLines = source.split('\n');
-        for (const sideEffectLocation of sideEffectLocations){
-            const parsedLocation = parseLocation(sideEffectLocation.location);
-            if (!parsedLocation) continue;
-            const code = extractCodeFromSourceLines(sourceLines, parsedLocation);
-            if (code) module.addSideEffectCode({
-                moduleId: module.id,
-                startLine: parsedLocation.startLine,
-                code
-            });
-        }
-    }
-}
-export { extractSideEffectCodes, patchNativeModuleGraph, patchNativeModuleIds, patchNativeModuleSources };

package/dist/build-utils/build/module-graph/utils.js

@@ -1,60 +0,0 @@
-import "node:module";
-import { parser } from "../../../rule-utils/index.js";
-function getDefaultExportIdentifier(node, module, searchId) {
-    const { declaration } = node;
-    if (parser.asserts.isLiteral(declaration) && declaration.loc) return module.getStatement(declaration.loc);
-    if (parser.asserts.isIdentifier(declaration)) {
-        if (searchId) {
-            const result = getDeclarationIdentifier(declaration.name, module);
-            if (result) return result;
-        } else if (declaration.loc) return module.getStatement(declaration.loc);
-    }
-    if (parser.asserts.isClassDeclaration(declaration) || parser.asserts.isFunctionDeclaration(declaration)) {
-        if (declaration.id?.loc) return module.getStatement(declaration.id.loc);
-    }
-    const startLine = node.declaration.loc?.start.line;
-    if ('number' != typeof startLine) return;
-    const { transformed } = module.getSource();
-    const line = transformed.split('\n')[startLine - 1];
-    if (void 0 === line) return;
-    const endColumn = line.length - 1;
-    return module.getStatement({
-        start: {
-            line: startLine,
-            column: 0
-        },
-        end: {
-            line: startLine,
-            column: endColumn
-        }
-    });
-}
-function getExportIdentifierStatement(name, module) {
-    const ast = module.getProgram();
-    if (!ast) return;
-    for (const node of ast.body){
-        if (parser.asserts.isExportDefaultDeclaration(node)) {
-            const result = getDefaultExportIdentifier(node, module, false);
-            if (result) return result;
-        }
-        const id = parser.utils.getIdentifierInExport(name, node);
-        if (id?.loc) return module.getStatement(id.loc);
-    }
-}
-function getDeclarationIdentifier(name, module) {
-    const ast = module.getProgram();
-    if (!ast) return;
-    for (const node of ast.body){
-        const id = parser.utils.getIdentifierInDeclaration(name, node);
-        if (id?.loc) return module.getStatement(id.loc);
-        if (parser.asserts.isExportNamedDeclaration(node) && node.declaration) {
-            const id = parser.utils.getIdentifierInDeclaration(name, node.declaration);
-            if (id?.loc) return module.getStatement(id.loc);
-        }
-        if ('default' === name && parser.asserts.isExportDefaultDeclaration(node)) {
-            const result = getDefaultExportIdentifier(node, module, true);
-            if (result) return result;
-        }
-    }
-}
-export { getDeclarationIdentifier, getExportIdentifierStatement };

package/dist/build-utils/build/process.js

@@ -1,18 +0,0 @@
-import "node:module";
-import { filesize } from "filesize";
-import { memoryUsage, pid } from "process";
-function getMemoryUsage() {
-    return memoryUsage();
-}
-function getMemoryUsageMessage() {
-    const usage = getMemoryUsage();
-    const msgs = [
-        `RSS: ${filesize(usage.rss)}`,
-        `Heap Total: ${filesize(usage.heapTotal)}`,
-        `Heap Used: ${filesize(usage.heapUsed)}`
-    ];
-    if (usage.arrayBuffers) msgs.push(`ArrayBuffers: ${filesize(usage.arrayBuffers)}`);
-    if (usage.external) msgs.push(`External: ${filesize(usage.external)}`);
-    return `["${pid}" Memory Usage] ${msgs.join(', ')}`;
-}
-export { getMemoryUsage, getMemoryUsageMessage };

package/dist/build-utils/build/server.js

@@ -1,107 +0,0 @@
-import "node:module";
-import connect from "connect";
-import http from "http";
-import os from "os";
-import get_port from "get-port";
-import { execFileSync } from "child_process";
-import { Algorithm } from "../../common/index.js";
-const RESTRICTED_PORTS = [
-    3659,
-    4045,
-    6000,
-    6665,
-    6666,
-    6667,
-    6668,
-    6669
-];
-const defaultHost = '127.0.0.1';
-function getRandomPort(min, max) {
-    let port;
-    do port = Algorithm.random(min, max);
-    while (RESTRICTED_PORTS.includes(port));
-    return port;
-}
-const defaultPort = getRandomPort(3000, 8999);
-async function getPort(expectPort, host = defaultHost) {
-    return get_port({
-        port: expectPort,
-        host
-    });
-}
-const createGetPortSyncFunctionString = (expectPort, host = defaultHost)=>`
-(() => {
-const net = require('net');
-
-function getPort(expectPort, host) {
-  return new Promise((resolve, reject) => {
-    const server = net.createServer();
-    server.unref();
-    server.on('error', reject);
-    server.listen(expectPort, host, () => {
-      const { port } = server.address();
-      server.close(() => {
-        resolve(port);
-      });
-    });
-  });
-}
-
-async function getAvailablePort(expectPort) {
-  let port = expectPort;
-  while (true) {
-    try {
-      const res = await getPort(port, ${JSON.stringify(host)});
-      return res;
-    } catch (error) {
-      port += Math.floor(Math.random() * 100 + 1);
-    }
-  }
-}
-
-getAvailablePort(${expectPort}).then(port => process.stdout.write(port.toString()));
-})();
-`.trim();
-function getPortSync(expectPort, host = defaultHost) {
-    const statement = '\n' === os.EOL ? createGetPortSyncFunctionString(expectPort, host) : createGetPortSyncFunctionString(expectPort, host).replace(/\n/g, '');
-    const port = execFileSync(process.execPath, [
-        '-e',
-        statement
-    ], {
-        encoding: 'utf-8'
-    });
-    return Number(port);
-}
-function createApp() {
-    return connect();
-}
-async function createServer(port, host = defaultHost) {
-    const app = createApp();
-    const server = http.createServer(app);
-    const res = {
-        app,
-        server,
-        port,
-        close () {
-            return new Promise((resolve, reject)=>{
-                if ('closeAllConnections' in server) server.closeAllConnections();
-                if ('closeIdleConnections' in server) server.closeIdleConnections();
-                server.close((err)=>{
-                    if (err) reject(err);
-                    resolve();
-                });
-            });
-        }
-    };
-    return new Promise((resolve, reject)=>{
-        const onError = (error)=>{
-            reject(error);
-        };
-        server.once('error', onError);
-        server.listen(port, host, ()=>{
-            server.off('error', onError);
-            resolve(res);
-        });
-    });
-}
-export { createApp, createGetPortSyncFunctionString, createServer, defaultHost, defaultPort, getPort, getPortSync };

package/dist/build-utils/build/utils/index.js

@@ -1,4 +0,0 @@
-import "node:module";
-export * from "./loader.js";
-export * from "./plugin.js";
-export * from "./parseBundle.js";

package/dist/build-utils/build/utils/loader.js

@@ -1,267 +0,0 @@
-import "node:module";
-import node_path from "node:path";
-import { fileURLToPath } from "node:url";
-import { createRequire } from "node:module";
-import fs_extra from "fs-extra";
-import { omit } from "../../../collection.js";
-import { Loader } from "../../../common/index.js";
-import { readPackageJson } from "../json.js";
-import { logger } from "../../../logger.js";
-const loader_filename = fileURLToPath(import.meta.url);
-const loader_dirname = node_path.dirname(loader_filename);
-const loader_require = createRequire(import.meta.url);
-const PATH_QUERY_FRAGMENT_REGEXP = /^((?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/;
-function parsePathQueryFragment(str) {
-    const 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()) {
-    const cleanLoaderPath = parsePathQueryFragment(loaderPath).path;
-    const mod = loader_require(process.env.DOCTOR_TEST ? node_path.resolve(cwd, cleanLoaderPath) : loader_require.resolve(cleanLoaderPath, {
-        paths: [
-            cwd,
-            node_path.resolve(cwd, 'node_modules')
-        ]
-    }));
-    const isESM = mod.__esModule && 'function' == typeof mod.default;
-    return {
-        default: isESM ? mod.default : 'function' == typeof mod ? mod : null,
-        pitch: mod.default?.pitch || mod.pitch,
-        raw: mod.default?.raw || mod.raw || false
-    };
-}
-function extractLoaderName(loaderPath, cwd = '') {
-    let res = loaderPath.replace(cwd, '');
-    if (!node_path.isAbsolute(res)) return res;
-    const nms = '/node_modules/';
-    const idx = res.lastIndexOf(nms);
-    if (-1 !== idx) {
-        res = res.slice(idx + nms.length);
-        const ln = 'loader';
-        const lnIdx = res.lastIndexOf(ln);
-        if (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)) {
-            const { 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) {
-                const funcUse = rule.use;
-                const newRule = {
-                    ...rule,
-                    use: (...args)=>{
-                        const rules = funcUse(...args);
-                        return mapEachRules(rules, callback);
-                    }
-                };
-                return newRule;
-            }
-            if (Array.isArray(rule.use)) return {
-                ...rule,
-                use: mapEachRules(rule.use, callback)
-            };
-            return {
-                ...rule,
-                use: mapEachRules([
-                    rule.use
-                ], callback)
-            };
-        }
-        if ('rules' in rule && Array.isArray(rule.rules)) return {
-            ...rule,
-            rules: mapEachRules(rule.rules, callback)
-        };
-        if (Array.isArray(rule.oneOf)) return {
-            ...rule,
-            oneOf: mapEachRules(rule.oneOf, callback)
-        };
-        return rule;
-    });
-}
-function isESMLoader(r) {
-    const _loaderName = 'object' == typeof r && 'string' == typeof r?.loader ? r.loader : 'string' == typeof r ? r : '';
-    if (!_loaderName) return false;
-    const isPath = node_path.isAbsolute(_loaderName) || _loaderName.startsWith('./') || _loaderName.startsWith('../');
-    if (isPath) {
-        const packageJsonData = readPackageJson(_loaderName, (file)=>{
-            try {
-                return fs_extra.readJsonSync(file, {
-                    encoding: 'utf8'
-                });
-            } catch (e) {
-                logger.debug(`isESMLoader function error：${e}`);
-            }
-        });
-        if (packageJsonData?.type === 'module' && !packageJsonData?.name.includes('@rsdoctor/')) return true;
-    }
-    return false;
-}
-function appendProbeLoaders(compiler, loaderConfig) {
-    const _options = 'object' == typeof loaderConfig ? 'string' == typeof loaderConfig.options ? {
-        options: loaderConfig.options
-    } : loaderConfig.options : {};
-    const loaderPath = process.env.DOCTOR_TEST ? node_path.resolve(loader_dirname, '../loader/probeLoader.ts') : loader_require.resolve(node_path.join(loader_dirname, '../loader/probeLoader'));
-    const loader = 'string' == typeof loaderConfig ? loaderConfig : 'object' == typeof loaderConfig && loaderConfig.loader;
-    const 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 = true) {
-    if (!strict) return 'object' == typeof r && 'string' == typeof r?.loader && r.loader.includes(loaderName) || 'string' == typeof r && r.includes(loaderName);
-    return 'object' == typeof r && 'string' == typeof r?.loader && r.loader === loaderName || 'string' == typeof r && r === loaderName;
-}
-function addProbeLoader2Rules(rules, compiler, fn) {
-    return rules.map((rule)=>{
-        if (!rule || 'string' == typeof rule) return rule;
-        if (fn(rule) && !rule.use) {
-            const 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
-            };
-        }
-        if (rule.use) {
-            if (Array.isArray(rule.use)) rule.use = rule.use.flatMap((loaderConfig)=>{
-                if ('string' == typeof loaderConfig || 'object' == typeof loaderConfig && loaderConfig && 'loader' in loaderConfig) return fn(loaderConfig) ? appendProbeLoaders(compiler, loaderConfig) : [
-                    loaderConfig
-                ];
-                return [
-                    loaderConfig
-                ];
-            });
-            else if ('object' != typeof rule.use || Array.isArray(rule.use) || 'function' == typeof rule.use) {
-                if ('string' == typeof rule.use) rule.use = fn(rule.use) ? appendProbeLoaders(compiler, {
-                    loader: rule.use
-                }) : [
-                    {
-                        loader: rule.use
-                    }
-                ];
-            } else if ('loader' in rule.use) rule.use = fn(rule.use) ? appendProbeLoaders(compiler, rule.use) : [
-                rule.use
-            ];
-        }
-        if ('oneOf' in rule && rule.oneOf) return {
-            ...rule,
-            oneOf: addProbeLoader2Rules(rule.oneOf, compiler, fn)
-        };
-        if ('rules' in rule && rule.rules) return {
-            ...rule,
-            rules: addProbeLoader2Rules(rule.rules, compiler, fn)
-        };
-        return rule;
-    });
-}
-function createLoaderContextTrap(final) {
-    const cb = this.callback;
-    let callback = (...args)=>{
-        final(args[0], args[1] ?? null, args[2]);
-        return cb.call(this, ...args);
-    };
-    const ac = this.async;
-    let async = (...args)=>{
-        const cb = ac(...args);
-        return (...args)=>{
-            final(args[0], args[1] ?? null, args[2]);
-            return cb(...args);
-        };
-    };
-    const trap = 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) {
-                            const res = target.query.replace(new RegExp(`"${Loader.LoaderInternalPropertyName}":{[^}]*},{0,1}`), '');
-                            return res;
-                        }
-                        if ('object' == typeof target.query) {
-                            const options = target.query[Loader.LoaderInternalPropertyName];
-                            if (options.hasOptions) return omit(target.query, [
-                                Loader.LoaderInternalPropertyName
-                            ]);
-                            const innerLoaderPath = options?.loader;
-                            const loaderQuery = parsePathQueryFragment(innerLoaderPath).query;
-                            return loaderQuery;
-                        }
-                    }
-                    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':
-                    async = value;
-                    return true;
-                case 'callback':
-                    callback = value;
-                    return true;
-                default:
-                    return Reflect.set(target, key, value, receiver);
-            }
-        },
-        defineProperty (target, p, attrs) {
-            return Reflect.defineProperty(target, p, attrs);
-        }
-    });
-    return trap;
-}
-function parseQuery(query) {
-    if (query.startsWith('?')) query = query.slice(1);
-    const searchParams = new URLSearchParams(query);
-    return Object.fromEntries(searchParams.entries());
-}
-export { addProbeLoader2Rules, createLoaderContextTrap, extractLoaderName, getLoaderNameMatch, isESMLoader, loadLoaderModule, mapEachRules, parsePathQueryFragment, parseQuery };