@rsdoctor/core 1.2.2 → 1.2.4-beta.0

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

@@ -0,0 +1,356 @@
+"use strict";
+const __rslib_import_meta_url__ = /*#__PURE__*/ function() {
+    return 'undefined' == 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: function(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, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != 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__, {
+        extractLoaderName: ()=>extractLoaderName,
+        addProbeLoader2Rules: ()=>addProbeLoader2Rules,
+        isESMLoader: ()=>isESMLoader,
+        getLoaderNameMatch: ()=>getLoaderNameMatch,
+        parseQuery: ()=>parseQuery,
+        createLoaderContextTrap: ()=>createLoaderContextTrap,
+        loadLoaderModule: ()=>loadLoaderModule,
+        mapEachRules: ()=>mapEachRules,
+        parsePathQueryFragment: ()=>parsePathQueryFragment
+    });
+    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 esm_namespaceObject = require("fs-extra/esm");
+    var esm_default = /*#__PURE__*/ __webpack_require__.n(esm_namespaceObject);
+    const external_lodash_es_namespaceObject = require("lodash-es");
+    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: (null == match ? void 0 : match[1].replace(/\0(.)/g, '$1')) || '',
+            query: (null == match ? void 0 : match[2]) ? match[2].replace(/\0(.)/g, '$1') : '',
+            fragment: (null == match ? void 0 : match[3]) || ''
+        };
+    }
+    function loadLoaderModule(loaderPath, cwd = process.cwd()) {
+        var _mod_default, _mod_default1;
+        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: (null == (_mod_default = mod.default) ? void 0 : _mod_default.pitch) || mod.pitch,
+            raw: (null == (_mod_default1 = mod.default) ? void 0 : _mod_default1.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.apply(null, 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) {
+        let _loaderName = 'object' == typeof r && 'string' == typeof (null == r ? void 0 : 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 esm_default().readJsonSync(file, {
+                        encoding: 'utf8'
+                    });
+                } catch (e) {
+                    logger_namespaceObject.logger.debug(`isESMLoader function error\u{FF1A}${e}`);
+                }
+            });
+            if ((null == packageJsonData ? void 0 : packageJsonData.type) === 'module' && !(null == packageJsonData ? void 0 : 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 (null == r ? void 0 : r.loader) && r.loader.includes(loaderName) || 'string' == typeof r && r.includes(loaderName);
+        return 'object' == typeof r && 'string' == typeof (null == r ? void 0 : 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, external_lodash_es_namespaceObject.omit)(target.query, [
+                                    common_namespaceObject.Loader.LoaderInternalPropertyName
+                                ]);
+                                const innerLoaderPath = null == options ? void 0 : options.loader;
+                                const loaderQuery = parsePathQueryFragment(innerLoaderPath).query;
+                                return loaderQuery;
+                            }
+                        }
+                        return Reflect.get(target, key, receiver);
+                    case 'getOptions':
+                        return 'function' == typeof target.getOptions ? ()=>(0, external_lodash_es_namespaceObject.omit)(target.getOptions(), [
+                                common_namespaceObject.Loader.LoaderInternalPropertyName
+                            ]) : Reflect.get(target, key, receiver);
+                    default:
+                        const _target = target;
+                        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 __webpack_i__ in __webpack_exports__)if (-1 === [
+    "addProbeLoader2Rules",
+    "createLoaderContextTrap",
+    "extractLoaderName",
+    "getLoaderNameMatch",
+    "isESMLoader",
+    "loadLoaderModule",
+    "mapEachRules",
+    "parsePathQueryFragment",
+    "parseQuery"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -1,5 +1,4 @@
 import type { Common, Plugin } from '@rsdoctor/types';
-import { SourceMapInput as WebpackSourceMapInput } from '../../../types';
 export declare function parsePathQueryFragment(str: string): {
     path: string;
     query: string;
@@ -15,8 +14,7 @@ export declare function mapEachRules<T extends Plugin.BuildRuleSetRule>(rules: 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?: WebpackSourceMapInput) => void): Plugin.LoaderContext<Common.PlainObject<any>>;
+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;
 };
-//# sourceMappingURL=loader.d.ts.map

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

@@ -1,56 +1,30 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.n = (module)=>{
-        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
-        __webpack_require__.d(getter, {
-            a: getter
-        });
-        return getter;
-    };
-})();
-(()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
+import __rslib_shim_module__ from 'module';
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(import.meta.url);
+import * as __WEBPACK_EXTERNAL_MODULE_module__ from "module";
+import node_path from "node:path";
+import { fileURLToPath } from "node:url";
+import esm from "fs-extra/esm";
+import { omit } from "lodash-es";
+import { Loader } from "@rsdoctor/utils/common";
+import { readPackageJson } from "@rsdoctor/graph";
+import { logger } from "@rsdoctor/utils/logger";
+var __webpack_modules__ = {
+    module: function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_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: {}
     };
-})();
-var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    extractLoaderName: ()=>extractLoaderName,
-    addProbeLoader2Rules: ()=>addProbeLoader2Rules,
-    isESMLoader: ()=>isESMLoader,
-    getLoaderNameMatch: ()=>getLoaderNameMatch,
-    parseQuery: ()=>parseQuery,
-    createLoaderContextTrap: ()=>createLoaderContextTrap,
-    loadLoaderModule: ()=>loadLoaderModule,
-    mapEachRules: ()=>mapEachRules,
-    parsePathQueryFragment: ()=>parsePathQueryFragment
-});
-const external_node_path_namespaceObject = require("node:path");
-var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
-const external_fs_extra_namespaceObject = require("fs-extra");
-var external_fs_extra_default = /*#__PURE__*/ __webpack_require__.n(external_fs_extra_namespaceObject);
-const external_lodash_namespaceObject = require("lodash");
-const common_namespaceObject = require("@rsdoctor/utils/common");
-const graph_namespaceObject = require("@rsdoctor/graph");
-const logger_namespaceObject = require("@rsdoctor/utils/logger");
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+const loader_filename = fileURLToPath(import.meta.url);
+const loader_dirname = node_path.dirname(loader_filename);
 const PATH_QUERY_FRAGMENT_REGEXP = /^((?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/;
 function parsePathQueryFragment(str) {
     const match = PATH_QUERY_FRAGMENT_REGEXP.exec(str);
@@ -63,10 +37,12 @@ function parsePathQueryFragment(str) {
 function loadLoaderModule(loaderPath, cwd = process.cwd()) {
     var _mod_default, _mod_default1;
     const cleanLoaderPath = parsePathQueryFragment(loaderPath).path;
-    const mod = require(process.env.DOCTOR_TEST ? external_node_path_default().resolve(cwd, cleanLoaderPath) : require.resolve(cleanLoaderPath, {
+    const { createRequire } = __webpack_require__("module");
+    const requireFn = createRequire(import.meta.url);
+    const mod = requireFn(process.env.DOCTOR_TEST ? node_path.resolve(cwd, cleanLoaderPath) : requireFn.resolve(cleanLoaderPath, {
         paths: [
             cwd,
-            external_node_path_default().resolve(cwd, 'node_modules')
+            node_path.resolve(cwd, 'node_modules')
         ]
     }));
     const isESM = mod.__esModule && 'function' == typeof mod.default;
@@ -78,7 +54,7 @@ function loadLoaderModule(loaderPath, cwd = process.cwd()) {
 }
 function extractLoaderName(loaderPath, cwd = '') {
     let res = loaderPath.replace(cwd, '');
-    if (!external_node_path_default().isAbsolute(res)) return res;
+    if (!node_path.isAbsolute(res)) return res;
     const nms = '/node_modules/';
     const idx = res.lastIndexOf(nms);
     if (-1 !== idx) {
@@ -148,18 +124,18 @@ function mapEachRules(rules, callback) {
 function isESMLoader(r) {
     let _loaderName = 'object' == typeof r && 'string' == typeof (null == r ? void 0 : r.loader) ? r.loader : 'string' == typeof r ? r : '';
     if (!_loaderName) return false;
-    const isPath = external_node_path_default().isAbsolute(_loaderName) || _loaderName.startsWith('./') || _loaderName.startsWith('../');
+    const isPath = node_path.isAbsolute(_loaderName) || _loaderName.startsWith('./') || _loaderName.startsWith('../');
     if (isPath) {
-        const packageJsonData = (0, graph_namespaceObject.readPackageJson)(_loaderName, (file)=>{
+        const packageJsonData = readPackageJson(_loaderName, (file)=>{
             try {
-                return external_fs_extra_default().readJsonSync(file, {
+                return esm.readJsonSync(file, {
                     encoding: 'utf8'
                 });
             } catch (e) {
-                logger_namespaceObject.logger.debug(`isESMLoader function error\u{FF1A}${e}`);
+                logger.debug(`isESMLoader function error\u{FF1A}${e}`);
             }
         });
-        if ((null == packageJsonData ? void 0 : packageJsonData.type) === 'module') return true;
+        if ((null == packageJsonData ? void 0 : packageJsonData.type) === 'module' && !(null == packageJsonData ? void 0 : packageJsonData.name.includes('@rsdoctor/'))) return true;
     }
     return false;
 }
@@ -167,7 +143,7 @@ function appendProbeLoaders(compiler, loaderConfig) {
     const _options = 'object' == typeof loaderConfig ? 'string' == typeof loaderConfig.options ? {
         options: loaderConfig.options
     } : loaderConfig.options : {};
-    const loaderPath = external_node_path_default().join(__dirname, '../loader/probeLoader.js');
+    const loaderPath = process.env.DOCTOR_TEST ? node_path.resolve(loader_dirname, '../loader/probeLoader.ts') : 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,
@@ -261,13 +237,13 @@ function createLoaderContextTrap(final) {
                 case 'query':
                     if (target.query) {
                         if ('string' == typeof target.query) {
-                            const res = target.query.replace(new RegExp(`"${common_namespaceObject.Loader.LoaderInternalPropertyName}":\{[^\}]*\},{0,1}`), '');
+                            const res = target.query.replace(new RegExp(`"${Loader.LoaderInternalPropertyName}":\{[^\}]*\},{0,1}`), '');
                             return res;
                         }
                         if ('object' == typeof target.query) {
-                            const options = target.query[common_namespaceObject.Loader.LoaderInternalPropertyName];
-                            if (options.hasOptions) return (0, external_lodash_namespaceObject.omit)(target.query, [
-                                common_namespaceObject.Loader.LoaderInternalPropertyName
+                            const options = target.query[Loader.LoaderInternalPropertyName];
+                            if (options.hasOptions) return omit(target.query, [
+                                Loader.LoaderInternalPropertyName
                             ]);
                             const innerLoaderPath = null == options ? void 0 : options.loader;
                             const loaderQuery = parsePathQueryFragment(innerLoaderPath).query;
@@ -276,8 +252,8 @@ function createLoaderContextTrap(final) {
                     }
                     return Reflect.get(target, key, receiver);
                 case 'getOptions':
-                    return 'function' == typeof target.getOptions ? ()=>(0, external_lodash_namespaceObject.omit)(target.getOptions(), [
-                            common_namespaceObject.Loader.LoaderInternalPropertyName
+                    return 'function' == typeof target.getOptions ? ()=>omit(target.getOptions(), [
+                            Loader.LoaderInternalPropertyName
                         ]) : Reflect.get(target, key, receiver);
                 default:
                     const _target = target;
@@ -307,26 +283,4 @@ function parseQuery(query) {
     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 __webpack_i__ in __webpack_exports__)if (-1 === [
-    "addProbeLoader2Rules",
-    "createLoaderContextTrap",
-    "extractLoaderName",
-    "getLoaderNameMatch",
-    "isESMLoader",
-    "loadLoaderModule",
-    "mapEachRules",
-    "parsePathQueryFragment",
-    "parseQuery"
-].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});
+export { addProbeLoader2Rules, createLoaderContextTrap, extractLoaderName, getLoaderNameMatch, isESMLoader, loadLoaderModule, mapEachRules, parsePathQueryFragment, parseQuery };