@bleedingdev/modern-js-renderer-core 0.0.0-bootstrap → 3.9.3-ultramodern.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Modern.js
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/cjs/abort.js

@@ -0,0 +1,65 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+function untilAborted(handled, signal) {
+    const settled = Promise.resolve(handled);
+    const discard = ()=>void settled.then((value)=>{
+            if (value instanceof Response) value.body?.cancel().catch(()=>{});
+        }, ()=>{});
+    if (signal.aborted) {
+        discard();
+        return Promise.reject(signal.reason);
+    }
+    return new Promise((resolve, reject)=>{
+        const onAbort = ()=>{
+            discard();
+            reject(signal.reason);
+        };
+        signal.addEventListener('abort', onAbort, {
+            once: true
+        });
+        settled.then((value)=>{
+            signal.removeEventListener('abort', onAbort);
+            resolve(value);
+        }, (error)=>{
+            signal.removeEventListener('abort', onAbort);
+            reject(error);
+        });
+    });
+}
+__webpack_require__.d(__webpack_exports__, {
+    untilAborted: ()=>untilAborted
+});
+exports.untilAborted = __webpack_exports__.untilAborted;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "untilAborted"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/adapter.js

@@ -0,0 +1,62 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+const adapterError = (name, detail)=>new Error(`Invalid renderer adapter ${String(name)}: ${detail}`);
+function defineRendererAdapter(adapter) {
+    const { name, profile } = adapter;
+    if (profile.renderer !== name) throw adapterError(name, `profile names ${profile.renderer}`);
+    if (!adapter.routerFrameworks.length) throw adapterError(name, 'it declares no router framework');
+    if (adapter.worker.rsc !== profile.capabilities.rsc) throw adapterError(name, 'worker RSC support contradicts its profile');
+    if ('native' === adapter.kind) {
+        if (true !== adapter.worker.nativeDocuments) throw adapterError(name, 'native documents come from its server handler');
+        const federation = adapter.federation;
+        const capability = profile.capabilities.moduleFederation;
+        if (void 0 === federation !== (false === capability) || void 0 !== federation && federation.ssr !== (true === capability)) throw adapterError(name, 'federation support contradicts its profile');
+    }
+    return Object.freeze(adapter);
+}
+function nativeRendererDependencies(profile) {
+    return {
+        ...Object.fromEntries(Object.entries(profile.dependencies).filter(([name])=>!name.startsWith('@modern-js/'))),
+        [profile.router.coreName]: profile.router.coreVersion
+    };
+}
+__webpack_require__.d(__webpack_exports__, {
+    defineRendererAdapter: ()=>defineRendererAdapter,
+    nativeRendererDependencies: ()=>nativeRendererDependencies
+});
+exports.defineRendererAdapter = __webpack_exports__.defineRendererAdapter;
+exports.nativeRendererDependencies = __webpack_exports__.nativeRendererDependencies;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "defineRendererAdapter",
+    "nativeRendererDependencies"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/data/body.js

@@ -0,0 +1,78 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    readBoundedDataText: ()=>readBoundedDataText
+});
+const external_codec_js_namespaceObject = require("./codec.js");
+async function readBoundedDataText(response, signal, maxBytes = external_codec_js_namespaceObject.MAX_DATA_BYTES) {
+    if (signal?.aborted) {
+        response.body?.cancel(signal.reason).catch(()=>void 0);
+        signal.throwIfAborted();
+    }
+    if (!response.body) return '';
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder('utf-8', {
+        fatal: true
+    });
+    let bytes = 0;
+    let text = '';
+    const abort = ()=>{
+        reader.cancel(signal?.reason).catch(()=>void 0);
+    };
+    signal?.addEventListener('abort', abort, {
+        once: true
+    });
+    try {
+        while(true){
+            const result = await reader.read();
+            signal?.throwIfAborted();
+            if (result.done) break;
+            bytes += result.value.byteLength;
+            if (bytes > maxBytes) throw new external_codec_js_namespaceObject.DataProtocolError('Public data exceeds its byte limit');
+            text += decoder.decode(result.value, {
+                stream: true
+            });
+        }
+        return text + decoder.decode();
+    } catch (error) {
+        reader.cancel(error).catch(()=>void 0);
+        throw error;
+    } finally{
+        signal?.removeEventListener('abort', abort);
+        reader.releaseLock();
+    }
+}
+exports.readBoundedDataText = __webpack_exports__.readBoundedDataText;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "readBoundedDataText"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/data/client.js

@@ -0,0 +1,409 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createDataClient: ()=>createDataClient,
+    readDataResponse: ()=>readDataResponse
+});
+const external_abort_js_namespaceObject = require("../abort.js");
+const external_identity_js_namespaceObject = require("../identity.js");
+const external_body_js_namespaceObject = require("./body.js");
+const external_codec_js_namespaceObject = require("./codec.js");
+const external_static_js_namespaceObject = require("./static.js");
+const external_types_js_namespaceObject = require("./types.js");
+const isRecord = (value)=>null !== value && 'object' == typeof value && !Array.isArray(value);
+function assertKeys(record, keys, required = []) {
+    if (Object.keys(record).some((key)=>!keys.includes(key))) throw new external_codec_js_namespaceObject.DataProtocolError('Unknown data protocol field');
+    if (required.some((key)=>!Object.hasOwn(record, key))) throw new external_codec_js_namespaceObject.DataProtocolError('Missing data protocol field');
+}
+function assertError(value) {
+    if (!isRecord(value)) throw new external_codec_js_namespaceObject.DataProtocolError('Malformed public error');
+    assertKeys(value, [
+        'name',
+        'message',
+        'stack'
+    ]);
+    if ('string' != typeof value['name'] || 'string' != typeof value['message'] || Object.hasOwn(value, 'stack') && 'string' != typeof value['stack']) throw new external_codec_js_namespaceObject.DataProtocolError('Malformed public error');
+}
+function assertEnvelope(value, expected) {
+    if (!isRecord(value) || value['version'] !== external_types_js_namespaceObject.DATA_PROTOCOL_VERSION || value['routeId'] !== expected.routeId || value['operation'] !== expected.operation || !isRecord(value['identity']) || !isRecord(value['outcome'])) throw new external_codec_js_namespaceObject.DataProtocolError('Data protocol or route identity mismatch');
+    assertKeys(value, [
+        'version',
+        'identity',
+        'routeId',
+        'operation',
+        'outcome',
+        'deferredKeys'
+    ]);
+    assertKeys(value['identity'], [
+        'renderer',
+        'appId',
+        'entryName',
+        'protocolVersion',
+        'buildId'
+    ]);
+    try {
+        (0, external_identity_js_namespaceObject.assertRendererIdentity)(value['identity'], expected.identity);
+    } catch  {
+        throw new external_codec_js_namespaceObject.DataProtocolError('Data renderer or build identity mismatch');
+    }
+    const outcome = value['outcome'];
+    if (!Number.isInteger(outcome['status']) || outcome['status'] < 200 || outcome['status'] > 599) throw new external_codec_js_namespaceObject.DataProtocolError('Malformed data response status');
+    switch(outcome['kind']){
+        case 'success':
+            assertKeys(outcome, [
+                'kind',
+                'value',
+                'status'
+            ], [
+                'value'
+            ]);
+            break;
+        case 'redirect':
+            assertKeys(outcome, [
+                'kind',
+                'location',
+                'status'
+            ]);
+            if ('string' != typeof outcome['location'] || ![
+                301,
+                302,
+                303,
+                307,
+                308
+            ].includes(outcome['status'])) throw new external_codec_js_namespaceObject.DataProtocolError('Malformed data redirect');
+            break;
+        case 'not-found':
+            assertKeys(outcome, [
+                'kind',
+                'value',
+                'thrown',
+                'status'
+            ], [
+                'value'
+            ]);
+            if (404 !== outcome['status'] || 'boolean' != typeof outcome['thrown']) throw new external_codec_js_namespaceObject.DataProtocolError('Malformed not-found outcome');
+            break;
+        case 'error':
+            assertKeys(outcome, [
+                'kind',
+                'error',
+                'data',
+                'thrown',
+                'status'
+            ]);
+            assertError(outcome['error']);
+            if ('boolean' != typeof outcome['thrown']) throw new external_codec_js_namespaceObject.DataProtocolError('Malformed error outcome');
+            break;
+        default:
+            throw new external_codec_js_namespaceObject.DataProtocolError('Unknown data outcome');
+    }
+    if (Object.hasOwn(value, 'deferredKeys')) {
+        if (!Array.isArray(value['deferredKeys']) || value['deferredKeys'].some((key)=>'string' != typeof key) || new Set(value['deferredKeys']).size !== value['deferredKeys'].length || 'success' !== outcome['kind'] || !isRecord(outcome['value']) || value['deferredKeys'].some((key)=>Object.hasOwn(outcome['value'], key))) throw new external_codec_js_namespaceObject.DataProtocolError('Malformed deferred data keys');
+    }
+}
+function dataError(error) {
+    const result = new Error(error.message);
+    result.name = error.name;
+    if (void 0 !== error.stack) result.stack = error.stack;
+    else delete result.stack;
+    return result;
+}
+async function readDeferredResponse(response, expected, signal) {
+    if (!response.body) throw new external_codec_js_namespaceObject.DataProtocolError('Missing deferred data body');
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder('utf-8', {
+        fatal: true
+    });
+    let buffer = '';
+    let initialized = false;
+    let completed = false;
+    let initialResolve;
+    let initialReject;
+    const initial = new Promise((resolve, reject)=>{
+        initialResolve = resolve;
+        initialReject = reject;
+    });
+    let completionResolve;
+    let completionReject;
+    const completion = new Promise((resolve, reject)=>{
+        completionResolve = resolve;
+        completionReject = reject;
+    });
+    completion.catch(()=>void 0);
+    const pending = new Map();
+    const reject = (error)=>{
+        completionReject(error);
+        if (!initialized) initialReject(error);
+        for (const promise of pending.values())promise.reject(error);
+        pending.clear();
+    };
+    const abort = ()=>{
+        const reason = signal?.reason ?? new DOMException('The data request was aborted', 'AbortError');
+        reject(reason);
+        reader.cancel(reason).catch(()=>void 0);
+    };
+    if (signal?.aborted) abort();
+    else signal?.addEventListener('abort', abort, {
+        once: true
+    });
+    const consume = (text)=>{
+        if (completed) throw new external_codec_js_namespaceObject.DataProtocolError('Data frames follow stream completion');
+        const frame = (0, external_codec_js_namespaceObject.parsePublicData)(text);
+        if (!isRecord(frame)) throw new external_codec_js_namespaceObject.DataProtocolError('Malformed data stream frame');
+        if ('initial' === frame['type']) {
+            assertKeys(frame, [
+                'type',
+                'envelope'
+            ]);
+            if (initialized) throw new external_codec_js_namespaceObject.DataProtocolError('Duplicate initial data frame');
+            assertEnvelope(frame['envelope'], expected);
+            const envelope = frame['envelope'];
+            if (!Array.isArray(envelope.deferredKeys) || 'success' !== envelope.outcome.kind) throw new external_codec_js_namespaceObject.DataProtocolError('Initial stream frame needs deferred keys');
+            const value = envelope.outcome.value;
+            for (const key of envelope.deferredKeys){
+                const promise = new Promise((resolve, rejectPromise)=>{
+                    pending.set(key, {
+                        resolve,
+                        reject: rejectPromise
+                    });
+                });
+                promise.catch(()=>void 0);
+                Object.defineProperty(value, key, {
+                    value: promise,
+                    writable: true,
+                    enumerable: true,
+                    configurable: true
+                });
+            }
+            initialized = true;
+            const outcome = {
+                ...envelope.outcome,
+                value
+            };
+            Object.defineProperty(outcome, 'completion', {
+                value: completion
+            });
+            initialResolve(outcome);
+            return;
+        }
+        if (!initialized) throw new external_codec_js_namespaceObject.DataProtocolError('Deferred data arrived before the initial frame');
+        if ('complete' === frame['type']) {
+            assertKeys(frame, [
+                'type'
+            ]);
+            if (0 !== pending.size) throw new external_codec_js_namespaceObject.DataProtocolError('Deferred stream completed with unresolved values');
+            completed = true;
+            return;
+        }
+        if ('resolve' !== frame['type'] && 'reject' !== frame['type']) throw new external_codec_js_namespaceObject.DataProtocolError('Unknown data stream frame');
+        'resolve' === frame['type'] ? assertKeys(frame, [
+            'type',
+            'key',
+            'value'
+        ], [
+            'value'
+        ]) : assertKeys(frame, [
+            'type',
+            'key',
+            'error'
+        ]);
+        if ('string' != typeof frame['key'] || !pending.has(frame['key'])) throw new external_codec_js_namespaceObject.DataProtocolError('Unknown or duplicate deferred data key');
+        const promise = pending.get(frame['key']);
+        if ('resolve' === frame['type']) promise.resolve(frame['value']);
+        else {
+            assertError(frame['error']);
+            promise.reject(dataError(frame['error']));
+        }
+        pending.delete(frame['key']);
+    };
+    const append = (text)=>{
+        buffer += text;
+        let lineEnd = buffer.indexOf('\n');
+        while(-1 !== lineEnd){
+            const line = buffer.slice(0, lineEnd);
+            buffer = buffer.slice(lineEnd + 1);
+            if (!line) throw new external_codec_js_namespaceObject.DataProtocolError('Empty data stream frame');
+            consume(line);
+            lineEnd = buffer.indexOf('\n');
+        }
+        if (new TextEncoder().encode(buffer).byteLength > external_codec_js_namespaceObject.MAX_DATA_BYTES) throw new external_codec_js_namespaceObject.DataProtocolError('Deferred data frame exceeds its size limit');
+    };
+    (async ()=>{
+        try {
+            while(true){
+                const chunk = await reader.read();
+                if (chunk.done) {
+                    append(decoder.decode());
+                    break;
+                }
+                for(let offset = 0; offset < chunk.value.byteLength; offset += 65536)append(decoder.decode(chunk.value.subarray(offset, offset + 65536), {
+                    stream: true
+                }));
+            }
+            if ('' !== buffer || !completed) throw new external_codec_js_namespaceObject.DataProtocolError('Truncated deferred data stream');
+            completionResolve();
+        } catch (error) {
+            reject(error);
+            reader.cancel(error).catch(()=>void 0);
+        } finally{
+            signal?.removeEventListener('abort', abort);
+            reader.releaseLock();
+        }
+    })();
+    return initial;
+}
+async function readDataResponse(response, expected, signal) {
+    const discard = (reason)=>{
+        response.body?.cancel(reason).catch(()=>void 0);
+    };
+    if (signal?.aborted) {
+        discard(signal.reason);
+        signal.throwIfAborted();
+    }
+    const contentType = response.headers.get('content-type')?.split(';')[0]?.trim();
+    if (contentType === external_types_js_namespaceObject.DATA_STREAM_CONTENT_TYPE) return readDeferredResponse(response, expected, signal);
+    if (contentType !== external_types_js_namespaceObject.DATA_CONTENT_TYPE) {
+        const error = new external_codec_js_namespaceObject.DataProtocolError(`Expected an UltraModern data response, received HTTP ${response.status}`);
+        discard(error);
+        throw error;
+    }
+    const value = (0, external_codec_js_namespaceObject.parsePublicData)(await (0, external_body_js_namespaceObject.readBoundedDataText)(response, signal));
+    signal?.throwIfAborted();
+    assertEnvelope(value, expected);
+    if (Object.hasOwn(value, 'deferredKeys')) throw new external_codec_js_namespaceObject.DataProtocolError('Deferred values require the stream protocol');
+    return value.outcome;
+}
+async function readStaticPayload(url, routeId, fetchData, request) {
+    if (url.search || !(0, external_static_js_namespaceObject.isPrerenderedDocument)()) return;
+    let response;
+    try {
+        response = await (0, external_abort_js_namespaceObject.untilAborted)(fetchData(new URL((0, external_static_js_namespaceObject.staticDataPayloadPath)(url.pathname, routeId), url), {
+            credentials: 'same-origin',
+            signal: request.signal
+        }), request.signal);
+    } catch  {
+        request.signal.throwIfAborted();
+        return;
+    }
+    if (!response.ok) return void response.body?.cancel().catch(()=>void 0);
+    let payload;
+    try {
+        payload = JSON.parse(await (0, external_body_js_namespaceObject.readBoundedDataText)(response, request.signal, external_static_js_namespaceObject.STATIC_DATA_PAYLOAD_MAX_BYTES));
+    } catch  {
+        request.signal.throwIfAborted();
+        return;
+    }
+    if (!(0, external_static_js_namespaceObject.isStaticDataPayload)(payload)) return;
+    return new Response(payload.body, {
+        status: payload.status,
+        headers: {
+            'content-type': payload.contentType
+        }
+    });
+}
+async function bufferRequestBody(request) {
+    if (!request.body) return null;
+    const { signal } = request;
+    if (/^multipart\/form-data\b/iu.test(request.headers.get('content-type') ?? '')) return (0, external_abort_js_namespaceObject.untilAborted)(request.blob(), signal);
+    const reader = request.body.getReader();
+    const cancel = ()=>{
+        reader.cancel(signal.reason).catch(()=>{});
+    };
+    signal.addEventListener('abort', cancel, {
+        once: true
+    });
+    try {
+        const chunks = [];
+        for(;;){
+            const part = await reader.read();
+            signal.throwIfAborted();
+            if (part.done) break;
+            chunks.push(part.value);
+        }
+        return new Blob(chunks, {
+            type: request.headers.get('content-type') ?? ''
+        });
+    } finally{
+        signal.removeEventListener('abort', cancel);
+    }
+}
+function createDataClient(routeId, identity, options = {}) {
+    if (!routeId) throw new external_codec_js_namespaceObject.DataProtocolError('A data client requires a route ID');
+    const fetchData = options.fetch ?? globalThis.fetch;
+    const execute = async (operation, input)=>{
+        const request = input.request;
+        request.signal.throwIfAborted();
+        if ('loader' === operation && 'GET' !== request.method) throw new external_codec_js_namespaceObject.DataProtocolError('A loader client needs a GET Request');
+        if ('action' === operation && [
+            'GET',
+            'HEAD'
+        ].includes(request.method)) throw new external_codec_js_namespaceObject.DataProtocolError('An action client needs a mutation Request');
+        const url = new URL(request.url);
+        if ('loader' === operation) {
+            const replayed = await readStaticPayload(url, routeId, fetchData, request);
+            if (replayed) return readDataResponse(replayed, {
+                identity,
+                routeId,
+                operation
+            }, request.signal);
+        }
+        url.searchParams.set(external_types_js_namespaceObject.LOADER_ID_PARAM, routeId);
+        url.searchParams.set(external_types_js_namespaceObject.DIRECT_PARAM, 'true');
+        const proxyRequest = new Request(url, {
+            method: request.method,
+            headers: request.headers,
+            body: 'action' === operation ? await bufferRequestBody(request) : null,
+            signal: request.signal
+        });
+        const response = await (0, external_abort_js_namespaceObject.untilAborted)(fetchData(proxyRequest, {
+            credentials: 'same-origin',
+            redirect: 'manual',
+            signal: request.signal
+        }), request.signal);
+        return readDataResponse(response, {
+            identity,
+            routeId,
+            operation
+        }, request.signal);
+    };
+    return {
+        loader: (input)=>execute('loader', input),
+        action: (input)=>execute('action', input)
+    };
+}
+exports.createDataClient = __webpack_exports__.createDataClient;
+exports.readDataResponse = __webpack_exports__.readDataResponse;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createDataClient",
+    "readDataResponse"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});