@bleedingdev/modern-js-plugin-bff 3.5.0-ultramodern.30 → 3.5.0-ultramodern.31

package/dist/cjs/runtime/effect/handler/batch.js

@@ -0,0 +1,195 @@
+"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__, {
+    createBatchValidationResponse: ()=>createBatchValidationResponse,
+    isBatchRequestPayload: ()=>isBatchRequestPayload,
+    isPlainObject: ()=>isPlainObject,
+    mapWithConcurrency: ()=>mapWithConcurrency,
+    normalizeBatchAllowedMethods: ()=>normalizeBatchAllowedMethods,
+    normalizeBatchPath: ()=>normalizeBatchPath,
+    normalizeItemMethod: ()=>normalizeItemMethod,
+    prepareJsonRequestBody: ()=>prepareJsonRequestBody,
+    promiseWithTimeout: ()=>promiseWithTimeout,
+    toBatchItemError: ()=>toBatchItemError,
+    toHeaderRecord: ()=>toHeaderRecord,
+    toTextLength: ()=>toTextLength
+});
+const index_js_namespaceObject = require("../../data-platform/index.js");
+function normalizeBatchPath(pathname) {
+    if (!pathname || '/' === pathname) return index_js_namespaceObject.DEFAULT_DATA_BATCH_ENDPOINT;
+    if (!pathname.startsWith('/')) return `/${pathname}`;
+    return pathname;
+}
+function isPlainObject(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+function toTextLength(value) {
+    if ("u" > typeof TextEncoder) return new TextEncoder().encode(value).length;
+    if ("u" > typeof Buffer) return Buffer.byteLength(value);
+    return value.length;
+}
+function toHeaderRecord(headers) {
+    const record = {};
+    headers.forEach((value, key)=>{
+        record[key] = value;
+    });
+    return record;
+}
+function normalizeItemMethod(method) {
+    return (method || 'GET').toUpperCase();
+}
+function normalizeBatchAllowedMethods(allowedMethods) {
+    const source = Array.isArray(allowedMethods) && allowedMethods.length > 0 ? allowedMethods : [
+        'GET'
+    ];
+    return new Set(source.map((method)=>method.toUpperCase()));
+}
+function isBatchRequestPayload(value) {
+    return isPlainObject(value) && 1 === value.protocolVersion && 'string' == typeof value.batchId && 'number' == typeof value.sentAt && Array.isArray(value.items);
+}
+function createBatchValidationResponse(message, status = 400) {
+    return new Response(JSON.stringify({
+        message
+    }), {
+        status,
+        headers: {
+            'content-type': 'application/json; charset=utf-8'
+        }
+    });
+}
+function createJsonValidationResponse(message, status = 400) {
+    return new Response(JSON.stringify({
+        message
+    }), {
+        status,
+        headers: {
+            'content-type': 'application/json; charset=utf-8'
+        }
+    });
+}
+function cloneWithoutJsonBodyHeaders(request) {
+    const headers = new Headers(request.headers);
+    headers.delete('content-type');
+    headers.delete('content-length');
+    return new Request(request.url, {
+        method: request.method,
+        headers,
+        signal: request.signal
+    });
+}
+async function prepareJsonRequestBody(request) {
+    const method = normalizeItemMethod(request.method);
+    if ('GET' === method || 'HEAD' === method) return request;
+    const contentType = (request.headers.get('content-type') || '').toLowerCase();
+    if (!contentType.includes('application/json')) return request;
+    if (null === request.body) return cloneWithoutJsonBodyHeaders(request);
+    try {
+        const bodyText = await request.clone().text();
+        if ('' === bodyText) return cloneWithoutJsonBodyHeaders(request);
+        JSON.parse(bodyText);
+    } catch  {
+        return createJsonValidationResponse('Invalid JSON request body');
+    }
+    return request;
+}
+function toBatchItemError(id, status, message) {
+    return {
+        id,
+        status,
+        headers: {
+            'content-type': 'application/json; charset=utf-8'
+        },
+        body: JSON.stringify({
+            message
+        })
+    };
+}
+function promiseWithTimeout(effect, timeoutMs) {
+    if (timeoutMs <= 0) return effect;
+    return new Promise((resolve, reject)=>{
+        const timer = setTimeout(()=>{
+            reject(new Error(`Batch item timeout after ${String(timeoutMs)}ms`));
+        }, timeoutMs);
+        effect.then((value)=>{
+            clearTimeout(timer);
+            resolve(value);
+        }, (error)=>{
+            clearTimeout(timer);
+            reject(error);
+        });
+    });
+}
+async function mapWithConcurrency(items, concurrency, mapper) {
+    if (0 === items.length) return [];
+    const normalizedConcurrency = Math.max(1, concurrency);
+    const output = new Array(items.length);
+    let index = 0;
+    const workers = Array.from({
+        length: Math.min(normalizedConcurrency, items.length)
+    }, async ()=>{
+        while(true){
+            const currentIndex = index;
+            index += 1;
+            if (currentIndex >= items.length) return;
+            output[currentIndex] = await mapper(items[currentIndex], currentIndex);
+        }
+    });
+    await Promise.all(workers);
+    return output;
+}
+exports.createBatchValidationResponse = __webpack_exports__.createBatchValidationResponse;
+exports.isBatchRequestPayload = __webpack_exports__.isBatchRequestPayload;
+exports.isPlainObject = __webpack_exports__.isPlainObject;
+exports.mapWithConcurrency = __webpack_exports__.mapWithConcurrency;
+exports.normalizeBatchAllowedMethods = __webpack_exports__.normalizeBatchAllowedMethods;
+exports.normalizeBatchPath = __webpack_exports__.normalizeBatchPath;
+exports.normalizeItemMethod = __webpack_exports__.normalizeItemMethod;
+exports.prepareJsonRequestBody = __webpack_exports__.prepareJsonRequestBody;
+exports.promiseWithTimeout = __webpack_exports__.promiseWithTimeout;
+exports.toBatchItemError = __webpack_exports__.toBatchItemError;
+exports.toHeaderRecord = __webpack_exports__.toHeaderRecord;
+exports.toTextLength = __webpack_exports__.toTextLength;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createBatchValidationResponse",
+    "isBatchRequestPayload",
+    "isPlainObject",
+    "mapWithConcurrency",
+    "normalizeBatchAllowedMethods",
+    "normalizeBatchPath",
+    "normalizeItemMethod",
+    "prepareJsonRequestBody",
+    "promiseWithTimeout",
+    "toBatchItemError",
+    "toHeaderRecord",
+    "toTextLength"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/effect/handler/definition.js

@@ -0,0 +1,101 @@
+"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__, {
+    defineEffectBff: ()=>defineEffectBff,
+    defineEffectRpcBff: ()=>defineEffectRpcBff
+});
+const external_entry_shape_js_namespaceObject = require("../entry-shape.js");
+const external_envelope_js_namespaceObject = require("./envelope.js");
+const external_http_js_namespaceObject = require("./http.js");
+const external_rpc_js_namespaceObject = require("./rpc.js");
+function defineEffectBff(definition) {
+    const createHandler = (options)=>{
+        const rpcDefinition = definition.rpc;
+        let mergedRpcOptions = rpcDefinition;
+        if (rpcDefinition && options?.rpc) mergedRpcOptions = {
+            ...rpcDefinition,
+            ...options.rpc
+        };
+        return (0, external_http_js_namespaceObject.createHttpApiHandler)({
+            api: definition.api,
+            layer: definition.layer,
+            openapi: options?.openapi,
+            rpc: mergedRpcOptions,
+            dataPlatform: (0, external_envelope_js_namespaceObject.mergeDataPlatformOptions)(definition.dataPlatform, options?.dataPlatform),
+            validateRequest: options?.validateRequest
+        });
+    };
+    Object.defineProperty(createHandler, external_entry_shape_js_namespaceObject.EFFECT_VALIDATOR_AWARE_FACTORY, {
+        value: true
+    });
+    const client = createLoaderMaterializedClientPlaceholder();
+    return {
+        ...definition,
+        createHandler,
+        client
+    };
+}
+const LOADER_CLIENT_IGNORED_KEYS = new Set([
+    'then',
+    'catch',
+    'finally',
+    'toJSON',
+    '$$typeof'
+]);
+function createLoaderMaterializedClientPlaceholder() {
+    const explain = (property)=>{
+        throw new Error(`[BFF][Effect] client.${String(property)} is not available here: the typed client only exists when the API entry is imported through the "@api/index" transformed path (the BFF loader replaces it with generated client code). On the server, use HttpApiClient or call the Effect layer directly.`);
+    };
+    return new Proxy(Object.create(null), {
+        get (_target, property) {
+            if ('symbol' == typeof property || LOADER_CLIENT_IGNORED_KEYS.has(property)) return;
+            return explain(property);
+        }
+    });
+}
+function defineEffectRpcBff(definition) {
+    const createHandler = (options)=>(0, external_rpc_js_namespaceObject.createRpcApiHandler)({
+            ...definition,
+            ...options
+        });
+    return {
+        ...definition,
+        createHandler
+    };
+}
+exports.defineEffectBff = __webpack_exports__.defineEffectBff;
+exports.defineEffectRpcBff = __webpack_exports__.defineEffectRpcBff;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "defineEffectBff",
+    "defineEffectRpcBff"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/effect/handler/envelope.js

@@ -0,0 +1,104 @@
+"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__, {
+    mergeDataPlatformOptions: ()=>mergeDataPlatformOptions,
+    validateDataPlatformRequestEnvelope: ()=>validateDataPlatformRequestEnvelope
+});
+const index_js_namespaceObject = require("../../data-platform/index.js");
+const external_routing_js_namespaceObject = require("./routing.js");
+function createInvalidEnvelopeResponse(message, errors) {
+    return new Response(JSON.stringify({
+        message,
+        ...errors && errors.length > 0 ? {
+            errors
+        } : {}
+    }), {
+        status: 400,
+        headers: {
+            'content-type': 'application/json; charset=utf-8'
+        }
+    });
+}
+function validateDataPlatformRequestEnvelope(request, options) {
+    const isEnabled = options?.enabled ?? true;
+    if (!isEnabled) return null;
+    const envelopeHeader = options?.envelopeHeader || index_js_namespaceObject.DEFAULT_DATA_ENVELOPE_HEADER;
+    const encodedEnvelope = request.headers.get(envelopeHeader);
+    if (!encodedEnvelope) {
+        if (options?.requireEnvelope) return createInvalidEnvelopeResponse(`Missing required data envelope header: ${envelopeHeader}`);
+        return null;
+    }
+    const envelope = (0, index_js_namespaceObject.decodeRequestEnvelopeHeader)(encodedEnvelope);
+    if (!envelope) return createInvalidEnvelopeResponse(`Invalid data envelope header format: ${envelopeHeader}`);
+    const validation = (0, index_js_namespaceObject.validateRequestEnvelope)(envelope, {
+        expectedProtocolVersion: 1,
+        expectedNamespace: options?.expectedNamespace,
+        expectedOrigin: options?.validateOrigin === false ? void 0 : (0, external_routing_js_namespaceObject.getExpectedEnvelopeOrigin)(request),
+        requireTraceContext: options?.requireTraceContext
+    });
+    if (!validation.ok) return createInvalidEnvelopeResponse('Invalid data envelope', validation.errors);
+    if (envelope.selectionPlan) {
+        const selectionValidation = (0, index_js_namespaceObject.validateSelectionPlan)(envelope.selectionPlan, {
+            maxDepth: options?.selection?.maxDepth,
+            maxFields: options?.selection?.maxFields,
+            allowedLeafPaths: options?.selection?.allowedLeafPaths
+        });
+        if (!selectionValidation.ok) return createInvalidEnvelopeResponse('Invalid data envelope selection plan', selectionValidation.errors);
+    }
+    return null;
+}
+function mergeDataPlatformOptions(base, override) {
+    if (!base && !override) return;
+    const baseSelection = base?.selection;
+    const overrideSelection = override?.selection;
+    const baseBatch = base?.batch;
+    const overrideBatch = override?.batch;
+    return {
+        ...base,
+        ...override,
+        selection: baseSelection || overrideSelection ? {
+            ...baseSelection,
+            ...overrideSelection
+        } : void 0,
+        batch: baseBatch || overrideBatch ? {
+            ...baseBatch,
+            ...overrideBatch
+        } : void 0
+    };
+}
+exports.mergeDataPlatformOptions = __webpack_exports__.mergeDataPlatformOptions;
+exports.validateDataPlatformRequestEnvelope = __webpack_exports__.validateDataPlatformRequestEnvelope;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "mergeDataPlatformOptions",
+    "validateDataPlatformRequestEnvelope"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/effect/handler/http.js

@@ -0,0 +1,96 @@
+"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__, {
+    createHttpApiHandler: ()=>createHttpApiHandler
+});
+const Layer_namespaceObject = require("effect/Layer");
+const http_namespaceObject = require("effect/unstable/http");
+const external_batch_js_namespaceObject = require("./batch.js");
+const external_batch_handler_js_namespaceObject = require("./batch-handler.js");
+const external_envelope_js_namespaceObject = require("./envelope.js");
+const external_openapi_js_namespaceObject = require("./openapi.js");
+const external_routing_js_namespaceObject = require("./routing.js");
+const external_rpc_js_namespaceObject = require("./rpc.js");
+const external_types_js_namespaceObject = require("./types.js");
+function createHttpApiHandler(options) {
+    const apiLayer = options.layer.pipe(Layer_namespaceObject.provide(http_namespaceObject.HttpServer.layerServices));
+    const openApiLayer = (0, external_openapi_js_namespaceObject.createOpenApiLayer)(options.api, options.openapi);
+    const mergedLayer = openApiLayer ? Layer_namespaceObject.mergeAll(apiLayer, openApiLayer) : apiLayer;
+    const httpApiHandler = http_namespaceObject.HttpRouter.toWebHandler(mergedLayer);
+    const withDataPlatformValidation = async (request, context)=>{
+        const policyDenial = options.validateRequest?.(request);
+        if (policyDenial) return policyDenial;
+        const preparedRequest = await (0, external_batch_js_namespaceObject.prepareJsonRequestBody)(request);
+        if (preparedRequest instanceof Response) return preparedRequest;
+        const validationError = (0, external_envelope_js_namespaceObject.validateDataPlatformRequestEnvelope)(preparedRequest, options.dataPlatform);
+        if (validationError) return validationError;
+        return httpApiHandler.handler(preparedRequest, (0, external_types_js_namespaceObject.toEffectServiceContext)(context));
+    };
+    const batchHandler = (0, external_batch_handler_js_namespaceObject.createDataPlatformBatchRequestHandler)({
+        dataPlatform: options.dataPlatform,
+        handleItem: withDataPlatformValidation
+    });
+    const handleHttpApiRequest = async (request, context)=>{
+        const pathname = (0, external_routing_js_namespaceObject.getRequestPathname)(request);
+        if (batchHandler.enabled && pathname === batchHandler.path) return batchHandler.handle(request, context);
+        return withDataPlatformValidation(request, context);
+    };
+    if (!options.rpc) return {
+        handler: handleHttpApiRequest,
+        dispose: async ()=>{
+            await httpApiHandler.dispose();
+        }
+    };
+    const rpcPath = (0, external_rpc_js_namespaceObject.normalizeRpcPath)(options.rpc.path);
+    const rpcHandler = (0, external_rpc_js_namespaceObject.createRpcApiHandler)(options.rpc);
+    return {
+        handler: async (request, context)=>{
+            if ((0, external_routing_js_namespaceObject.isRpcRequest)(request, rpcPath)) {
+                const policyDenial = options.validateRequest?.(request);
+                if (policyDenial) return policyDenial;
+                return rpcHandler.handler(request, (0, external_types_js_namespaceObject.toEffectServiceContext)(context));
+            }
+            return handleHttpApiRequest(request);
+        },
+        dispose: async ()=>{
+            await Promise.all([
+                httpApiHandler.dispose(),
+                rpcHandler.dispose()
+            ]);
+        }
+    };
+}
+exports.createHttpApiHandler = __webpack_exports__.createHttpApiHandler;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createHttpApiHandler"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/effect/handler/openapi.js

@@ -0,0 +1,57 @@
+"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__, {
+    createOpenApiLayer: ()=>createOpenApiLayer
+});
+const http_namespaceObject = require("effect/unstable/http");
+const httpapi_namespaceObject = require("effect/unstable/httpapi");
+function normalizeOpenApiPath(pathname) {
+    if (!pathname.startsWith('/')) return `/${pathname}`;
+    return pathname;
+}
+function getOpenApiOptions(openapi) {
+    if (!openapi || 'object' != typeof openapi) return;
+    if (!openapi.path) return;
+    return {
+        path: normalizeOpenApiPath(openapi.path)
+    };
+}
+function createOpenApiLayer(api, openapi) {
+    const openApiOptions = getOpenApiOptions(openapi);
+    if (!openApiOptions) return null;
+    return http_namespaceObject.HttpRouter.add('GET', openApiOptions.path, http_namespaceObject.HttpServerResponse.jsonUnsafe(httpapi_namespaceObject.OpenApi.fromApi(api)));
+}
+exports.createOpenApiLayer = __webpack_exports__.createOpenApiLayer;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createOpenApiLayer"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/effect/handler/routing.js

@@ -0,0 +1,100 @@
+"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__, {
+    getExpectedEnvelopeOrigin: ()=>getExpectedEnvelopeOrigin,
+    getMountedPrefixFromContext: ()=>getMountedPrefixFromContext,
+    getRequestPathname: ()=>getRequestPathname,
+    isRpcRequest: ()=>isRpcRequest,
+    removeMountedPrefixFromBatchPath: ()=>removeMountedPrefixFromBatchPath
+});
+const external_batch_js_namespaceObject = require("./batch.js");
+function getRequestPathname(request) {
+    try {
+        return new URL(request.url).pathname;
+    } catch  {
+        return new URL(request.url, 'http://localhost').pathname;
+    }
+}
+function normalizeMountPrefix(prefix) {
+    if (!prefix || '/' === prefix) return '';
+    return prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
+}
+function getMountedPrefixFromContext(request, context) {
+    if (!(0, external_batch_js_namespaceObject.isPlainObject)(context) || 'string' != typeof context.path) return '';
+    const contextPath = normalizeMountPrefix(context.path);
+    const requestPath = normalizeMountPrefix(getRequestPathname(request));
+    if (!contextPath || !requestPath || contextPath === requestPath || !contextPath.endsWith(requestPath)) return '';
+    return normalizeMountPrefix(contextPath.slice(0, contextPath.length - requestPath.length));
+}
+function removeMountedPrefixFromBatchPath(pathWithQuery, prefix) {
+    const normalizedPrefix = normalizeMountPrefix(prefix);
+    if (!normalizedPrefix) return pathWithQuery;
+    const [pathname, ...queryParts] = pathWithQuery.split('?');
+    if (!pathname) return pathWithQuery;
+    let nextPathname = pathname;
+    if (pathname === normalizedPrefix) nextPathname = '/';
+    else if (pathname.startsWith(`${normalizedPrefix}/`)) {
+        const sliced = pathname.slice(normalizedPrefix.length);
+        nextPathname = sliced.startsWith('/') ? sliced : `/${sliced}`;
+    }
+    if (0 === queryParts.length) return nextPathname;
+    return `${nextPathname}?${queryParts.join('?')}`;
+}
+function getRequestOrigin(request) {
+    try {
+        return new URL(request.url).origin;
+    } catch  {
+        return new URL(request.url, 'http://localhost').origin;
+    }
+}
+function getExpectedEnvelopeOrigin(request) {
+    const origin = request.headers.get('origin');
+    if (origin && 'null' !== origin) return origin;
+    return getRequestOrigin(request);
+}
+function isRpcRequest(request, rpcPath) {
+    const pathname = getRequestPathname(request);
+    return pathname === rpcPath || pathname.startsWith(`${rpcPath}/`);
+}
+exports.getExpectedEnvelopeOrigin = __webpack_exports__.getExpectedEnvelopeOrigin;
+exports.getMountedPrefixFromContext = __webpack_exports__.getMountedPrefixFromContext;
+exports.getRequestPathname = __webpack_exports__.getRequestPathname;
+exports.isRpcRequest = __webpack_exports__.isRpcRequest;
+exports.removeMountedPrefixFromBatchPath = __webpack_exports__.removeMountedPrefixFromBatchPath;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getExpectedEnvelopeOrigin",
+    "getMountedPrefixFromContext",
+    "getRequestPathname",
+    "isRpcRequest",
+    "removeMountedPrefixFromBatchPath"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});