@rsdoctor/core 1.6.1 → 2.0.0-alpha.1

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

@@ -1,124 +0,0 @@
-import "node:module";
-import node_fs from "node:fs";
-import { ModuleGraphTrans, Webpack } from "@rsdoctor/graph";
-import { hasSetEsModuleStatement } from "../parser.js";
-import { isFunction } from "es-toolkit/compat";
-import { logger } from "@rsdoctor/utils/logger";
-async function readFile(target, wbFs) {
-    if (wbFs?.fs?.readFile) {
-        const result = new Promise((resolve, reject)=>{
-            wbFs.fs.readFile(target, (err, content)=>{
-                if (err) return void reject(err);
-                content ? resolve(Buffer.from(content)) : resolve();
-            });
-        }).catch(()=>{});
-        if (result) return result;
-    }
-    try {
-        return await node_fs.promises.readFile(target);
-    } catch  {
-        logger.debug(`readFile error: ${target}`);
-        return;
-    }
-}
-function getModuleExportsType(module, moduleGraph, strict = false) {
-    if (moduleGraph && 'getExportsType' in module) return module.getExportsType(moduleGraph, strict);
-    return strict ? 'default-with-named' : 'dynamic';
-}
-function appendDependency(webpackDep, module, webpackGraph, graph) {
-    const resolvedWebpackModule = webpackGraph?.getResolvedModule ? webpackGraph.getResolvedModule(webpackDep) : void 0;
-    if (!resolvedWebpackModule) return;
-    const rawRequest = Webpack.getWebpackDependencyRequest(webpackDep, resolvedWebpackModule);
-    const resolveRequest = Webpack.getWebpackModulePath(resolvedWebpackModule);
-    const request = rawRequest ?? resolveRequest;
-    if (!module.getDependencyByRequest(request)) {
-        const depLayer = resolvedWebpackModule.layer || void 0;
-        const depModule = graph.getModuleByFile(resolveRequest, depLayer)[0];
-        if (depModule) {
-            const dep = module.addDependency(request, depModule, ModuleGraphTrans.getImportKind(webpackDep));
-            if (dep) graph.addDependency(dep);
-        }
-    }
-    const dependency = module.getDependencyByRequest(request);
-    if (dependency) {
-        dependency.setBuildMeta({
-            exportsType: getModuleExportsType(resolvedWebpackModule, webpackGraph, module.meta.strictHarmonyModule)
-        });
-        const statement = Webpack.getDependencyPosition(webpackDep, module, false);
-        if (statement) dependency.addStatement(statement);
-        dependency.statements.forEach((state)=>{
-            state.position.source = state.module.getSourceRange(state.position.transformed);
-        });
-    }
-}
-function getModuleSource(modulePath, wbFs, sourceMap) {
-    if (sourceMap) try {
-        const contentFromSourceMap = sourceMap.sourceContentFor(modulePath);
-        if (contentFromSourceMap) return Buffer.from(contentFromSourceMap);
-    } catch (e) {
-        logger.debug(`getModuleSource error: ${e}`);
-    }
-    return readFile(modulePath, wbFs);
-}
-async function appendModuleData(origin, webpackGraph, graph, wbFs, features, context) {
-    const module = graph.getModuleByWebpackId(Webpack.getWebpackModuleId(origin));
-    if (!origin || !module) return;
-    const { getSourceMap, astCache, packagePathMap } = context ?? {};
-    try {
-        const sourceMap = await getSourceMap?.(module.path);
-        const source = await getModuleSource(module.path, wbFs, sourceMap) ?? Buffer.from('');
-        if (sourceMap) module.setSourceMap(sourceMap);
-        if (astCache?.has(origin)) {
-            const program = astCache.get(origin);
-            module.setProgram(program);
-            module.meta.hasSetEsModuleStatement = hasSetEsModuleStatement(program);
-        }
-        const transformed = Webpack.isExternalModule(origin) ? '' : module.getSource().transformed.length > 0 ? module.getSource().transformed : isFunction(origin?.originalSource) ? origin.originalSource()?.source()?.toString() ?? '' : '';
-        const transformedSize = Webpack.isExternalModule(origin) ? 0 : module.getSize().transformedSize > 0 ? module.getSize().transformedSize : Buffer.from(transformed).byteLength;
-        module.setSource({
-            transformed,
-            source: source.toString()
-        });
-        module.setSize({
-            transformedSize,
-            sourceSize: source.byteLength
-        });
-        let packageData;
-        if (packagePathMap && origin.resourceResolveData) {
-            let { descriptionFileRoot: root } = origin.resourceResolveData;
-            const { descriptionFileData: data } = origin.resourceResolveData;
-            if (root && data && data.name && data.version) {
-                if (packagePathMap.has(root)) root = packagePathMap.get(root);
-                else {
-                    const realpath = await node_fs.promises.realpath(root, {
-                        encoding: 'utf-8'
-                    });
-                    root = realpath;
-                    packagePathMap.set(root, realpath);
-                }
-                packageData = {
-                    ...origin.resourceResolveData.descriptionFileData,
-                    root
-                };
-            }
-        }
-        module.meta.strictHarmonyModule = origin.buildMeta?.strictHarmonyModule ?? false;
-        module.meta.packageData = packageData;
-        if (!features?.lite && origin?.dependencies) Array.from(origin.dependencies).filter((item)=>ModuleGraphTrans.isImportDependency(item)).concat(origin.blocks.reduce((ans, item)=>ans.concat(item.dependencies), [])).forEach((dep)=>appendDependency(dep, module, webpackGraph, graph));
-    } catch (e) {
-        console.error(`module ${module.path} transform has error:`, e);
-    }
-}
-async function appendModuleGraphByCompilation(compilation, graph, features, context) {
-    try {
-        const webpackCompilation = compilation;
-        const { moduleGraph: webpackGraph, fileSystemInfo } = webpackCompilation;
-        const allModules = Webpack.getAllModules(webpackCompilation);
-        await Promise.all(allModules.map((module)=>appendModuleData(module, webpackGraph, graph, fileSystemInfo, features, context)));
-        ModuleGraphTrans.removeNoImportStyle(graph);
-        return graph;
-    } catch  {
-        return graph;
-    }
-}
-export { appendModuleGraphByCompilation, getModuleExportsType };

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

@@ -1,76 +0,0 @@
-"use strict";
-var __webpack_modules__ = {
-    "./loader" (module) {
-        module.exports = require("./loader.cjs");
-    },
-    "./parseBundle" (module) {
-        module.exports = require("./parseBundle.cjs");
-    },
-    "./plugin" (module) {
-        module.exports = require("./plugin.cjs");
-    }
-};
-var __webpack_module_cache__ = {};
-function __webpack_require__(moduleId) {
-    var cachedModule = __webpack_module_cache__[moduleId];
-    if (void 0 !== cachedModule) return cachedModule.exports;
-    var module = __webpack_module_cache__[moduleId] = {
-        exports: {}
-    };
-    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
-    return module.exports;
-}
-(()=>{
-    __webpack_require__.n = (module)=>{
-        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
-        __webpack_require__.d(getter, {
-            a: getter
-        });
-        return getter;
-    };
-})();
-(()=>{
-    __webpack_require__.d = (exports1, getters, values)=>{
-        var define = (defs, kind)=>{
-            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-                enumerable: true,
-                [kind]: defs[key]
-            });
-        };
-        define(getters, "get");
-        define(values, "value");
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-(()=>{
-    __webpack_require__.r(__webpack_exports__);
-    var _loader__rspack_import_0 = __webpack_require__("./loader");
-    var __rspack_reexport = {};
-    for(const __rspack_import_key in _loader__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_loader__rspack_import_0[__rspack_import_key];
-    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _plugin__rspack_import_1 = __webpack_require__("./plugin");
-    var __rspack_reexport = {};
-    for(const __rspack_import_key in _plugin__rspack_import_1)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_plugin__rspack_import_1[__rspack_import_key];
-    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _parseBundle__rspack_import_2 = __webpack_require__("./parseBundle");
-    var __rspack_reexport = {};
-    for(const __rspack_import_key in _parseBundle__rspack_import_2)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_parseBundle__rspack_import_2[__rspack_import_key];
-    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-})();
-for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/build-utils/build/utils/index.d.cts

@@ -1,3 +0,0 @@
-export * from './loader';
-export * from './plugin';
-export * from './parseBundle';

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

@@ -1,358 +0,0 @@
-"use strict";
-const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
-    return "u" < typeof document ? new (require('url'.replace('', ''))).URL('file:' + __filename).href : document.currentScript && document.currentScript.src || new URL('main.js', document.baseURI).href;
-}();
-var __webpack_modules__ = {
-    module (module) {
-        module.exports = require("module");
-    }
-};
-var __webpack_module_cache__ = {};
-function __webpack_require__(moduleId) {
-    var cachedModule = __webpack_module_cache__[moduleId];
-    if (void 0 !== cachedModule) return cachedModule.exports;
-    var module = __webpack_module_cache__[moduleId] = {
-        exports: {}
-    };
-    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
-    return module.exports;
-}
-(()=>{
-    __webpack_require__.n = (module)=>{
-        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
-        __webpack_require__.d(getter, {
-            a: getter
-        });
-        return getter;
-    };
-})();
-(()=>{
-    __webpack_require__.d = (exports1, getters, values)=>{
-        var define = (defs, kind)=>{
-            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-                enumerable: true,
-                [kind]: defs[key]
-            });
-        };
-        define(getters, "get");
-        define(values, "value");
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-(()=>{
-    __webpack_require__.r(__webpack_exports__);
-    __webpack_require__.d(__webpack_exports__, {
-        addProbeLoader2Rules: ()=>addProbeLoader2Rules,
-        createLoaderContextTrap: ()=>createLoaderContextTrap,
-        extractLoaderName: ()=>extractLoaderName,
-        getLoaderNameMatch: ()=>getLoaderNameMatch,
-        isESMLoader: ()=>isESMLoader,
-        loadLoaderModule: ()=>loadLoaderModule,
-        mapEachRules: ()=>mapEachRules,
-        parsePathQueryFragment: ()=>parsePathQueryFragment,
-        parseQuery: ()=>parseQuery
-    });
-    const external_node_path_namespaceObject = require("node:path");
-    var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
-    const external_node_url_namespaceObject = require("node:url");
-    const external_fs_extra_namespaceObject = require("fs-extra");
-    var external_fs_extra_default = /*#__PURE__*/ __webpack_require__.n(external_fs_extra_namespaceObject);
-    const compat_namespaceObject = require("es-toolkit/compat");
-    const common_namespaceObject = require("@rsdoctor/utils/common");
-    const graph_namespaceObject = require("@rsdoctor/graph");
-    const logger_namespaceObject = require("@rsdoctor/utils/logger");
-    const loader_filename = (0, external_node_url_namespaceObject.fileURLToPath)(__rslib_import_meta_url__);
-    const loader_dirname = external_node_path_default().dirname(loader_filename);
-    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 { createRequire } = __webpack_require__("module");
-        const requireFn = createRequire(__rslib_import_meta_url__);
-        const mod = requireFn(process.env.DOCTOR_TEST ? external_node_path_default().resolve(cwd, cleanLoaderPath) : requireFn.resolve(cleanLoaderPath, {
-            paths: [
-                cwd,
-                external_node_path_default().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 (!external_node_path_default().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 = external_node_path_default().isAbsolute(_loaderName) || _loaderName.startsWith('./') || _loaderName.startsWith('../');
-        if (isPath) {
-            const packageJsonData = (0, graph_namespaceObject.readPackageJson)(_loaderName, (file)=>{
-                try {
-                    return external_fs_extra_default().readJsonSync(file, {
-                        encoding: 'utf8'
-                    });
-                } catch (e) {
-                    logger_namespaceObject.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 ? external_node_path_default().resolve(loader_dirname, '../loader/probeLoader.ts') : require.resolve(external_node_path_default().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(`"${common_namespaceObject.Loader.LoaderInternalPropertyName}":\{[^\}]*\},{0,1}`), '');
-                                return res;
-                            }
-                            if ('object' == typeof target.query) {
-                                const options = target.query[common_namespaceObject.Loader.LoaderInternalPropertyName];
-                                if (options.hasOptions) return (0, compat_namespaceObject.omit)(target.query, [
-                                    common_namespaceObject.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 ? ()=>(0, compat_namespaceObject.omit)(target.getOptions(), [
-                                common_namespaceObject.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());
-    }
-})();
-exports.addProbeLoader2Rules = __webpack_exports__.addProbeLoader2Rules;
-exports.createLoaderContextTrap = __webpack_exports__.createLoaderContextTrap;
-exports.extractLoaderName = __webpack_exports__.extractLoaderName;
-exports.getLoaderNameMatch = __webpack_exports__.getLoaderNameMatch;
-exports.isESMLoader = __webpack_exports__.isESMLoader;
-exports.loadLoaderModule = __webpack_exports__.loadLoaderModule;
-exports.mapEachRules = __webpack_exports__.mapEachRules;
-exports.parsePathQueryFragment = __webpack_exports__.parsePathQueryFragment;
-exports.parseQuery = __webpack_exports__.parseQuery;
-for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "addProbeLoader2Rules",
-    "createLoaderContextTrap",
-    "extractLoaderName",
-    "getLoaderNameMatch",
-    "isESMLoader",
-    "loadLoaderModule",
-    "mapEachRules",
-    "parsePathQueryFragment",
-    "parseQuery"
-].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/build-utils/build/utils/loader.d.cts

@@ -1,20 +0,0 @@
-import type { Common, Plugin } from '@rsdoctor/types';
-export declare function parsePathQueryFragment(str: string): {
-    path: string;
-    query: string;
-    fragment: string;
-};
-export declare function loadLoaderModule(loaderPath: string, cwd?: string): {
-    default: Plugin.LoaderDefinition<Common.PlainObject, {}>;
-    pitch: Plugin.PitchLoaderDefinitionFunction;
-    raw: boolean | void;
-};
-export declare function extractLoaderName(loaderPath: string, cwd?: string): string;
-export declare function mapEachRules<T extends Plugin.BuildRuleSetRule>(rules: T[], callback: (rule: T) => T): T[];
-export declare function isESMLoader(r: Plugin.BuildRuleSetRule): boolean;
-export declare function getLoaderNameMatch(r: Plugin.BuildRuleSetRule, loaderName: string, strict?: boolean): boolean;
-export declare function addProbeLoader2Rules<T extends Plugin.BuildRuleSetRule>(rules: T[], compiler: Plugin.BaseCompiler, fn: (r: Plugin.BuildRuleSetRule) => boolean): T[];
-export declare function createLoaderContextTrap(this: Plugin.LoaderContext<Common.PlainObject>, final: (err: Error | null | undefined, res: string | Buffer | null, sourceMap?: Plugin.SourceMapInput) => void): Plugin.LoaderContext<Common.PlainObject<any>>;
-export declare function parseQuery(query: string): {
-    [k: string]: string;
-};