@bleedingdev/modern-js-bff-effect 3.8.3-ultramodern.2

package/dist/cjs/data-platform/batch/request.js

@@ -0,0 +1,121 @@
+"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__, {
+    createBatchId: ()=>createBatchId,
+    measureTextBytes: ()=>measureTextBytes,
+    normalizeMethod: ()=>normalizeMethod,
+    shouldBatchRequest: ()=>shouldBatchRequest,
+    toHeaderRecord: ()=>toHeaderRecord,
+    toRequestBody: ()=>toRequestBody
+});
+const external_types_js_namespaceObject = require("../types.js");
+const external_protocol_js_namespaceObject = require("./protocol.js");
+function toHeaderRecord(headers) {
+    if (!headers) return {};
+    if (headers instanceof Headers) {
+        const next = {};
+        headers.forEach((value, key)=>{
+            next[key.toLowerCase()] = value;
+        });
+        return next;
+    }
+    if (Array.isArray(headers)) return headers.reduce((acc, [key, value])=>{
+        acc[String(key).toLowerCase()] = String(value);
+        return acc;
+    }, {});
+    return Object.entries(headers).reduce((acc, [key, value])=>{
+        if (void 0 === value) return acc;
+        acc[String(key).toLowerCase()] = Array.isArray(value) ? value.join(', ') : String(value);
+        return acc;
+    }, {});
+}
+function measureTextBytes(value) {
+    if ("u" > typeof TextEncoder) return new TextEncoder().encode(value).length;
+    if ("u" > typeof Buffer) return Buffer.byteLength(value);
+    return value.length;
+}
+function createBatchId() {
+    const now = Date.now().toString(36);
+    const random = Math.random().toString(16).slice(2, 10);
+    return `batch_${now}_${random}`;
+}
+function normalizeMethod(method) {
+    return (method || 'GET').toUpperCase();
+}
+async function toRequestBody(initBody) {
+    if (null == initBody) return {
+        body: void 0,
+        inferredContentType: void 0,
+        batchable: true
+    };
+    if ("u" > typeof ReadableStream && initBody instanceof ReadableStream) return {
+        body: void 0,
+        inferredContentType: void 0,
+        batchable: false
+    };
+    try {
+        const response = new Response(initBody);
+        return {
+            body: (0, external_protocol_js_namespaceObject.encodeBatchBody)(new Uint8Array(await response.arrayBuffer())),
+            inferredContentType: response.headers.get('content-type') || void 0,
+            batchable: true
+        };
+    } catch  {
+        return {
+            body: void 0,
+            inferredContentType: void 0,
+            batchable: false
+        };
+    }
+}
+function shouldBatchRequest(input) {
+    if (input.requestUrl.href === input.batchEndpoint) return false;
+    if ('off' === input.headers[external_types_js_namespaceObject.DEFAULT_DATA_BATCH_HEADER]) return false;
+    if (!input.allowedMethods.has(input.method)) return false;
+    if (void 0 !== input.body) return false;
+    return true;
+}
+exports.createBatchId = __webpack_exports__.createBatchId;
+exports.measureTextBytes = __webpack_exports__.measureTextBytes;
+exports.normalizeMethod = __webpack_exports__.normalizeMethod;
+exports.shouldBatchRequest = __webpack_exports__.shouldBatchRequest;
+exports.toHeaderRecord = __webpack_exports__.toHeaderRecord;
+exports.toRequestBody = __webpack_exports__.toRequestBody;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createBatchId",
+    "measureTextBytes",
+    "normalizeMethod",
+    "shouldBatchRequest",
+    "toHeaderRecord",
+    "toRequestBody"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/data-platform/batch/response.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__);
+__webpack_require__.d(__webpack_exports__, {
+    isBatchResponsePayload: ()=>isBatchResponsePayload,
+    parseResponseLikeCreateRequest: ()=>parseResponseLikeCreateRequest
+});
+const external_codec_js_namespaceObject = require("../codec.js");
+const external_protocol_js_namespaceObject = require("./protocol.js");
+function isBatchResponseItem(value) {
+    return (0, external_codec_js_namespaceObject.isPlainObject)(value) && 'string' == typeof value.id && 'number' == typeof value.status && (void 0 === value.headers || (0, external_protocol_js_namespaceObject.isBatchHeaderList)(value.headers)) && (void 0 === value.body || (0, external_protocol_js_namespaceObject.isBatchBody)(value.body)) && !((0, external_protocol_js_namespaceObject.isNullBodyStatus)(value.status) && void 0 !== value.body);
+}
+function isBatchResponsePayload(value) {
+    return (0, external_codec_js_namespaceObject.isPlainObject)(value) && 2 === value.protocolVersion && 'string' == typeof value.batchId && 'number' == typeof value.receivedAt && Array.isArray(value.items) && value.items.every((item)=>isBatchResponseItem(item));
+}
+async function parseResponseLikeCreateRequest(response) {
+    const contentType = (response.headers.get('content-type') || '').toLowerCase();
+    if (!response.ok) {
+        let data = null;
+        data = contentType.includes('application/json') ? await response.json() : await response.text();
+        response.data = data;
+        throw response;
+    }
+    if (contentType.includes('application/json') || contentType.includes('text/json')) return response.json();
+    if (contentType.includes('text/html') || contentType.includes('text/plain')) return response.text();
+    if (contentType.includes('application/x-www-form-urlencoded') || contentType.includes('multipart/form-data')) return response.formData();
+    if (contentType.includes('application/octet-stream')) return response.arrayBuffer();
+    if (contentType.includes('image/png')) return response;
+    return response.text();
+}
+exports.isBatchResponsePayload = __webpack_exports__.isBatchResponsePayload;
+exports.parseResponseLikeCreateRequest = __webpack_exports__.parseResponseLikeCreateRequest;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "isBatchResponsePayload",
+    "parseResponseLikeCreateRequest"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/data-platform/batch/telemetry.js

@@ -0,0 +1,71 @@
+"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__, {
+    DATA_BATCH_TRANSPORT_OTEL_EVENT: ()=>DATA_BATCH_TRANSPORT_OTEL_EVENT,
+    createDataBatchTransportTelemetryAttributes: ()=>createDataBatchTransportTelemetryAttributes,
+    emitDataBatchTransportEvent: ()=>emitDataBatchTransportEvent
+});
+const api_namespaceObject = require("@opentelemetry/api");
+const DATA_BATCH_TRANSPORT_OTEL_EVENT = 'modernjs.data.batch';
+function createDataBatchTransportTelemetryAttributes(event) {
+    return {
+        'modernjs.data.batch.type': event.type,
+        'modernjs.data.batch.endpoint': event.endpoint,
+        'modernjs.data.batch.degraded': 'fallback' === event.type || 'disable' === event.type,
+        ...event.batchId ? {
+            'modernjs.data.batch.id': event.batchId
+        } : {},
+        ...'number' == typeof event.size ? {
+            'modernjs.data.batch.size': event.size
+        } : {},
+        ...event.reason ? {
+            'modernjs.data.batch.reason': event.reason
+        } : {}
+    };
+}
+function emitDataBatchTransportEvent(onEvent, event) {
+    try {
+        onEvent?.(event);
+    } catch  {}
+    try {
+        api_namespaceObject.trace.getActiveSpan()?.addEvent(DATA_BATCH_TRANSPORT_OTEL_EVENT, createDataBatchTransportTelemetryAttributes(event));
+    } catch  {}
+}
+exports.DATA_BATCH_TRANSPORT_OTEL_EVENT = __webpack_exports__.DATA_BATCH_TRANSPORT_OTEL_EVENT;
+exports.createDataBatchTransportTelemetryAttributes = __webpack_exports__.createDataBatchTransportTelemetryAttributes;
+exports.emitDataBatchTransportEvent = __webpack_exports__.emitDataBatchTransportEvent;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DATA_BATCH_TRANSPORT_OTEL_EVENT",
+    "createDataBatchTransportTelemetryAttributes",
+    "emitDataBatchTransportEvent"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/data-platform/batch/url.js

@@ -0,0 +1,69 @@
+"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__, {
+    normalizeBatchEndpoint: ()=>normalizeBatchEndpoint,
+    resolveRuntimeOrigin: ()=>resolveRuntimeOrigin,
+    toAbsoluteUrl: ()=>toAbsoluteUrl
+});
+const external_types_js_namespaceObject = require("../types.js");
+function resolveRuntimeOrigin() {
+    if ("u" > typeof window && window.location && 'string' == typeof window.location.origin && window.location.origin) return window.location.origin;
+    if ("u" > typeof globalThis && globalThis.location && 'string' == typeof globalThis.location?.origin) return globalThis.location.origin;
+    return 'http://localhost';
+}
+function toAbsoluteUrl(input) {
+    if (input instanceof URL) return input;
+    if ("u" > typeof Request && input instanceof Request) return new URL(input.url);
+    const value = String(input);
+    try {
+        return new URL(value);
+    } catch  {
+        return new URL(value, resolveRuntimeOrigin());
+    }
+}
+function normalizeBatchEndpoint(requestUrl, endpoint) {
+    const value = endpoint || external_types_js_namespaceObject.DEFAULT_DATA_BATCH_ENDPOINT;
+    try {
+        return new URL(value);
+    } catch  {
+        return new URL(value, requestUrl.origin);
+    }
+}
+exports.normalizeBatchEndpoint = __webpack_exports__.normalizeBatchEndpoint;
+exports.resolveRuntimeOrigin = __webpack_exports__.resolveRuntimeOrigin;
+exports.toAbsoluteUrl = __webpack_exports__.toAbsoluteUrl;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "normalizeBatchEndpoint",
+    "resolveRuntimeOrigin",
+    "toAbsoluteUrl"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/data-platform/batch-transport.js

@@ -0,0 +1,59 @@
+"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__, {
+    DATA_BATCH_TRANSPORT_OTEL_EVENT: ()=>telemetry_js_namespaceObject.DATA_BATCH_TRANSPORT_OTEL_EVENT,
+    createDataBatchTransport: ()=>createDataBatchTransport,
+    createDataBatchTransportTelemetryAttributes: ()=>telemetry_js_namespaceObject.createDataBatchTransportTelemetryAttributes,
+    emitDataBatchTransportEvent: ()=>telemetry_js_namespaceObject.emitDataBatchTransportEvent
+});
+const queue_js_namespaceObject = require("./batch/queue.js");
+const telemetry_js_namespaceObject = require("./batch/telemetry.js");
+function createDataBatchTransport(options = {}) {
+    const fallbackFetch = 'function' == typeof fetch ? fetch.bind(globalThis) : void 0;
+    const baseFetch = options.fetch || fallbackFetch;
+    if (!baseFetch) throw new Error('createDataBatchTransport requires a fetch implementation');
+    return (0, queue_js_namespaceObject.createBatchTransportQueue)({
+        options,
+        baseFetch
+    });
+}
+exports.DATA_BATCH_TRANSPORT_OTEL_EVENT = __webpack_exports__.DATA_BATCH_TRANSPORT_OTEL_EVENT;
+exports.createDataBatchTransport = __webpack_exports__.createDataBatchTransport;
+exports.createDataBatchTransportTelemetryAttributes = __webpack_exports__.createDataBatchTransportTelemetryAttributes;
+exports.emitDataBatchTransportEvent = __webpack_exports__.emitDataBatchTransportEvent;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DATA_BATCH_TRANSPORT_OTEL_EVENT",
+    "createDataBatchTransport",
+    "createDataBatchTransportTelemetryAttributes",
+    "emitDataBatchTransportEvent"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/data-platform/codec.js

@@ -0,0 +1,155 @@
+"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 isPlainObject(value) {
+    if ('object' != typeof value || null === value || Array.isArray(value)) return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || null === proto;
+}
+function canonicalize(value) {
+    if (Array.isArray(value)) return value.map((item)=>canonicalize(item));
+    if (isPlainObject(value)) return Object.keys(value).sort().reduce((acc, key)=>{
+        acc[key] = canonicalize(value[key]);
+        return acc;
+    }, {});
+    return value;
+}
+function stableStringify(value) {
+    return JSON.stringify(canonicalize(value));
+}
+function encodeRequestEnvelopeHeader(envelope) {
+    return encodeURIComponent(stableStringify(envelope));
+}
+function isRequestEnvelopeShape(value) {
+    if (!isPlainObject(value)) return false;
+    return 1 === value.protocolVersion && 'string' == typeof value.operationId && 'string' == typeof value.appNamespace && 'string' == typeof value.origin && 'string' == typeof value.scopeKey && 'string' == typeof value.inputHash && 'number' == typeof value.timestamp;
+}
+function decodeRequestEnvelopeHeader(value) {
+    try {
+        const decoded = decodeURIComponent(value);
+        const parsed = JSON.parse(decoded);
+        if (!isRequestEnvelopeShape(parsed)) return null;
+        return parsed;
+    } catch  {
+        return null;
+    }
+}
+function hashString(value) {
+    let hash = 0x811c9dc5;
+    for(let index = 0; index < value.length; index++){
+        hash ^= value.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return (hash >>> 0).toString(16).padStart(8, '0');
+}
+function sanitizeSegment(segment) {
+    const normalized = segment.trim().replace(/[^a-zA-Z0-9_-]+/g, '_');
+    return normalized.length > 0 ? normalized : 'unknown';
+}
+function normalizeOrigin(origin) {
+    const normalized = origin.trim();
+    try {
+        const url = new URL(normalized);
+        return `${url.protocol}//${url.host}`.toLowerCase();
+    } catch  {
+        return normalized.toLowerCase();
+    }
+}
+function normalizeOperationDescriptor(input) {
+    return {
+        appNamespace: sanitizeSegment(input.appNamespace),
+        apiId: sanitizeSegment(input.apiId),
+        group: sanitizeSegment(input.group),
+        endpoint: sanitizeSegment(input.endpoint),
+        schemaHash: input.schemaHash || null,
+        version: input.version ?? 1
+    };
+}
+function createOperationId(input) {
+    const descriptor = normalizeOperationDescriptor(input);
+    const readable = `${descriptor.appNamespace}.${descriptor.apiId}.${descriptor.group}.${descriptor.endpoint}.v${String(descriptor.version)}`;
+    return `${readable}:${hashString(stableStringify(descriptor))}`;
+}
+function buildScopeKey(scope) {
+    const canonical = {
+        appNamespace: sanitizeSegment(scope.appNamespace),
+        origin: normalizeOrigin(scope.origin),
+        tenantId: scope.tenantId ?? null,
+        userId: scope.userId ?? null,
+        sessionId: scope.sessionId ?? null
+    };
+    return `${canonical.appNamespace}:${hashString(stableStringify(canonical))}`;
+}
+function buildQueryKey(input) {
+    const canonical = {
+        operationId: input.operationId,
+        scopeKey: input.scopeKey,
+        requestMode: input.requestMode ?? 'cache-first',
+        requestInput: input.requestInput ?? null,
+        selectionPlan: input.selectionPlan ?? null
+    };
+    return `${input.operationId}:${hashString(stableStringify(canonical))}`;
+}
+__webpack_require__.d(__webpack_exports__, {
+    buildQueryKey: ()=>buildQueryKey,
+    buildScopeKey: ()=>buildScopeKey,
+    createOperationId: ()=>createOperationId,
+    decodeRequestEnvelopeHeader: ()=>decodeRequestEnvelopeHeader,
+    encodeRequestEnvelopeHeader: ()=>encodeRequestEnvelopeHeader,
+    hashString: ()=>hashString,
+    isPlainObject: ()=>isPlainObject,
+    normalizeOrigin: ()=>normalizeOrigin,
+    sanitizeSegment: ()=>sanitizeSegment,
+    stableStringify: ()=>stableStringify
+});
+exports.buildQueryKey = __webpack_exports__.buildQueryKey;
+exports.buildScopeKey = __webpack_exports__.buildScopeKey;
+exports.createOperationId = __webpack_exports__.createOperationId;
+exports.decodeRequestEnvelopeHeader = __webpack_exports__.decodeRequestEnvelopeHeader;
+exports.encodeRequestEnvelopeHeader = __webpack_exports__.encodeRequestEnvelopeHeader;
+exports.hashString = __webpack_exports__.hashString;
+exports.isPlainObject = __webpack_exports__.isPlainObject;
+exports.normalizeOrigin = __webpack_exports__.normalizeOrigin;
+exports.sanitizeSegment = __webpack_exports__.sanitizeSegment;
+exports.stableStringify = __webpack_exports__.stableStringify;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "buildQueryKey",
+    "buildScopeKey",
+    "createOperationId",
+    "decodeRequestEnvelopeHeader",
+    "encodeRequestEnvelopeHeader",
+    "hashString",
+    "isPlainObject",
+    "normalizeOrigin",
+    "sanitizeSegment",
+    "stableStringify"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/data-platform/index.js

@@ -0,0 +1,124 @@
+"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__, {
+    DATA_BATCH_TRANSPORT_OTEL_EVENT: ()=>external_batch_transport_js_namespaceObject.DATA_BATCH_TRANSPORT_OTEL_EVENT,
+    DEFAULT_DATA_BATCH_ENDPOINT: ()=>external_types_js_namespaceObject.DEFAULT_DATA_BATCH_ENDPOINT,
+    DEFAULT_DATA_BATCH_HEADER: ()=>external_types_js_namespaceObject.DEFAULT_DATA_BATCH_HEADER,
+    DEFAULT_DATA_ENVELOPE_HEADER: ()=>external_types_js_namespaceObject.DEFAULT_DATA_ENVELOPE_HEADER,
+    buildQueryKey: ()=>external_codec_js_namespaceObject.buildQueryKey,
+    buildScopeKey: ()=>external_codec_js_namespaceObject.buildScopeKey,
+    createDataBatchTransport: ()=>external_batch_transport_js_namespaceObject.createDataBatchTransport,
+    createDataBatchTransportTelemetryAttributes: ()=>external_batch_transport_js_namespaceObject.createDataBatchTransportTelemetryAttributes,
+    createHydrationEnvelope: ()=>external_validation_js_namespaceObject.createHydrationEnvelope,
+    createInvalidationEvent: ()=>external_invalidation_js_namespaceObject.createInvalidationEvent,
+    createOperationId: ()=>external_codec_js_namespaceObject.createOperationId,
+    createRequestEnvelope: ()=>external_validation_js_namespaceObject.createRequestEnvelope,
+    decodeRequestEnvelopeHeader: ()=>external_codec_js_namespaceObject.decodeRequestEnvelopeHeader,
+    deriveChildTraceContext: ()=>external_trace_js_namespaceObject.deriveChildTraceContext,
+    emitDataBatchTransportEvent: ()=>external_batch_transport_js_namespaceObject.emitDataBatchTransportEvent,
+    encodeRequestEnvelopeHeader: ()=>external_codec_js_namespaceObject.encodeRequestEnvelopeHeader,
+    formatTraceparentHeader: ()=>external_trace_js_namespaceObject.formatTraceparentHeader,
+    isPlainObject: ()=>external_codec_js_namespaceObject.isPlainObject,
+    measureTextBytes: ()=>request_js_namespaceObject.measureTextBytes,
+    normalizeMethod: ()=>request_js_namespaceObject.normalizeMethod,
+    normalizeOrigin: ()=>external_codec_js_namespaceObject.normalizeOrigin,
+    parseTraceparentHeader: ()=>external_trace_js_namespaceObject.parseTraceparentHeader,
+    shouldApplyInvalidation: ()=>external_invalidation_js_namespaceObject.shouldApplyInvalidation,
+    stableStringify: ()=>external_codec_js_namespaceObject.stableStringify,
+    validateHydrationEnvelope: ()=>external_validation_js_namespaceObject.validateHydrationEnvelope,
+    validateRequestEnvelope: ()=>external_validation_js_namespaceObject.validateRequestEnvelope,
+    validateSelectionPlan: ()=>external_validation_js_namespaceObject.validateSelectionPlan
+});
+const request_js_namespaceObject = require("./batch/request.js");
+const external_batch_transport_js_namespaceObject = require("./batch-transport.js");
+const external_codec_js_namespaceObject = require("./codec.js");
+const external_invalidation_js_namespaceObject = require("./invalidation.js");
+const external_trace_js_namespaceObject = require("./trace.js");
+const external_types_js_namespaceObject = require("./types.js");
+const external_validation_js_namespaceObject = require("./validation.js");
+exports.DATA_BATCH_TRANSPORT_OTEL_EVENT = __webpack_exports__.DATA_BATCH_TRANSPORT_OTEL_EVENT;
+exports.DEFAULT_DATA_BATCH_ENDPOINT = __webpack_exports__.DEFAULT_DATA_BATCH_ENDPOINT;
+exports.DEFAULT_DATA_BATCH_HEADER = __webpack_exports__.DEFAULT_DATA_BATCH_HEADER;
+exports.DEFAULT_DATA_ENVELOPE_HEADER = __webpack_exports__.DEFAULT_DATA_ENVELOPE_HEADER;
+exports.buildQueryKey = __webpack_exports__.buildQueryKey;
+exports.buildScopeKey = __webpack_exports__.buildScopeKey;
+exports.createDataBatchTransport = __webpack_exports__.createDataBatchTransport;
+exports.createDataBatchTransportTelemetryAttributes = __webpack_exports__.createDataBatchTransportTelemetryAttributes;
+exports.createHydrationEnvelope = __webpack_exports__.createHydrationEnvelope;
+exports.createInvalidationEvent = __webpack_exports__.createInvalidationEvent;
+exports.createOperationId = __webpack_exports__.createOperationId;
+exports.createRequestEnvelope = __webpack_exports__.createRequestEnvelope;
+exports.decodeRequestEnvelopeHeader = __webpack_exports__.decodeRequestEnvelopeHeader;
+exports.deriveChildTraceContext = __webpack_exports__.deriveChildTraceContext;
+exports.emitDataBatchTransportEvent = __webpack_exports__.emitDataBatchTransportEvent;
+exports.encodeRequestEnvelopeHeader = __webpack_exports__.encodeRequestEnvelopeHeader;
+exports.formatTraceparentHeader = __webpack_exports__.formatTraceparentHeader;
+exports.isPlainObject = __webpack_exports__.isPlainObject;
+exports.measureTextBytes = __webpack_exports__.measureTextBytes;
+exports.normalizeMethod = __webpack_exports__.normalizeMethod;
+exports.normalizeOrigin = __webpack_exports__.normalizeOrigin;
+exports.parseTraceparentHeader = __webpack_exports__.parseTraceparentHeader;
+exports.shouldApplyInvalidation = __webpack_exports__.shouldApplyInvalidation;
+exports.stableStringify = __webpack_exports__.stableStringify;
+exports.validateHydrationEnvelope = __webpack_exports__.validateHydrationEnvelope;
+exports.validateRequestEnvelope = __webpack_exports__.validateRequestEnvelope;
+exports.validateSelectionPlan = __webpack_exports__.validateSelectionPlan;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DATA_BATCH_TRANSPORT_OTEL_EVENT",
+    "DEFAULT_DATA_BATCH_ENDPOINT",
+    "DEFAULT_DATA_BATCH_HEADER",
+    "DEFAULT_DATA_ENVELOPE_HEADER",
+    "buildQueryKey",
+    "buildScopeKey",
+    "createDataBatchTransport",
+    "createDataBatchTransportTelemetryAttributes",
+    "createHydrationEnvelope",
+    "createInvalidationEvent",
+    "createOperationId",
+    "createRequestEnvelope",
+    "decodeRequestEnvelopeHeader",
+    "deriveChildTraceContext",
+    "emitDataBatchTransportEvent",
+    "encodeRequestEnvelopeHeader",
+    "formatTraceparentHeader",
+    "isPlainObject",
+    "measureTextBytes",
+    "normalizeMethod",
+    "normalizeOrigin",
+    "parseTraceparentHeader",
+    "shouldApplyInvalidation",
+    "stableStringify",
+    "validateHydrationEnvelope",
+    "validateRequestEnvelope",
+    "validateSelectionPlan"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});