@rspack/core 0.7.2 → 0.7.3-canary-607ec67-20240612123914

package/dist/loader-runner/index.js

@@ -8,45 +8,38 @@
  * Copyright (c) JS Foundation and other contributors
  * https://github.com/webpack/loader-runner/blob/main/LICENSE
  */
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _LoaderObject_cachedData, _LoaderObject_loaderItem;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.runLoaders = exports.parsePathQueryFragment = void 0;
+exports.parsePathQueryFragment = exports.runLoaders = exports.LoaderObject = void 0;
+const node_querystring_1 = __importDefault(require("node:querystring"));
+const assert_1 = __importDefault(require("assert"));
+const util_1 = require("util");
+const binding_1 = require("@rspack/binding");
 const webpack_sources_1 = require("webpack-sources");
+const Module_1 = require("../Module");
 const NormalModule_1 = require("../NormalModule");
 const adapterRuleUse_1 = require("../config/adapterRuleUse");
-const util_1 = require("../util");
+const util_2 = require("../util");
 const createHash_1 = require("../util/createHash");
 const identifier_1 = require("../util/identifier");
 const memoize_1 = require("../util/memoize");
-const loadLoader = require("./loadLoader");
-const Module_1 = require("../Module");
-const querystring = require("node:querystring");
-const PATH_QUERY_FRAGMENT_REGEXP = /^((?:\u200b.|[^?#\u200b])*)(\?(?:\u200b.|[^#\u200b])*)?(#.*)?$/;
-function parsePathQueryFragment(str) {
-    const match = PATH_QUERY_FRAGMENT_REGEXP.exec(str);
-    return {
-        path: match?.[1].replace(/\u200b(.)/g, "$1") || "",
-        query: match?.[2] ? match[2].replace(/\u200b(.)/g, "$1") : "",
-        fragment: match?.[3] || ""
-    };
-}
-exports.parsePathQueryFragment = parsePathQueryFragment;
-function dirname(path) {
-    if (path === "/")
-        return "/";
-    const i = path.lastIndexOf("/");
-    const j = path.lastIndexOf("\\");
-    const i2 = path.indexOf("/");
-    const j2 = path.indexOf("\\");
-    const idx = i > j ? i : j;
-    const idx2 = i > j ? i2 : j2;
-    if (idx < 0)
-        return path;
-    if (idx === idx2)
-        return path.slice(0, idx + 1);
-    return path.slice(0, idx);
-}
+const loadLoader_1 = __importDefault(require("./loadLoader"));
 function createLoaderObject(loader, compiler) {
-    const obj = {
+    var obj = {
         path: null,
         query: null,
         fragment: null,
@@ -67,37 +60,42 @@ function createLoaderObject(loader, compiler) {
                 obj.fragment);
         },
         set: function (value) {
-            if (typeof value === "string") {
-                const splittedRequest = parsePathQueryFragment(value);
-                obj.path = splittedRequest.path;
-                obj.query = splittedRequest.query;
-                obj.fragment = splittedRequest.fragment;
-                obj.options = undefined;
-                obj.ident = undefined;
-            }
-            else {
-                if (!value.loader)
-                    throw new Error("request should be a string or object with loader and options (" +
-                        JSON.stringify(value) +
-                        ")");
-                obj.path = value.loader;
-                obj.fragment = value.fragment || "";
-                obj.type = value.type;
-                obj.options = value.options;
-                obj.ident = value.ident;
-                if (obj.options === null)
-                    obj.query = value.query;
-                else if (obj.options === undefined)
-                    obj.query = value.query;
-                else if (typeof obj.options === "string")
-                    obj.query = "?" + obj.options;
-                else if (obj.ident)
-                    obj.query = "??" + obj.ident;
-                else if (typeof obj.options === "object" && obj.options.ident)
-                    obj.query = "??" + obj.options.ident;
-                else
-                    obj.query = "?" + JSON.stringify(obj.options);
+            var splittedRequest = (0, identifier_1.parseResourceWithoutFragment)(value.request);
+            obj.path = splittedRequest.path;
+            obj.query = splittedRequest.query;
+            obj.fragment = splittedRequest.fragment || "";
+            obj.options =
+                obj.options === null
+                    ? splittedRequest.query
+                        ? splittedRequest.query.slice(1)
+                        : undefined
+                    : obj.options;
+            if (typeof obj.options === "string" && obj.options[0] === "?") {
+                const ident = obj.options.slice(1);
+                if (ident === "[[missing ident]]") {
+                    throw new Error("No ident is provided by referenced loader. " +
+                        "When using a function for Rule.use in config you need to " +
+                        "provide an 'ident' property for referenced loader options.");
+                }
+                obj.options = compiler.__internal__ruleSet.references.get(ident);
+                if (obj.options === undefined) {
+                    throw new Error("Invalid ident is provided by referenced loader");
+                }
+                obj.ident = ident;
             }
+            obj.type = value.type;
+            if (obj.options === null)
+                obj.query = "";
+            else if (obj.options === undefined)
+                obj.query = "";
+            else if (typeof obj.options === "string")
+                obj.query = "?" + obj.options;
+            else if (obj.ident)
+                obj.query = "??" + obj.ident;
+            else if (typeof obj.options === "object" && obj.options.ident)
+                obj.query = "??" + obj.options.ident;
+            else
+                obj.query = "?" + JSON.stringify(obj.options);
         }
     });
     obj.request = loader;
@@ -106,6 +104,169 @@ function createLoaderObject(loader, compiler) {
     }
     return obj;
 }
+class LoaderObject {
+    constructor(loaderItem, compiler) {
+        _LoaderObject_cachedData.set(this, void 0);
+        _LoaderObject_loaderItem.set(this, void 0);
+        const { request, path, query, fragment, options, ident, normal, pitch, raw, type } = createLoaderObject(loaderItem, compiler);
+        this.request = request;
+        this.path = path;
+        this.query = query;
+        this.fragment = fragment;
+        this.options = options;
+        this.ident = ident;
+        this.normal = normal;
+        this.pitch = pitch;
+        this.raw = raw;
+        this.type = type;
+        __classPrivateFieldSet(this, _LoaderObject_loaderItem, loaderItem, "f");
+        __classPrivateFieldSet(this, _LoaderObject_cachedData, null, "f");
+    }
+    get pitchExecuted() {
+        return (0, binding_1.__loader_item_get_pitch_executed)(__classPrivateFieldGet(this, _LoaderObject_loaderItem, "f").inner);
+    }
+    set pitchExecuted(value) {
+        (0, assert_1.default)(value);
+        (0, binding_1.__loader_item_set_pitch_executed)(__classPrivateFieldGet(this, _LoaderObject_loaderItem, "f").inner);
+    }
+    get normalExecuted() {
+        return (0, binding_1.__loader_item_get_normal_executed)(__classPrivateFieldGet(this, _LoaderObject_loaderItem, "f").inner);
+    }
+    set normalExecuted(value) {
+        (0, assert_1.default)(value);
+        (0, binding_1.__loader_item_set_normal_executed)(__classPrivateFieldGet(this, _LoaderObject_loaderItem, "f").inner);
+    }
+    // A data object shared between the pitch and the normal phase
+    get data() {
+        __classPrivateFieldSet(this, _LoaderObject_cachedData, __classPrivateFieldGet(this, _LoaderObject_cachedData, "f") ??
+            (0, binding_1.__loader_item_get_loader_data)(__classPrivateFieldGet(this, _LoaderObject_loaderItem, "f").inner) ??
+            {}, "f");
+        return new Proxy(__classPrivateFieldGet(this, _LoaderObject_cachedData, "f"), {
+            set: (_, property, value) => {
+                if (typeof property === "string") {
+                    console.log(property, value);
+                    __classPrivateFieldGet(this, _LoaderObject_cachedData, "f")[property] = value;
+                    (0, binding_1.__loader_item_set_loader_data)(__classPrivateFieldGet(this, _LoaderObject_loaderItem, "f").inner, __classPrivateFieldGet(this, _LoaderObject_cachedData, "f"));
+                }
+                return true;
+            },
+            get: (_, property) => {
+                if (typeof property === "string") {
+                    return __classPrivateFieldGet(this, _LoaderObject_cachedData, "f")[property];
+                }
+            }
+        });
+    }
+    // A data object shared between the pitch and the normal phase
+    set data(data) {
+        __classPrivateFieldSet(this, _LoaderObject_cachedData, data, "f");
+        (0, binding_1.__loader_item_set_loader_data)(__classPrivateFieldGet(this, _LoaderObject_loaderItem, "f").inner, data);
+    }
+    shouldYield() {
+        return this.request.startsWith(adapterRuleUse_1.BUILTIN_LOADER_PREFIX);
+    }
+    static __from_binding(loaderItem, compiler) {
+        return new this(loaderItem, compiler);
+    }
+    static __to_binding(loader) {
+        return __classPrivateFieldGet(loader, _LoaderObject_loaderItem, "f").inner;
+    }
+}
+exports.LoaderObject = LoaderObject;
+_LoaderObject_cachedData = new WeakMap(), _LoaderObject_loaderItem = new WeakMap();
+class JsSourceMap {
+    static __from_binding(map) {
+        return (0, util_2.isNil)(map) ? undefined : (0, util_2.toObject)(map);
+    }
+    static __to_binding(map) {
+        return (0, util_2.serializeObject)(map);
+    }
+}
+const loadLoaderAsync = (0, util_1.promisify)(loadLoader_1.default);
+const runSyncOrAsync = (0, util_1.promisify)(function runSyncOrAsync(fn, context, args, callback) {
+    let isSync = true;
+    let isDone = false;
+    let isError = false; // internal error
+    let reportedError = false;
+    // @ts-expect-error loader-runner leverages `arguments` to achieve the same functionality.
+    context.async = function async() {
+        if (isDone) {
+            if (reportedError)
+                return; // ignore
+            throw new Error("async(): The callback was already called.");
+        }
+        isSync = false;
+        return innerCallback;
+    };
+    const innerCallback = (context.callback = function (err, ...args) {
+        if (isDone) {
+            if (reportedError)
+                return; // ignore
+            throw new Error("callback(): The callback was already called.");
+        }
+        isDone = true;
+        isSync = false;
+        try {
+            // @ts-expect-error
+            callback(err, args);
+        }
+        catch (e) {
+            isError = true;
+            throw e;
+        }
+    });
+    try {
+        const result = (function LOADER_EXECUTION() {
+            return fn.apply(context, args);
+        })();
+        if (isSync) {
+            isDone = true;
+            // @ts-expect-error
+            if (result === undefined)
+                return callback();
+            if (result &&
+                typeof result === "object" &&
+                typeof result.then === "function") {
+                return result.then(function (r) {
+                    callback(null, [r]);
+                }, callback);
+            }
+            return callback(null, [result]);
+        }
+    }
+    catch (e) {
+        if (isError)
+            throw e;
+        if (isDone) {
+            // loader is already "done", so we cannot use the callback function
+            // for better debugging we print the error on the console
+            if (e instanceof Error)
+                console.error(e.stack);
+            else
+                console.error(e);
+            return;
+        }
+        isDone = true;
+        reportedError = true;
+        // @ts-expect-error
+        callback(e);
+    }
+});
+function dirname(path) {
+    if (path === "/")
+        return "/";
+    const i = path.lastIndexOf("/");
+    const j = path.lastIndexOf("\\");
+    const i2 = path.indexOf("/");
+    const j2 = path.indexOf("\\");
+    const idx = i > j ? i : j;
+    const idx2 = i > j ? i2 : j2;
+    if (idx < 0)
+        return path;
+    if (idx === idx2)
+        return path.slice(0, idx + 1);
+    return path.slice(0, idx);
+}
 function getCurrentLoader(loaderContext, index = loaderContext.loaderIndex) {
     if (loaderContext.loaders &&
         loaderContext.loaders.length &&
@@ -116,10 +277,10 @@ function getCurrentLoader(loaderContext, index = loaderContext.loaderIndex) {
     }
     return null;
 }
-async function runLoaders(compiler, rawContext) {
-    const resource = rawContext.resource;
-    const loaderContext = {};
+async function runLoaders(compiler, context) {
+    const loaderState = context.loaderState;
     //
+    const { resource } = context.resourceData;
     const splittedResource = resource && parsePathQueryFragment(resource);
     const resourcePath = splittedResource ? splittedResource.path : undefined;
     const resourceQuery = splittedResource ? splittedResource.query : undefined;
@@ -128,51 +289,21 @@ async function runLoaders(compiler, rawContext) {
         : undefined;
     const contextDirectory = resourcePath ? dirname(resourcePath) : null;
     // execution state
-    let cacheable = true;
-    const fileDependencies = rawContext.fileDependencies.slice();
-    const contextDependencies = rawContext.contextDependencies.slice();
-    const missingDependencies = rawContext.missingDependencies.slice();
-    const buildDependencies = rawContext.buildDependencies.slice();
-    const assetFilenames = rawContext.assetFilenames.slice();
-    const loaders = rawContext.currentLoader.split("$").map(loader => {
-        const splittedRequest = (0, identifier_1.parseResourceWithoutFragment)(loader);
-        const obj = {};
-        obj.loader = obj.path = splittedRequest.path;
-        obj.query = splittedRequest.query;
-        obj.fragment = splittedRequest.fragment;
-        const type = /\.mjs$/i.test(splittedRequest.path) ? "module" : "commonjs";
-        obj.type = type;
-        obj.options = splittedRequest.query
-            ? splittedRequest.query.slice(1)
-            : undefined;
-        if (typeof obj.options === "string" && obj.options[0] === "?") {
-            const ident = obj.options.slice(1);
-            if (ident === "[[missing ident]]") {
-                throw new Error("No ident is provided by referenced loader. " +
-                    "When using a function for Rule.use in config you need to " +
-                    "provide an 'ident' property for referenced loader options.");
-            }
-            obj.options = compiler.__internal__ruleSet.references.get(ident);
-            if (obj.options === undefined) {
-                throw new Error(`Invalid ident("${ident}") is provided by referenced loader`);
-            }
-            obj.ident = ident;
-        }
-        return createLoaderObject(obj, compiler);
+    const fileDependencies = context.fileDependencies;
+    const contextDependencies = context.contextDependencies;
+    const missingDependencies = context.missingDependencies;
+    const buildDependencies = context.buildDependencies;
+    const assetFilenames = context.assetFilenames;
+    /// Construct `loaderContext`
+    const loaderContext = {};
+    loaderContext.loaders = context.loaderItems.map(item => {
+        return LoaderObject.__from_binding(item, compiler);
     });
-    loaderContext.__internal__context = rawContext;
-    loaderContext.hot = rawContext.hot;
+    loaderContext.hot = context.hot;
     loaderContext.context = contextDirectory;
-    loaderContext.loaderIndex = 0;
-    loaderContext.loaders = loaders;
     loaderContext.resourcePath = resourcePath;
     loaderContext.resourceQuery = resourceQuery;
     loaderContext.resourceFragment = resourceFragment;
-    loaderContext.cacheable = function (flag) {
-        if (flag === false) {
-            cacheable = false;
-        }
-    };
     loaderContext.dependency = loaderContext.addDependency =
         function addDependency(file) {
             fileDependencies.push(file);
@@ -183,6 +314,9 @@ async function runLoaders(compiler, rawContext) {
     loaderContext.addMissingDependency = function addMissingDependency(context) {
         missingDependencies.push(context);
     };
+    loaderContext.addBuildDependency = function addBuildDependency(file) {
+        buildDependencies.push(file);
+    };
     loaderContext.getDependencies = function getDependencies() {
         return fileDependencies.slice();
     };
@@ -196,14 +330,14 @@ async function runLoaders(compiler, rawContext) {
         fileDependencies.length = 0;
         contextDependencies.length = 0;
         missingDependencies.length = 0;
-        cacheable = true;
+        context.cacheable = true;
     };
     loaderContext.importModule = function importModule(request, options, callback) {
         if (!callback) {
             return new Promise((resolve, reject) => {
                 compiler
                     ._lastCompilation.__internal_getInner()
-                    .importModule(request, options.publicPath, options.baseUri, rawContext._module.moduleIdentifier, loaderContext.context, (err, res) => {
+                    .importModule(request, options.publicPath, options.baseUri, context._module.moduleIdentifier, loaderContext.context, (err, res) => {
                     if (err)
                         reject(err);
                     else {
@@ -230,7 +364,7 @@ async function runLoaders(compiler, rawContext) {
         }
         return compiler
             ._lastCompilation.__internal_getInner()
-            .importModule(request, options.publicPath, options.baseUri, rawContext._module.moduleIdentifier, loaderContext.context, (err, res) => {
+            .importModule(request, options.publicPath, options.baseUri, context._module.moduleIdentifier, loaderContext.context, (err, res) => {
             if (err) {
                 callback(err, undefined);
             }
@@ -335,12 +469,6 @@ async function runLoaders(compiler, rawContext) {
                 : entry.query;
         }
     });
-    Object.defineProperty(loaderContext, "data", {
-        enumerable: true,
-        get: function () {
-            return loaderContext.loaders[loaderContext.loaderIndex].data;
-        }
-    });
     loaderContext.version = 2;
     loaderContext.sourceMap = compiler.options.devtool
         ? (0, adapterRuleUse_1.isUseSourceMap)(compiler.options.devtool)
@@ -399,18 +527,14 @@ async function runLoaders(compiler, rawContext) {
     loaderContext.rootContext = compiler.context;
     loaderContext.emitError = function emitError(error) {
         const title = "Module Error";
-        const message = error instanceof Error ? (0, util_1.concatErrorMsgAndStack)(error) : error;
-        compiler._lastCompilation.__internal__pushDiagnostic("error", title, `${message}\n(from: ${(0, util_1.stringifyLoaderObject)(loaderContext.loaders[loaderContext.loaderIndex])})`);
+        const message = error instanceof Error ? (0, util_2.concatErrorMsgAndStack)(error) : error;
+        compiler._lastCompilation.__internal__pushDiagnostic("error", title, `${message}\n(from: ${(0, util_2.stringifyLoaderObject)(loaderContext.loaders[loaderContext.loaderIndex])})`);
     };
     loaderContext.emitWarning = function emitWarning(warning) {
         const title = "Module Warning";
-        const message = warning instanceof Error ? (0, util_1.concatErrorMsgAndStack)(warning) : warning;
-        compiler._lastCompilation.__internal__pushDiagnostic("warning", title, `${message}\n(from: ${(0, util_1.stringifyLoaderObject)(loaderContext.loaders[loaderContext.loaderIndex])})`);
+        const message = warning instanceof Error ? (0, util_2.concatErrorMsgAndStack)(warning) : warning;
+        compiler._lastCompilation.__internal__pushDiagnostic("warning", title, `${message}\n(from: ${(0, util_2.stringifyLoaderObject)(loaderContext.loaders[loaderContext.loaderIndex])})`);
     };
-    loaderContext.__internal__pushNativeDiagnostics =
-        function __internal__pushNativeDiagnostics(diagnostics) {
-            compiler._lastCompilation.__internal__pushNativeDiagnostics(diagnostics);
-        };
     loaderContext.emitFile = function emitFile(name, content, sourceMap, assetInfo) {
         let source;
         if (sourceMap) {
@@ -455,38 +579,9 @@ async function runLoaders(compiler, rawContext) {
             return (0, createHash_1.createHash)(type || compiler._lastCompilation.outputOptions.hashFunction);
         }
     };
-    loaderContext.addBuildDependency = function addBuildDependency(file) {
-        buildDependencies.push(file);
-    };
-    loaderContext.addDependency = function addDependency(file) {
-        fileDependencies.push(file);
-    };
-    loaderContext.dependency = function dependency(file) {
-        fileDependencies.push(file);
-    };
-    loaderContext.addContextDependency = function addContextDependency(context) {
-        contextDependencies.push(context);
-    };
-    loaderContext.addMissingDependency = function addMissingDependency(missing) {
-        missingDependencies.push(missing);
-    };
-    loaderContext.clearDependencies = function clearDependencies() {
-        fileDependencies.length = 0;
-        contextDependencies.length = 0;
-        missingDependencies.length = 0;
-    };
-    loaderContext.getDependencies = function getDependencies() {
-        return fileDependencies.slice();
-    };
-    loaderContext.getContextDependencies = function getContextDependencies() {
-        return contextDependencies.slice();
-    };
-    loaderContext.getMissingDependencies = function getMissingDependencies() {
-        return missingDependencies.slice();
-    };
     loaderContext._compiler = compiler;
     loaderContext._compilation = compiler._lastCompilation;
-    loaderContext._module = Module_1.Module.__from_binding(rawContext._module, compiler._lastCompilation);
+    loaderContext._module = Module_1.Module.__from_binding(context._module, compiler._lastCompilation);
     loaderContext.getOptions = function () {
         const loader = getCurrentLoader(loaderContext);
         let options = loader?.options;
@@ -501,7 +596,7 @@ async function runLoaders(compiler, rawContext) {
                 }
             }
             else {
-                options = querystring.parse(options);
+                options = node_querystring_1.default.parse(options);
             }
         }
         if (options === null || options === undefined) {
@@ -519,60 +614,89 @@ async function runLoaders(compiler, rawContext) {
             throw Error("Too many nested child compiler, exceeded max limitation 1000");
         }
     }
-    return new Promise((resolve, reject) => {
-        if (loaderContext.__internal__context.isPitching) {
-            iteratePitchingLoaders(loaderContext, [], (err, result) => {
-                if (err) {
-                    return reject(err);
+    /// Sync with `context`
+    Object.defineProperty(loaderContext, "loaderIndex", {
+        enumerable: true,
+        get: () => context.loaderIndex,
+        set: loaderIndex => (context.loaderIndex = loaderIndex)
+    });
+    Object.defineProperty(loaderContext, "cacheable", {
+        enumerable: true,
+        get: () => (cacheable) => {
+            if (cacheable === false) {
+                context.cacheable = cacheable;
+            }
+        }
+    });
+    Object.defineProperty(loaderContext, "data", {
+        enumerable: true,
+        get: () => loaderContext.loaders[loaderContext.loaderIndex].data,
+        set: data => (loaderContext.loaders[loaderContext.loaderIndex].data = data)
+    });
+    switch (loaderState) {
+        case binding_1.JsLoaderState.Pitching: {
+            while (loaderContext.loaderIndex < loaderContext.loaders.length) {
+                const currentLoaderObject = loaderContext.loaders[loaderContext.loaderIndex];
+                if (currentLoaderObject.shouldYield())
+                    break;
+                if (currentLoaderObject.pitchExecuted) {
+                    loaderContext.loaderIndex += 1;
+                    continue;
                 }
-                const [content, sourceMap, additionalData] = result;
-                resolve({
-                    content: (0, util_1.isNil)(content) ? undefined : (0, util_1.toBuffer)(content),
-                    sourceMap: (0, util_1.serializeObject)(sourceMap),
-                    additionalData,
-                    buildDependencies,
-                    cacheable,
-                    fileDependencies,
-                    contextDependencies,
-                    missingDependencies,
-                    assetFilenames,
-                    isPitching: loaderContext.__internal__context.isPitching,
-                    additionalDataExternal: loaderContext.__internal__context.additionalDataExternal
+                await loadLoaderAsync(currentLoaderObject);
+                const fn = currentLoaderObject.pitch;
+                currentLoaderObject.pitchExecuted = true;
+                if (!fn)
+                    continue;
+                const args = (await runSyncOrAsync(fn, loaderContext, [
+                    loaderContext.remainingRequest,
+                    loaderContext.previousRequest,
+                    currentLoaderObject.data
+                ])) || [];
+                const hasArg = args.some(function (value) {
+                    return value !== undefined;
                 });
-            });
+                if (hasArg) {
+                    const [content, sourceMap, additionalData] = args;
+                    context.content = (0, util_2.isNil)(content) ? null : (0, util_2.toBuffer)(content);
+                    context.sourceMap = (0, util_2.serializeObject)(sourceMap);
+                    context.additionalData = additionalData;
+                    break;
+                }
+            }
+            break;
         }
-        else {
-            // normal
-            loaderContext.loaderIndex = loaderContext.loaders.length - 1;
-            iterateNormalLoaders(loaderContext, [
-                rawContext.content,
-                (0, util_1.isNil)(rawContext.sourceMap)
-                    ? undefined
-                    : (0, util_1.toObject)(rawContext.sourceMap),
-                (0, util_1.isNil)(rawContext.additionalData)
-                    ? undefined
-                    : rawContext.additionalData
-            ], (err, result) => {
-                if (err) {
-                    return reject(err);
+        case binding_1.JsLoaderState.Normal: {
+            let content = context.content;
+            let sourceMap = JsSourceMap.__from_binding(context.sourceMap);
+            let additionalData = context.additionalData;
+            while (loaderContext.loaderIndex >= 0) {
+                const currentLoaderObject = loaderContext.loaders[loaderContext.loaderIndex];
+                if (currentLoaderObject.shouldYield())
+                    break;
+                if (currentLoaderObject.normalExecuted) {
+                    loaderContext.loaderIndex--;
+                    continue;
                 }
-                const [content, sourceMap, additionalData] = result;
-                resolve({
-                    content: (0, util_1.isNil)(content) ? undefined : (0, util_1.toBuffer)(content),
-                    sourceMap: (0, util_1.serializeObject)(sourceMap),
-                    additionalData,
-                    buildDependencies,
-                    cacheable,
-                    fileDependencies,
-                    contextDependencies,
-                    missingDependencies,
-                    assetFilenames,
-                    isPitching: loaderContext.__internal__context.isPitching,
-                    additionalDataExternal: loaderContext.__internal__context.additionalDataExternal
-                });
-            });
+                await loadLoaderAsync(currentLoaderObject);
+                const fn = currentLoaderObject.normal;
+                currentLoaderObject.normalExecuted = true;
+                if (!fn)
+                    continue;
+                let args = [content, sourceMap, additionalData];
+                convertArgs(args, !!currentLoaderObject.raw);
+                [content, sourceMap, additionalData] =
+                    (await runSyncOrAsync(fn, loaderContext, args)) || [];
+            }
+            context.content = (0, util_2.isNil)(content) ? null : (0, util_2.toBuffer)(content);
+            context.sourceMap = JsSourceMap.__to_binding(sourceMap);
+            context.additionalData = additionalData;
+            break;
         }
-    });
+        default:
+            throw new Error(`Unexpected loader runner state: ${loaderState}`);
+    }
+    return context;
 }
 exports.runLoaders = runLoaders;
 function utf8BufferToString(buf) {
@@ -590,149 +714,13 @@ function convertArgs(args, raw) {
     else if (raw && typeof args[0] === "string")
         args[0] = Buffer.from(args[0], "utf-8");
 }
-function runSyncOrAsync(fn, context, args, callback) {
-    let isSync = true;
-    let isDone = false;
-    let isError = false; // internal error
-    let reportedError = false;
-    // @ts-expect-error loader-runner leverages `arguments` to achieve the same functionality.
-    context.async = function async() {
-        if (isDone) {
-            if (reportedError)
-                return; // ignore
-            throw new Error("async(): The callback was already called.");
-        }
-        isSync = false;
-        return innerCallback;
+const PATH_QUERY_FRAGMENT_REGEXP = /^((?:\u200b.|[^?#\u200b])*)(\?(?:\u200b.|[^#\u200b])*)?(#.*)?$/;
+function parsePathQueryFragment(str) {
+    const match = PATH_QUERY_FRAGMENT_REGEXP.exec(str);
+    return {
+        path: match?.[1].replace(/\u200b(.)/g, "$1") || "",
+        query: match?.[2] ? match[2].replace(/\u200b(.)/g, "$1") : "",
+        fragment: match?.[3] || ""
     };
-    const innerCallback = (context.callback = function () {
-        if (isDone) {
-            if (reportedError)
-                return; // ignore
-            throw new Error("callback(): The callback was already called.");
-        }
-        isDone = true;
-        isSync = false;
-        try {
-            callback.apply(null, arguments);
-        }
-        catch (e) {
-            isError = true;
-            throw e;
-        }
-    });
-    try {
-        const result = (function LOADER_EXECUTION() {
-            return fn.apply(context, args);
-        })();
-        if (isSync) {
-            isDone = true;
-            if (result === undefined)
-                return callback();
-            if (result &&
-                typeof result === "object" &&
-                typeof result.then === "function") {
-                return result.then(function (r) {
-                    callback(null, r);
-                }, callback);
-            }
-            return callback(null, result);
-        }
-    }
-    catch (e) {
-        if (isError)
-            throw e;
-        if (isDone) {
-            // loader is already "done", so we cannot use the callback function
-            // for better debugging we print the error on the console
-            if (e instanceof Error)
-                console.error(e.stack);
-            else
-                console.error(e);
-            return;
-        }
-        isDone = true;
-        reportedError = true;
-        callback(e);
-    }
-}
-function iteratePitchingLoaders(loaderContext, args, callback) {
-    // Running out of js loaders, so yield back to rust.
-    // Directly callback as we may still have other loaders on the rust side,
-    // The difference between rspack loader-runner and webpack loader-runner is
-    // that we do not run the loaders in the normal stage if pitching is not successful.
-    if (loaderContext.loaderIndex >= loaderContext.loaders.length)
-        return callback(null, args);
-    const currentLoaderObject = loaderContext.loaders[loaderContext.loaderIndex];
-    // iterate
-    if (currentLoaderObject.pitchExecuted) {
-        loaderContext.loaderIndex++;
-        return iteratePitchingLoaders(loaderContext, args, callback);
-    }
-    // load loader module
-    loadLoader(currentLoaderObject, function (err) {
-        if (err) {
-            loaderContext.cacheable(false);
-            return callback(err);
-        }
-        const fn = currentLoaderObject.pitch;
-        currentLoaderObject.pitchExecuted = true;
-        if (!fn)
-            return iteratePitchingLoaders(loaderContext, args, callback);
-        runSyncOrAsync(fn, loaderContext, [
-            loaderContext.remainingRequest,
-            loaderContext.previousRequest,
-            (currentLoaderObject.data = {})
-        ], function (err) {
-            if (err)
-                return callback(err);
-            const args = Array.prototype.slice.call(arguments, 1);
-            // Determine whether to continue the pitching process based on
-            // argument values (as opposed to argument presence) in order
-            // to support synchronous and asynchronous usages.
-            const hasArg = args.some(function (value) {
-                return value !== undefined;
-            });
-            // If a loader pitched successfully,
-            // then It should execute normal loaders too.
-            if (hasArg) {
-                // Instruct rust side to execute loaders in backwards.
-                loaderContext.__internal__context.isPitching = false;
-                loaderContext.loaderIndex--;
-                iterateNormalLoaders(loaderContext, args, callback);
-            }
-            else {
-                iteratePitchingLoaders(loaderContext, args, callback);
-            }
-        });
-    });
-}
-function iterateNormalLoaders(loaderContext, args, callback) {
-    // JS loaders ends
-    if (loaderContext.loaderIndex < 0)
-        return callback(null, args);
-    const currentLoaderObject = loaderContext.loaders[loaderContext.loaderIndex];
-    // iterate
-    if (currentLoaderObject.normalExecuted) {
-        loaderContext.loaderIndex--;
-        return iterateNormalLoaders(loaderContext, args, callback);
-    }
-    loadLoader(currentLoaderObject, function (err) {
-        if (err) {
-            loaderContext.cacheable(false);
-            return callback(err);
-        }
-        const fn = currentLoaderObject.normal;
-        currentLoaderObject.normalExecuted = true;
-        if (!fn) {
-            return iterateNormalLoaders(loaderContext, args, callback);
-        }
-        convertArgs(args, !!currentLoaderObject.raw);
-        runSyncOrAsync(fn, loaderContext, args, function (err) {
-            if (err)
-                return callback(err);
-            const args = Array.prototype.slice.call(arguments, 1);
-            iterateNormalLoaders(loaderContext, args, callback);
-        });
-    });
 }
+exports.parsePathQueryFragment = parsePathQueryFragment;