@rsdoctor/core 0.0.0-next-20240620044732

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

@@ -0,0 +1,113 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  getDeclarationIdentifier: () => getDeclarationIdentifier,
+  getExportIdentifierStatement: () => getExportIdentifierStatement
+});
+module.exports = __toCommonJS(utils_exports);
+var import_lodash = require("lodash");
+var import_ruleUtils = require("@rsdoctor/utils/ruleUtils");
+function getDefaultExportIdentifier(node, module2, searchId) {
+  const { declaration } = node;
+  if (import_ruleUtils.parser.asserts.isLiteral(declaration) && declaration.loc) {
+    return module2.getStatement(declaration.loc);
+  }
+  if (import_ruleUtils.parser.asserts.isIdentifier(declaration)) {
+    if (searchId) {
+      const result = getDeclarationIdentifier(declaration.name, module2);
+      if (result) {
+        return result;
+      }
+    } else if (declaration.loc) {
+      return module2.getStatement(declaration.loc);
+    }
+  }
+  if (import_ruleUtils.parser.asserts.isClassDeclaration(declaration) || import_ruleUtils.parser.asserts.isFunctionDeclaration(declaration)) {
+    if (declaration.id?.loc) {
+      return module2.getStatement(declaration.id.loc);
+    }
+  }
+  const startLine = node.declaration.loc?.start.line;
+  if (!(0, import_lodash.isNumber)(startLine)) {
+    return;
+  }
+  const { transformed } = module2.getSource();
+  const endColumn = transformed.split("\n")[startLine - 1].length - 1;
+  return module2.getStatement({
+    start: {
+      line: startLine,
+      column: 0
+    },
+    end: {
+      line: startLine,
+      column: endColumn
+    }
+  });
+}
+function getExportIdentifierStatement(name, module2) {
+  const ast = module2.getProgram();
+  if (!ast) {
+    return;
+  }
+  for (const node of ast.body) {
+    if (import_ruleUtils.parser.asserts.isExportDefaultDeclaration(node)) {
+      const result = getDefaultExportIdentifier(node, module2, false);
+      if (result) {
+        return result;
+      }
+    }
+    const id = import_ruleUtils.parser.utils.getIdentifierInExport(name, node);
+    if (id?.loc) {
+      return module2.getStatement(id.loc);
+    }
+  }
+}
+function getDeclarationIdentifier(name, module2) {
+  const ast = module2.getProgram();
+  if (!ast) {
+    return;
+  }
+  for (const node of ast.body) {
+    const id = import_ruleUtils.parser.utils.getIdentifierInDeclaration(name, node);
+    if (id?.loc) {
+      return module2.getStatement(id.loc);
+    }
+    if (import_ruleUtils.parser.asserts.isExportNamedDeclaration(node) && node.declaration) {
+      const id2 = import_ruleUtils.parser.utils.getIdentifierInDeclaration(
+        name,
+        node.declaration
+      );
+      if (id2?.loc) {
+        return module2.getStatement(id2.loc);
+      }
+    }
+    if (name === "default" && import_ruleUtils.parser.asserts.isExportDefaultDeclaration(node)) {
+      const result = getDefaultExportIdentifier(node, module2, true);
+      if (result) {
+        return result;
+      }
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDeclarationIdentifier,
+  getExportIdentifierStatement
+});

package/dist/build-utils/build/module-graph/webpack/transform.d.ts

@@ -0,0 +1,12 @@
+import type { SourceMapConsumer } from 'source-map';
+import * as Webpack from 'webpack';
+import { Node } from '@rsdoctor/utils/ruleUtils';
+import { Plugin } from '@rsdoctor/types';
+import { ModuleGraph } from '@rsdoctor/graph';
+export interface TransformContext {
+    astCache?: Map<Webpack.NormalModule, Node.Program>;
+    packagePathMap?: Map<string, string>;
+    getSourceMap?(module: string): Promise<SourceMapConsumer | undefined>;
+}
+export declare function appendModuleGraphByCompilation(compilation: Plugin.BaseCompilation, graph: ModuleGraph, features?: Plugin.RsdoctorWebpackPluginFeatures, context?: TransformContext): Promise<ModuleGraph>;
+//# sourceMappingURL=transform.d.ts.map

package/dist/build-utils/build/module-graph/webpack/transform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../../../../src/build-utils/build/module-graph/webpack/transform.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,KAAK,OAAO,MAAM,SAAS,CAAC;AAEnC,OAAO,EAAE,IAAI,EAAE,MAAM,2BAA2B,CAAC;AACjD,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAU,WAAW,EAAe,MAAM,iBAAiB,CAAC;AAmBnE,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,EAAE,GAAG,CAAC,OAAO,CAAC,YAAY,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;IACnD,cAAc,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,YAAY,CAAC,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,GAAG,SAAS,CAAC,CAAC;CACvE;AAoND,wBAAsB,8BAA8B,CAClD,WAAW,EAAE,MAAM,CAAC,eAAe,EACnC,KAAK,EAAE,WAAW,EAClB,QAAQ,CAAC,EAAE,MAAM,CAAC,6BAA6B,EAC/C,OAAO,CAAC,EAAE,gBAAgB,wBA2B3B"}

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

@@ -0,0 +1,195 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var transform_exports = {};
+__export(transform_exports, {
+  appendModuleGraphByCompilation: () => appendModuleGraphByCompilation
+});
+module.exports = __toCommonJS(transform_exports);
+var import_build = require("@rsdoctor/utils/build");
+var import_compatible = require("../../../common/webpack/compatible");
+var import_module_graph = require("../../../common/module-graph");
+var import_parser = require("../parser");
+var import_lodash = require("lodash");
+async function readFile(target, wbFs) {
+  if (wbFs?.fs?.readFile) {
+    const result = new Promise((resolve, reject) => {
+      wbFs.fs.readFile(target, (err, content) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        if (content) {
+          resolve(Buffer.from(content));
+        } else {
+          resolve();
+        }
+      });
+    }).catch(() => {
+    });
+    if (result) {
+      return result;
+    }
+  }
+  return import_build.File.fse.readFile(target).catch(() => {
+  });
+}
+function appendDependency(webpackDep, module2, webpackGraph, graph) {
+  const resolvedWebpackModule = (0, import_compatible.getResolveModule)(
+    webpackDep,
+    webpackGraph
+  );
+  if (!resolvedWebpackModule) {
+    return;
+  }
+  const rawRequest = (0, import_compatible.getWebpackDependencyRequest)(
+    webpackDep,
+    resolvedWebpackModule
+  );
+  const resolveRequest = (0, import_compatible.getWebpackModulePath)(resolvedWebpackModule);
+  const request = rawRequest ?? resolveRequest;
+  if (!module2.getDependencyByRequest(request)) {
+    const depModule = graph.getModuleByFile(resolveRequest);
+    if (depModule) {
+      const dep = module2.addDependency(
+        request,
+        depModule,
+        (0, import_module_graph.getImportKind)(webpackDep)
+      );
+      if (dep) {
+        graph.addDependency(dep);
+      }
+    }
+  }
+  const dependency = module2.getDependencyByRequest(request);
+  if (dependency) {
+    dependency.setBuildMeta({
+      exportsType: (0, import_compatible.getModuleExportsType)(
+        resolvedWebpackModule,
+        webpackGraph,
+        module2.meta.strictHarmonyModule
+      )
+    });
+    const statement = (0, import_compatible.getDependencyPosition)(webpackDep, module2, 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) {
+    }
+  }
+  return process.env.NODE_ENV === "test" ? Buffer.from("test code") : readFile(modulePath, wbFs);
+}
+async function appendModuleData(origin, webpackGraph, graph, wbFs, features, context) {
+  const module2 = graph.getModuleByWebpackId((0, import_compatible.getWebpackModuleId)(origin));
+  if (!origin || !module2) {
+    return;
+  }
+  const { getSourceMap, astCache, packagePathMap } = context ?? {};
+  try {
+    const sourceMap = await getSourceMap?.(module2.path);
+    const source = await getModuleSource(module2.path, wbFs, sourceMap) ?? Buffer.from("");
+    if (sourceMap) {
+      module2.setSourceMap(sourceMap);
+    }
+    if (astCache?.has(origin)) {
+      const program = astCache.get(origin);
+      module2.setProgram(program);
+      module2.meta.hasSetEsModuleStatement = (0, import_parser.hasSetEsModuleStatement)(program);
+    }
+    const transformed = (0, import_compatible.isExternalModule)(origin) ? "" : module2.getSource().transformed.length > 0 ? module2.getSource().transformed : (0, import_lodash.isFunction)(origin?.originalSource) ? origin.originalSource()?.source()?.toString() : "";
+    const transformedSize = (0, import_compatible.isExternalModule)(origin) ? 0 : module2.getSize().transformedSize > 0 ? module2.getSize().transformedSize : Buffer.from(transformed).byteLength;
+    module2.setSource({
+      transformed,
+      source: source.toString()
+    });
+    module2.setSize({
+      transformedSize,
+      sourceSize: source.byteLength
+    });
+    let packageData;
+    if (packagePathMap && origin.resourceResolveData) {
+      let { descriptionFileRoot: root } = origin.resourceResolveData;
+      const { descriptionFileData: data } = origin.resourceResolveData;
+      if (root && data.name && data.version) {
+        if (packagePathMap.has(root)) {
+          root = packagePathMap.get(root);
+        } else {
+          const realpath = await import_build.File.fse.realpath(root);
+          root = realpath;
+          packagePathMap.set(root, realpath);
+        }
+        packageData = {
+          ...origin.resourceResolveData.descriptionFileData,
+          root
+        };
+      }
+    }
+    module2.meta.strictHarmonyModule = origin.buildMeta?.strictHarmonyModule ?? false;
+    module2.meta.packageData = packageData;
+    if (!features?.lite && origin?.dependencies) {
+      Array.from(origin.dependencies).filter((item) => (0, import_module_graph.isImportDependency)(item)).concat(
+        origin.blocks.reduce(
+          (ans, item) => ans.concat(item.dependencies),
+          []
+        )
+      ).forEach((dep) => appendDependency(dep, module2, webpackGraph, graph));
+    }
+  } catch (e) {
+    console.error(`module ${module2.path} transform has error:`, e);
+  }
+}
+async function appendModuleGraphByCompilation(compilation, graph, features, context) {
+  try {
+    const { moduleGraph: webpackGraph, fileSystemInfo } = compilation;
+    const allModules = (0, import_compatible.getAllModules)(compilation);
+    await Promise.all(
+      allModules.map((module2) => {
+        return appendModuleData(
+          module2,
+          webpackGraph,
+          graph,
+          fileSystemInfo,
+          features,
+          context
+        );
+      })
+    );
+    (0, import_module_graph.removeNoImportStyle)(graph);
+    return graph;
+  } catch (e) {
+    return graph;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  appendModuleGraphByCompilation
+});

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

@@ -0,0 +1,4 @@
+export * from './loader';
+export * from './plugin';
+export * from './parseBundle';
+//# sourceMappingURL=index.d.ts.map

package/dist/build-utils/build/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/build-utils/build/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC"}

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

@@ -0,0 +1,26 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+module.exports = __toCommonJS(utils_exports);
+__reExport(utils_exports, require("./loader"), module.exports);
+__reExport(utils_exports, require("./plugin"), module.exports);
+__reExport(utils_exports, require("./parseBundle"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./loader"),
+  ...require("./plugin"),
+  ...require("./parseBundle")
+});

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

@@ -0,0 +1,19 @@
+/// <reference types="node" />
+import type { Common, Plugin } from '@rsdoctor/types';
+import { SourceMapInput as WebpackSourceMapInput } from '../../../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 getLoaderOptions<T>(loaderContext: Plugin.LoaderContext<T>): T;
+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 addProbeLoader2Rules<T extends Plugin.BuildRuleSetRule>(rules: T[], loaderName: string, appendRules: (rule: T, index: number) => T, strict?: 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>>;
+//# sourceMappingURL=loader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../../../src/build-utils/build/utils/loader.ts"],"names":[],"mappings":";AAIA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAAQ,cAAc,IAAI,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAO/E,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG;IACnD,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;CAClB,CAOA;AAED,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,MAAM,EAClB,GAAG,SAAgB,GAClB;IACD,OAAO,EAAE,MAAM,CAAC,gBAAgB,CAAC,MAAM,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC;IACzD,KAAK,EAAE,MAAM,CAAC,6BAA6B,CAAC;IAC5C,GAAG,EAAE,OAAO,GAAG,IAAI,CAAC;CACrB,CAiBA;AAED,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,aAAa,EAAE,MAAM,CAAC,aAAa,CAAC,CAAC,CAAC,KAQzE;AAED,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,SAAK,GAAG,MAAM,CAqBtE;AAED,wBAAgB,YAAY,CAAC,CAAC,SAAS,MAAM,CAAC,gBAAgB,EAC5D,KAAK,EAAE,CAAC,EAAE,EACV,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,GACvB,CAAC,EAAE,CAgFL;AAyBD,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,MAAM,CAAC,gBAAgB,EACpE,KAAK,EAAE,CAAC,EAAE,EACV,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,EAC1C,MAAM,CAAC,EAAE,OAAO,GACf,CAAC,EAAE,CAgEL;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,WAAW,CAAC,EAC9C,KAAK,EAAE,CACL,GAAG,EAAE,KAAK,GAAG,IAAI,GAAG,SAAS,EAC7B,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,EAC3B,SAAS,CAAC,EAAE,qBAAqB,KAC9B,IAAI,iDAsFV"}

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

@@ -0,0 +1,299 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var loader_exports = {};
+__export(loader_exports, {
+  addProbeLoader2Rules: () => addProbeLoader2Rules,
+  createLoaderContextTrap: () => createLoaderContextTrap,
+  extractLoaderName: () => extractLoaderName,
+  getLoaderOptions: () => getLoaderOptions,
+  loadLoaderModule: () => loadLoaderModule,
+  mapEachRules: () => mapEachRules,
+  parsePathQueryFragment: () => parsePathQueryFragment
+});
+module.exports = __toCommonJS(loader_exports);
+var import_loader_utils = require("loader-utils");
+var import_path = __toESM(require("path"));
+var import_lodash = require("lodash");
+var import_common = require("@rsdoctor/utils/common");
+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 = process.env.DOCTOR_TEST ? require(import_path.default.resolve(cwd, cleanLoaderPath)) : require(require.resolve(cleanLoaderPath, {
+    paths: [cwd, import_path.default.resolve(cwd, "node_modules")]
+  }));
+  const isESM = mod.__esModule && typeof mod.default === "function";
+  return {
+    default: isESM ? mod.default : typeof mod === "function" ? mod : null,
+    pitch: mod.default?.pitch || mod.pitch,
+    raw: mod.default?.raw || mod.raw || false
+  };
+}
+function getLoaderOptions(loaderContext) {
+  if (typeof loaderContext.getOptions === "function") {
+    return loaderContext.getOptions();
+  }
+  return (0, import_loader_utils.getOptions)(loaderContext);
+}
+function extractLoaderName(loaderPath, cwd = "") {
+  let res = loaderPath.replace(cwd, "");
+  if (!import_path.default.isAbsolute(res))
+    return res;
+  const nms = "/node_modules/";
+  const idx = res.lastIndexOf(nms);
+  if (idx !== -1) {
+    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.map((rule) => {
+    if (typeof rule === "string") {
+      return callback({
+        loader: rule
+      });
+    }
+    if (rule.loader && typeof rule.loader === "string") {
+      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) || rule.use.length !== 0)) {
+      if (typeof rule.use === "string") {
+        return {
+          ...rule,
+          use: mapEachRules(
+            [
+              {
+                loader: rule.use,
+                options: rule.options
+              }
+            ],
+            callback
+          )
+        };
+      }
+      if (typeof rule.use === "function") {
+        const funcUse = rule.use;
+        const newRule = {
+          ...rule,
+          use: (...args) => {
+            const rules2 = funcUse.apply(null, args);
+            return mapEachRules(rules2, 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 getLoaderNameMatch(_r, loaderName, strict = true) {
+  if (!strict) {
+    return typeof _r === "object" && typeof _r?.loader === "string" && _r.loader.includes(loaderName) || typeof _r === "string" && _r.includes(loaderName);
+  }
+  return typeof _r === "object" && typeof _r?.loader === "string" && _r.loader === loaderName || typeof _r === "string" && _r === loaderName;
+}
+function addProbeLoader2Rules(rules, loaderName, appendRules, strict) {
+  return rules.map((rule) => {
+    if (!rule || typeof rule === "string")
+      return rule;
+    if (getLoaderNameMatch(rule, loaderName, strict)) {
+      const _rule = {
+        ...rule,
+        use: [
+          {
+            loader: rule.loader,
+            options: rule.options
+          }
+        ],
+        loader: void 0,
+        options: void 0
+      };
+      return appendRules(_rule, 0);
+    }
+    if (rule.use) {
+      if (Array.isArray(rule.use)) {
+        const _index = (0, import_lodash.findIndex)(
+          rule.use,
+          (_r) => getLoaderNameMatch(_r, loaderName, strict)
+        );
+        if (_index > -1) {
+          return appendRules(rule, _index);
+        }
+      } else if (typeof rule.use === "object" && !Array.isArray(rule.use) && typeof rule.use !== "function") {
+        rule.use = [
+          {
+            ...rule.use
+          }
+        ];
+        return appendRules(rule, 0);
+      }
+    }
+    if ("oneOf" in rule && rule.oneOf) {
+      return {
+        ...rule,
+        oneOf: addProbeLoader2Rules(
+          rule.oneOf,
+          loaderName,
+          appendRules
+        )
+      };
+    }
+    if ("rules" in rule && rule.rules) {
+      return {
+        ...rule,
+        rules: addProbeLoader2Rules(
+          rule.rules,
+          loaderName,
+          appendRules
+        )
+      };
+    }
+    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 cb2 = ac(...args);
+    return (...args2) => {
+      final(args2[0], args2[1] ?? null, args2[2]);
+      return cb2(...args2);
+    };
+  };
+  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 (typeof target.query === "string") {
+              const res = target.query.replace(
+                // eslint-disable-next-line no-useless-escape
+                new RegExp(
+                  `"${import_common.Loader.LoaderInternalPropertyName}":{[^}]*},{0,1}`
+                ),
+                ""
+              );
+              return res;
+            }
+            if (typeof target.query === "object") {
+              const options = target.query[import_common.Loader.LoaderInternalPropertyName];
+              if (options.hasOptions) {
+                return (0, import_lodash.omit)(target.query, [import_common.Loader.LoaderInternalPropertyName]);
+              }
+              const innerLoaderPath = options?.loader;
+              const loaderQuery = parsePathQueryFragment(innerLoaderPath).query;
+              return loaderQuery;
+            }
+          }
+          return Reflect.get(target, key, receiver);
+        case "getOptions":
+          return typeof target.getOptions === "function" ? () => (0, import_lodash.omit)(target.getOptions(), [import_common.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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addProbeLoader2Rules,
+  createLoaderContextTrap,
+  extractLoaderName,
+  getLoaderOptions,
+  loadLoaderModule,
+  mapEachRules,
+  parsePathQueryFragment
+});