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

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

@@ -0,0 +1,623 @@
+"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__, {
+    BatchBucketRegistry: ()=>BatchBucketRegistry,
+    createBatchTransportQueue: ()=>createBatchTransportQueue
+});
+const external_codec_js_namespaceObject = require("../codec.js");
+const external_types_js_namespaceObject = require("../types.js");
+const external_protocol_js_namespaceObject = require("./protocol.js");
+const external_request_js_namespaceObject = require("./request.js");
+const external_response_js_namespaceObject = require("./response.js");
+const external_telemetry_js_namespaceObject = require("./telemetry.js");
+const external_url_js_namespaceObject = require("./url.js");
+const SAFE_REPLAY_METHODS = new Set([
+    'GET',
+    'HEAD'
+]);
+const abortReason = (signal)=>signal.reason ?? new DOMException('The request was aborted', 'AbortError');
+const createRequestLifetime = (sourceSignal, timeoutMs)=>{
+    const controller = new AbortController();
+    let timedOut = false;
+    let timeoutHandle = null;
+    const abortFromSource = ()=>{
+        if (sourceSignal) controller.abort(abortReason(sourceSignal));
+    };
+    if (sourceSignal?.aborted) abortFromSource();
+    else if (sourceSignal) sourceSignal.addEventListener('abort', abortFromSource, {
+        once: true
+    });
+    if (!controller.signal.aborted && timeoutMs && timeoutMs > 0) timeoutHandle = setTimeout(()=>{
+        timedOut = true;
+        controller.abort(new DOMException('The batched request timed out', 'TimeoutError'));
+    }, timeoutMs);
+    return {
+        signal: controller.signal,
+        get timedOut () {
+            return timedOut;
+        },
+        dispose () {
+            if (null !== timeoutHandle) {
+                clearTimeout(timeoutHandle);
+                timeoutHandle = null;
+            }
+            sourceSignal?.removeEventListener('abort', abortFromSource);
+        }
+    };
+};
+const runWithSignal = (signal, operation)=>{
+    if (signal.aborted) return Promise.reject(abortReason(signal));
+    return new Promise((resolve, reject)=>{
+        const onAbort = ()=>{
+            signal.removeEventListener('abort', onAbort);
+            reject(abortReason(signal));
+        };
+        signal.addEventListener('abort', onAbort, {
+            once: true
+        });
+        let pending;
+        try {
+            pending = operation();
+        } catch (error) {
+            signal.removeEventListener('abort', onAbort);
+            reject(error);
+            return;
+        }
+        pending.then((value)=>{
+            signal.removeEventListener('abort', onAbort);
+            resolve(value);
+        }, (error)=>{
+            signal.removeEventListener('abort', onAbort);
+            reject(error);
+        });
+    });
+};
+class BatchBucketRegistry {
+    get size() {
+        return this.buckets.size;
+    }
+    get(bucketKey) {
+        return this.buckets.get(bucketKey);
+    }
+    ensure(bucketKey) {
+        const existing = this.buckets.get(bucketKey);
+        if (existing) return existing;
+        const next = {
+            items: [],
+            bytes: 0,
+            batchId: (0, external_request_js_namespaceObject.createBatchId)(),
+            sentAt: Date.now(),
+            timer: null,
+            flushing: false
+        };
+        this.buckets.set(bucketKey, next);
+        return next;
+    }
+    releaseIfIdle(bucketKey, bucket) {
+        if (this.buckets.get(bucketKey) !== bucket || bucket.flushing || null !== bucket.timer || bucket.items.length > 0) return false;
+        return this.buckets.delete(bucketKey);
+    }
+    constructor(){
+        this.buckets = new Map();
+    }
+}
+function createBatchTransportQueue({ options, baseFetch, bucketRegistry }) {
+    const flushIntervalMs = Math.max(0, options.flushIntervalMs ?? 8);
+    const maxBatchSize = Math.max(1, options.maxBatchSize ?? 16);
+    const maxBatchBytes = Math.max(1024, options.maxBatchBytes ?? 65536);
+    const requestTimeoutMs = options.requestTimeoutMs;
+    const allowedMethods = new Set((options.allowedMethods && options.allowedMethods.length > 0 ? options.allowedMethods : [
+        'GET'
+    ]).map((method)=>method.toUpperCase()));
+    const onEvent = options.onEvent;
+    const buckets = bucketRegistry ?? new BatchBucketRegistry();
+    const pendingByKey = new Map();
+    const disabledEndpoints = new Set();
+    let nextItemId = 0;
+    const createPayload = (bucket, items)=>({
+            protocolVersion: 2,
+            batchId: bucket.batchId,
+            sentAt: bucket.sentAt,
+            items: items.map((item)=>item.item)
+        });
+    const measurePayload = (bucket, items)=>(0, external_request_js_namespaceObject.measureTextBytes)(JSON.stringify(createPayload(bucket, items)));
+    const rotatePayloadIdentity = (bucket)=>{
+        bucket.batchId = (0, external_request_js_namespaceObject.createBatchId)();
+        bucket.sentAt = Date.now();
+    };
+    const settleRequest = (request, settlement)=>{
+        if ('settled' === request.phase) return false;
+        request.phase = 'settled';
+        request.lifetime.signal.removeEventListener('abort', request.abortListener);
+        request.lifetime.dispose();
+        if (pendingByKey.get(request.key) === request) pendingByKey.delete(request.key);
+        if ('resolve' === settlement.type) request.resolve(settlement.value);
+        else request.reject(settlement.reason);
+        return true;
+    };
+    const removeQueuedRequest = (request)=>{
+        const bucket = buckets.get(request.bucketKey);
+        if (!bucket) return;
+        const index = bucket.items.indexOf(request);
+        if (-1 === index) return;
+        bucket.items.splice(index, 1);
+        bucket.bytes = measurePayload(bucket, bucket.items);
+        if (0 === bucket.items.length && bucket.timer) {
+            clearTimeout(bucket.timer);
+            bucket.timer = null;
+        }
+        buckets.releaseIfIdle(request.bucketKey, bucket);
+    };
+    const abortQueuedRequest = (request)=>{
+        if ('settled' === request.phase) return;
+        if ('queued' === request.phase) removeQueuedRequest(request);
+        const abortBatchIfUnused = request.abortBatchIfUnused;
+        settleRequest(request, {
+            type: 'reject',
+            reason: abortReason(request.lifetime.signal)
+        });
+        abortBatchIfUnused?.();
+    };
+    const runSingle = (request)=>runWithSignal(request.lifetime.signal, async ()=>{
+            const response = await baseFetch(request.requestInput, request.requestInit);
+            return (0, external_response_js_namespaceObject.parseResponseLikeCreateRequest)(response);
+        });
+    const settleRequests = async (items, runner)=>{
+        await Promise.all(items.map(async (item)=>{
+            if ('settled' === item.phase) return;
+            try {
+                const value = await runner(item);
+                settleRequest(item, {
+                    type: 'resolve',
+                    value
+                });
+            } catch (error) {
+                settleRequest(item, {
+                    type: 'reject',
+                    reason: error
+                });
+            }
+        }));
+    };
+    const runAfterAmbiguousBatch = (request, reason)=>{
+        if (!SAFE_REPLAY_METHODS.has(request.item.method)) throw new Error(`Batch result is unknown for ${request.item.method}; automatic replay is disabled (${reason}).`);
+        return runSingle(request);
+    };
+    const settleAmbiguousBatchRequests = (items, reason)=>settleRequests(items, (request)=>runAfterAmbiguousBatch(request, reason));
+    const flushBucket = async (bucketKey)=>{
+        const bucket = buckets.get(bucketKey);
+        if (!bucket || bucket.flushing) return;
+        if (bucket.timer) {
+            clearTimeout(bucket.timer);
+            bucket.timer = null;
+        }
+        if (0 === bucket.items.length) return void buckets.releaseIfIdle(bucketKey, bucket);
+        bucket.flushing = true;
+        const items = bucket.items;
+        for (const item of items)item.phase = 'flushing';
+        const payloadIdentity = {
+            batchId: bucket.batchId,
+            sentAt: bucket.sentAt
+        };
+        bucket.items = [];
+        bucket.bytes = 0;
+        rotatePayloadIdentity(bucket);
+        const firstItem = items[0];
+        if (!firstItem) {
+            bucket.flushing = false;
+            buckets.releaseIfIdle(bucketKey, bucket);
+            return;
+        }
+        const endpoint = firstItem.endpoint;
+        if (1 === items.length || disabledEndpoints.has(endpoint)) {
+            (0, external_telemetry_js_namespaceObject.emitDataBatchTransportEvent)(onEvent, {
+                type: disabledEndpoints.has(endpoint) ? 'fallback' : 'flush',
+                endpoint,
+                size: items.length,
+                reason: disabledEndpoints.has(endpoint) ? 'batch-disabled' : void 0
+            });
+            await settleRequests(items, runSingle);
+            bucket.flushing = false;
+            if (bucket.items.length > 0 && !bucket.timer) flushBucket(bucketKey);
+            buckets.releaseIfIdle(bucketKey, bucket);
+            return;
+        }
+        const payload = createPayload(payloadIdentity, items);
+        const batchId = payload.batchId;
+        (0, external_telemetry_js_namespaceObject.emitDataBatchTransportEvent)(onEvent, {
+            type: 'flush',
+            endpoint,
+            batchId,
+            size: items.length
+        });
+        const payloadJson = JSON.stringify(payload);
+        const traceparent = items.find((item)=>'string' == typeof item.item.headers?.traceparent)?.item.headers?.traceparent || void 0;
+        const authorization = firstItem.authorization;
+        const cookie = firstItem.cookie;
+        const requestInit = {
+            method: 'POST',
+            credentials: firstItem.credentials,
+            headers: {
+                accept: 'application/json, */*;q=0.8',
+                'content-type': 'application/json; charset=utf-8',
+                [external_types_js_namespaceObject.DEFAULT_DATA_BATCH_HEADER]: '2',
+                ...traceparent ? {
+                    traceparent
+                } : {},
+                ...'string' == typeof authorization ? {
+                    authorization
+                } : {},
+                ...'string' == typeof cookie ? {
+                    cookie
+                } : {}
+            },
+            body: payloadJson
+        };
+        const controller = new AbortController();
+        let abortedBecauseUnused = false;
+        const abortBatchIfUnused = ()=>{
+            if (!controller.signal.aborted && items.every((item)=>'settled' === item.phase)) {
+                abortedBecauseUnused = true;
+                controller.abort(items.find((item)=>item.lifetime.timedOut) ? new DOMException('The batch timed out', 'TimeoutError') : new DOMException('Every batched request was aborted', 'AbortError'));
+            }
+        };
+        for (const item of items)item.abortBatchIfUnused = abortBatchIfUnused;
+        requestInit.signal = controller.signal;
+        try {
+            const response = await runWithSignal(controller.signal, ()=>baseFetch(endpoint, requestInit));
+            if (!response.ok) {
+                if (404 === response.status || 405 === response.status) {
+                    disabledEndpoints.add(endpoint);
+                    (0, external_telemetry_js_namespaceObject.emitDataBatchTransportEvent)(onEvent, {
+                        type: 'disable',
+                        endpoint,
+                        batchId,
+                        reason: `batch-endpoint-unavailable-${String(response.status)}`
+                    });
+                } else (0, external_telemetry_js_namespaceObject.emitDataBatchTransportEvent)(onEvent, {
+                    type: 'fallback',
+                    endpoint,
+                    batchId,
+                    size: items.length,
+                    reason: `batch-response-${String(response.status)}`
+                });
+                await settleAmbiguousBatchRequests(items, `batch-response-${String(response.status)}`);
+                bucket.flushing = false;
+                return;
+            }
+            const result = await runWithSignal(controller.signal, async ()=>response.json());
+            if (!(0, external_response_js_namespaceObject.isBatchResponsePayload)(result)) {
+                (0, external_telemetry_js_namespaceObject.emitDataBatchTransportEvent)(onEvent, {
+                    type: 'fallback',
+                    endpoint,
+                    batchId,
+                    size: items.length,
+                    reason: 'invalid-batch-response'
+                });
+                await settleAmbiguousBatchRequests(items, 'invalid-batch-response');
+                bucket.flushing = false;
+                return;
+            }
+            if (result.batchId !== batchId) {
+                (0, external_telemetry_js_namespaceObject.emitDataBatchTransportEvent)(onEvent, {
+                    type: 'fallback',
+                    endpoint,
+                    batchId,
+                    size: items.length,
+                    reason: 'mismatched-batch-id'
+                });
+                await settleAmbiguousBatchRequests(items, 'mismatched-batch-id');
+                bucket.flushing = false;
+                return;
+            }
+            const itemMap = new Map();
+            for (const item of result.items)itemMap.set(item.id, item);
+            await settleRequests(items, async (request)=>{
+                const resultItem = itemMap.get(request.item.id);
+                if (!resultItem) return runAfterAmbiguousBatch(request, 'missing-batch-result');
+                const reconstructedBody = resultItem.body ? (0, external_protocol_js_namespaceObject.decodeBatchBody)(resultItem.body) : null;
+                const reconstructedResponse = new Response((0, external_protocol_js_namespaceObject.isNullBodyStatus)(resultItem.status) ? null : reconstructedBody, {
+                    status: resultItem.status,
+                    headers: resultItem.headers
+                });
+                return (0, external_response_js_namespaceObject.parseResponseLikeCreateRequest)(reconstructedResponse);
+            });
+        } catch  {
+            if (abortedBecauseUnused) {
+                if (items.some((item)=>item.lifetime.timedOut)) (0, external_telemetry_js_namespaceObject.emitDataBatchTransportEvent)(onEvent, {
+                    type: 'fallback',
+                    endpoint,
+                    batchId,
+                    size: items.length,
+                    reason: 'batch-timeout'
+                });
+                return;
+            }
+            (0, external_telemetry_js_namespaceObject.emitDataBatchTransportEvent)(onEvent, {
+                type: 'fallback',
+                endpoint,
+                batchId,
+                size: items.length,
+                reason: 'batch-transport-error'
+            });
+            await settleAmbiguousBatchRequests(items, 'batch-transport-error');
+        } finally{
+            for (const item of items)item.abortBatchIfUnused = void 0;
+            bucket.flushing = false;
+            if (bucket.items.length > 0 && !bucket.timer) flushBucket(bucketKey);
+            buckets.releaseIfIdle(bucketKey, bucket);
+        }
+    };
+    const pendingReadPromises = new Map();
+    const normalizeRequest = (input, init)=>{
+        const sourceRequest = "u" > typeof Request && input instanceof Request ? input : void 0;
+        const initDefinesSignal = void 0 !== init && 'signal' in init;
+        const initDefinesBody = void 0 !== init && 'body' in init;
+        const initSnapshot = init ? {
+            ...init
+        } : void 0;
+        const getInitValue = (key)=>{
+            if (!init) return;
+            return Object.prototype.hasOwnProperty.call(initSnapshot, key) ? initSnapshot?.[key] : init[key];
+        };
+        const method = (0, external_request_js_namespaceObject.normalizeMethod)(getInitValue('method') ?? sourceRequest?.method);
+        const headers = (0, external_request_js_namespaceObject.toHeaderRecord)(getInitValue('headers') ?? sourceRequest?.headers);
+        const credentials = getInitValue('credentials') ?? sourceRequest?.credentials ?? 'same-origin';
+        const initBody = getInitValue('body');
+        const body = initBody ?? null;
+        const initSignal = initDefinesSignal ? getInitValue('signal') : void 0;
+        const sourceSignal = initDefinesSignal ? initSignal ?? void 0 : sourceRequest?.signal;
+        const requestUrl = (0, external_url_js_namespaceObject.toAbsoluteUrl)(input);
+        const endpoint = (0, external_url_js_namespaceObject.normalizeBatchEndpoint)(requestUrl, options.endpoint).toString();
+        return {
+            requestUrl,
+            endpoint,
+            method,
+            headers,
+            credentials,
+            body,
+            hasOpaqueSourceBody: void 0 === initBody && void 0 !== sourceRequest && null !== sourceRequest.body,
+            requestInput: sourceRequest ?? requestUrl.toString(),
+            requestInit: {
+                ...initSnapshot,
+                method,
+                headers,
+                credentials,
+                ...initDefinesBody ? {
+                    body: initBody
+                } : {},
+                ...initDefinesSignal ? {
+                    signal: initSignal
+                } : {}
+            },
+            sourceSignal
+        };
+    };
+    const getPendingReadKey = (request)=>{
+        if (!SAFE_REPLAY_METHODS.has(request.method) || void 0 !== request.sourceSignal || null !== request.body || request.hasOpaqueSourceBody || disabledEndpoints.has(request.endpoint) || !(0, external_request_js_namespaceObject.shouldBatchRequest)({
+            method: request.method,
+            body: void 0,
+            headers: request.headers,
+            allowedMethods,
+            batchEndpoint: request.endpoint,
+            requestUrl: request.requestUrl
+        })) return;
+        const itemHeaders = {
+            ...request.headers
+        };
+        delete itemHeaders.authorization;
+        delete itemHeaders.cookie;
+        const bucketKey = (0, external_codec_js_namespaceObject.stableStringify)({
+            endpoint: request.endpoint,
+            authorization: request.headers.authorization ?? null,
+            cookie: request.headers.cookie ?? null,
+            credentials: request.credentials
+        });
+        return (0, external_codec_js_namespaceObject.stableStringify)({
+            bucketKey,
+            path: `${request.requestUrl.pathname}${request.requestUrl.search}`,
+            method: request.method,
+            headers: itemHeaders,
+            body: null
+        });
+    };
+    const enqueue = async (request)=>{
+        const preparedBody = await (0, external_request_js_namespaceObject.toRequestBody)(request.body);
+        const hasOpaqueBody = !preparedBody.batchable || request.hasOpaqueSourceBody;
+        if (disabledEndpoints.has(request.endpoint) || !(0, external_request_js_namespaceObject.shouldBatchRequest)({
+            method: request.method,
+            body: hasOpaqueBody ? '[opaque request body]' : void 0,
+            headers: request.headers,
+            allowedMethods,
+            batchEndpoint: request.endpoint,
+            requestUrl: request.requestUrl
+        })) return baseFetch(request.requestInput, request.requestInit).then(external_response_js_namespaceObject.parseResponseLikeCreateRequest);
+        const itemId = `${Date.now().toString(36)}_${nextItemId.toString(36)}_${Math.random().toString(16).slice(2, 8)}`;
+        nextItemId += 1;
+        const itemHeaders = {
+            ...request.headers
+        };
+        delete itemHeaders.authorization;
+        delete itemHeaders.cookie;
+        if (preparedBody.body && preparedBody.inferredContentType && !itemHeaders['content-type']) itemHeaders['content-type'] = preparedBody.inferredContentType;
+        const item = {
+            id: itemId,
+            path: `${request.requestUrl.pathname}${request.requestUrl.search}`,
+            method: request.method,
+            headers: itemHeaders,
+            ...preparedBody.body ? {
+                body: preparedBody.body
+            } : {}
+        };
+        const bucketKey = (0, external_codec_js_namespaceObject.stableStringify)({
+            endpoint: request.endpoint,
+            authorization: request.headers.authorization ?? null,
+            cookie: request.headers.cookie ?? null,
+            credentials: request.credentials
+        });
+        const key = (0, external_codec_js_namespaceObject.stableStringify)({
+            bucketKey,
+            path: item.path,
+            method: item.method,
+            headers: item.headers,
+            body: item.body ?? null
+        });
+        const canSharePending = SAFE_REPLAY_METHODS.has(request.method) && void 0 === request.sourceSignal;
+        const existing = canSharePending ? pendingByKey.get(key) : void 0;
+        if (existing) return existing.promise;
+        const lifetime = createRequestLifetime(request.sourceSignal, requestTimeoutMs);
+        request.requestInit.signal = lifetime.signal;
+        const deferred = Promise.withResolvers();
+        const queued = {
+            key,
+            bucketKey,
+            endpoint: request.endpoint,
+            requestInput: request.requestInput,
+            requestInit: request.requestInit,
+            authorization: request.headers.authorization,
+            cookie: request.headers.cookie,
+            credentials: request.credentials,
+            item,
+            lifetime,
+            phase: 'queued',
+            promise: deferred.promise,
+            abortListener: ()=>abortQueuedRequest(queued),
+            resolve: deferred.resolve,
+            reject: deferred.reject
+        };
+        lifetime.signal.addEventListener('abort', queued.abortListener, {
+            once: true
+        });
+        if (lifetime.signal.aborted) {
+            abortQueuedRequest(queued);
+            return queued.promise;
+        }
+        if (canSharePending) pendingByKey.set(key, queued);
+        const bucket = buckets.ensure(bucketKey);
+        const singletonBytes = measurePayload(bucket, [
+            queued
+        ]);
+        if (singletonBytes > maxBatchBytes) {
+            (0, external_telemetry_js_namespaceObject.emitDataBatchTransportEvent)(onEvent, {
+                type: 'fallback',
+                endpoint: request.endpoint,
+                size: 1,
+                reason: 'batch-item-too-large'
+            });
+            queued.phase = 'flushing';
+            settleRequests([
+                queued
+            ], runSingle);
+            buckets.releaseIfIdle(bucketKey, bucket);
+            return queued.promise;
+        }
+        const candidateItems = [
+            ...bucket.items,
+            queued
+        ];
+        const candidateBytes = measurePayload(bucket, candidateItems);
+        if (bucket.items.length > 0 && candidateBytes > maxBatchBytes) {
+            if (bucket.flushing) {
+                (0, external_telemetry_js_namespaceObject.emitDataBatchTransportEvent)(onEvent, {
+                    type: 'fallback',
+                    endpoint: request.endpoint,
+                    size: 1,
+                    reason: 'batch-capacity-during-flush'
+                });
+                queued.phase = 'flushing';
+                settleRequests([
+                    queued
+                ], runSingle);
+                return queued.promise;
+            }
+            flushBucket(bucketKey);
+            if (measurePayload(bucket, [
+                queued
+            ]) > maxBatchBytes) {
+                (0, external_telemetry_js_namespaceObject.emitDataBatchTransportEvent)(onEvent, {
+                    type: 'fallback',
+                    endpoint: request.endpoint,
+                    size: 1,
+                    reason: 'batch-item-too-large'
+                });
+                queued.phase = 'flushing';
+                settleRequests([
+                    queued
+                ], runSingle);
+                return queued.promise;
+            }
+        }
+        bucket.items.push(queued);
+        bucket.bytes = measurePayload(bucket, bucket.items);
+        (0, external_telemetry_js_namespaceObject.emitDataBatchTransportEvent)(onEvent, {
+            type: 'enqueue',
+            endpoint: request.endpoint,
+            size: bucket.items.length
+        });
+        if (bucket.items.length >= maxBatchSize || bucket.bytes >= maxBatchBytes) {
+            flushBucket(bucketKey);
+            return queued.promise;
+        }
+        if (!bucket.timer) bucket.timer = setTimeout(()=>{
+            bucket.timer = null;
+            flushBucket(bucketKey);
+        }, flushIntervalMs);
+        return queued.promise;
+    };
+    return (input, init)=>{
+        let request;
+        try {
+            request = normalizeRequest(input, init);
+        } catch (error) {
+            return Promise.reject(error);
+        }
+        const pendingReadKey = getPendingReadKey(request);
+        const existing = pendingReadKey ? pendingReadPromises.get(pendingReadKey) : void 0;
+        if (existing) return existing;
+        const pending = enqueue(request);
+        if (pendingReadKey) {
+            pendingReadPromises.set(pendingReadKey, pending);
+            const clearPendingRead = ()=>{
+                if (pendingReadPromises.get(pendingReadKey) === pending) pendingReadPromises.delete(pendingReadKey);
+            };
+            pending.then(clearPendingRead, clearPendingRead);
+        }
+        return pending;
+    };
+}
+exports.BatchBucketRegistry = __webpack_exports__.BatchBucketRegistry;
+exports.createBatchTransportQueue = __webpack_exports__.createBatchTransportQueue;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "BatchBucketRegistry",
+    "createBatchTransportQueue"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});