@bleedingdev/modern-js-runtime-extensions 3.8.3-ultramodern.2

package/dist/cjs/node.js

@@ -0,0 +1,143 @@
+"use strict";
+var __webpack_modules__ = {
+    "./rendererHead" (module) {
+        module.exports = require("./rendererHead.js");
+    },
+    "node:stream" (module) {
+        module.exports = require("node:stream");
+    },
+    "node:string_decoder" (module) {
+        module.exports = require("node:string_decoder");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__);
+    var node_stream__rspack_import_0 = __webpack_require__("node:stream");
+    var node_string_decoder__rspack_import_1 = __webpack_require__("node:string_decoder");
+    var _rendererHead__rspack_import_2 = __webpack_require__("./rendererHead");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _rendererHead__rspack_import_2)if ([
+        "default",
+        "pipeNodeHeadStream",
+        "createNodeHeadMarkerStripper",
+        "createOnceErrorReporter"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_rendererHead__rspack_import_2[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    const toError = (reason)=>reason instanceof Error ? reason : new Error(String(reason));
+    const createNodeHeadMarkerStripper = (context, terminalMarker)=>{
+        const decoder = new node_string_decoder__rspack_import_1.StringDecoder('utf8');
+        const processor = (0, _rendererHead__rspack_import_2.createHeadChunkProcessor)(context);
+        let terminalCarry = '';
+        let sawTerminalMarker = void 0 === terminalMarker;
+        const observeTerminalMarker = (output)=>{
+            if (!sawTerminalMarker && void 0 !== terminalMarker) {
+                const observed = terminalCarry + output;
+                sawTerminalMarker = observed.includes(terminalMarker);
+                terminalCarry = observed.slice(Math.max(0, observed.length - terminalMarker.length + 1));
+            }
+            return output;
+        };
+        return new node_stream__rspack_import_0.Transform({
+            transform (chunk, _encoding, callback) {
+                try {
+                    callback(null, observeTerminalMarker(processor.push(decoder.write(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)))));
+                } catch (error) {
+                    callback(toError(error));
+                }
+            },
+            flush (callback) {
+                try {
+                    const output = observeTerminalMarker(processor.finish(decoder.end()));
+                    callback(null, sawTerminalMarker ? output : `${output}${terminalMarker}`);
+                } catch (error) {
+                    callback(toError(error));
+                }
+            },
+            destroy (error, callback) {
+                try {
+                    (0, _rendererHead__rspack_import_2.abortHeadRender)(context);
+                    callback(error);
+                } catch (abortError) {
+                    callback(error ?? toError(abortError));
+                }
+            }
+        });
+    };
+    const createOnceErrorReporter = (onError)=>{
+        let reported = false;
+        return (error)=>{
+            if (!reported) {
+                reported = true;
+                onError?.(error);
+            }
+        };
+    };
+    const pipeNodeHeadStream = (options)=>{
+        const { source, destination, context, terminalMarker, onError } = options;
+        const stripper = createNodeHeadMarkerStripper(context, terminalMarker);
+        (0, node_stream__rspack_import_0.pipeline)(source, stripper, destination, (error)=>{
+            if (null !== error) onError?.(error);
+        });
+    };
+    __webpack_require__.d(__webpack_exports__, {}, {
+        createNodeHeadMarkerStripper: createNodeHeadMarkerStripper,
+        createOnceErrorReporter: createOnceErrorReporter,
+        pipeNodeHeadStream: pipeNodeHeadStream
+    });
+})();
+exports.createNodeHeadMarkerStripper = __webpack_exports__.createNodeHeadMarkerStripper;
+exports.createOnceErrorReporter = __webpack_exports__.createOnceErrorReporter;
+exports.pipeNodeHeadStream = __webpack_exports__.pipeNodeHeadStream;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createNodeHeadMarkerStripper",
+    "createOnceErrorReporter",
+    "pipeNodeHeadStream"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/rendererHead.js

@@ -0,0 +1,263 @@
+"use strict";
+var __webpack_modules__ = {
+    "./helmetCompat" (module) {
+        module.exports = require("./helmetCompat.js");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__);
+    var _helmetCompat__rspack_import_0 = __webpack_require__("./helmetCompat");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _helmetCompat__rspack_import_0)if ([
+        "createWebHeadMarkerStripper",
+        "default",
+        "finishHeadRender",
+        "abortHeadRender",
+        "beginHeadRender",
+        "completeHeadRender",
+        "createHeadChunkProcessor",
+        "publishHeadRender",
+        "collectHeadRecord",
+        "collectHeadState"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_helmetCompat__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    const MARKER_ATTRIBUTE = 'data-modern-helmet';
+    const MARKER_PREFIX = `<template ${MARKER_ATTRIBUTE}="`;
+    const MARKER_SUFFIX = '"></template>';
+    const RECORD_ID_WIDTH = 12;
+    const MARKER_LENGTH = MARKER_PREFIX.length + 1 + 36 + RECORD_ID_WIDTH + MARKER_SUFFIX.length;
+    const HEAD_STATE = Symbol('modern.rendererHead');
+    const getState = (context)=>{
+        const headContext = context;
+        let state = headContext[HEAD_STATE];
+        if (void 0 === state) {
+            state = {
+                publishedRecords: []
+            };
+            Object.defineProperty(headContext, HEAD_STATE, {
+                value: state
+            });
+        }
+        return state;
+    };
+    const formatId = (value)=>value.toString(36).padStart(RECORD_ID_WIDTH, '0');
+    const createToken = (transaction)=>{
+        const token = `h${transaction.nonce}${formatId(transaction.nextRecordId)}`;
+        transaction.nextRecordId += 1;
+        return token;
+    };
+    const beginHeadRender = (context)=>{
+        const state = getState(context);
+        state.transaction = {
+            recordsByToken: new Map(),
+            committedRecords: [],
+            committedTokens: new Set(),
+            nextRecordId: 0,
+            nonce: globalThis.crypto.randomUUID(),
+            previousRecords: state.publishedRecords,
+            sealed: false
+        };
+        state.publish?.([]);
+    };
+    const collectHeadRecord = (context, createRecord, publish)=>{
+        const state = getState(context);
+        const transaction = state.transaction;
+        if (void 0 === transaction) return;
+        const hadPublisher = void 0 !== state.publish;
+        state.publish = (records)=>publish(records);
+        if (!hadPublisher) state.publish([]);
+        if (transaction.sealed) return null;
+        const token = createToken(transaction);
+        transaction.recordsByToken.set(token, createRecord());
+        return {
+            [MARKER_ATTRIBUTE]: token
+        };
+    };
+    const collectHeadState = (context, createRecord, derive, target)=>collectHeadRecord(context, createRecord, (records)=>{
+            target.helmet = derive(records);
+        });
+    const consumeMarkers = (context, html)=>{
+        const transaction = getState(context).transaction;
+        if (void 0 === transaction) return html;
+        let cursor = 0;
+        let stripped = '';
+        while(cursor < html.length){
+            const start = html.indexOf(MARKER_PREFIX, cursor);
+            if (-1 === start) {
+                stripped += html.slice(cursor);
+                break;
+            }
+            const tokenStart = start + MARKER_PREFIX.length;
+            const end = html.indexOf(MARKER_SUFFIX, tokenStart);
+            if (-1 === end) {
+                stripped += html.slice(cursor);
+                break;
+            }
+            const token = html.slice(tokenStart, end);
+            if (transaction.recordsByToken.has(token)) {
+                stripped += html.slice(cursor, start);
+                if (!transaction.sealed && !transaction.committedTokens.has(token)) {
+                    transaction.committedTokens.add(token);
+                    transaction.committedRecords.push(transaction.recordsByToken.get(token));
+                }
+            } else stripped += html.slice(cursor, end + MARKER_SUFFIX.length);
+            cursor = end + MARKER_SUFFIX.length;
+        }
+        return stripped;
+    };
+    const publish = (context)=>{
+        const state = getState(context);
+        const records = state.transaction?.committedRecords ?? [];
+        state.publishedRecords = records;
+        state.publish?.(records);
+    };
+    const publishHeadRender = (context)=>{
+        const transaction = getState(context).transaction;
+        if (void 0 !== transaction) {
+            transaction.sealed = true;
+            publish(context);
+        }
+    };
+    const finishHeadRender = (context)=>{
+        const state = getState(context);
+        if (void 0 !== state.transaction) {
+            if (!state.transaction.sealed) publish(context);
+            state.transaction = void 0;
+        }
+    };
+    const completeHeadRender = (context, html)=>{
+        const stripped = consumeMarkers(context, html);
+        finishHeadRender(context);
+        return stripped;
+    };
+    const abortHeadRender = (context)=>{
+        const state = getState(context);
+        const transaction = state.transaction;
+        if (void 0 !== transaction) {
+            state.publishedRecords = transaction.previousRecords;
+            state.publish?.(transaction.previousRecords);
+            state.transaction = void 0;
+        }
+    };
+    const findCarryStart = (input)=>{
+        const windowStart = Math.max(0, input.length - MARKER_LENGTH + 1);
+        const markerStart = input.lastIndexOf(MARKER_PREFIX);
+        if (markerStart >= windowStart && input.length - markerStart < MARKER_LENGTH) return markerStart;
+        const maxPrefixLength = Math.min(MARKER_PREFIX.length - 1, input.length);
+        for(let length = maxPrefixLength; length > 0; length -= 1)if (MARKER_PREFIX.startsWith(input.slice(-length))) return input.length - length;
+        return input.length;
+    };
+    const createHeadChunkProcessor = (context)=>{
+        let carry = '';
+        return {
+            push (chunk) {
+                const input = carry + chunk;
+                const carryStart = findCarryStart(input);
+                const output = consumeMarkers(context, input.slice(0, carryStart));
+                carry = input.slice(carryStart);
+                return output;
+            },
+            finish (chunk = '') {
+                const output = completeHeadRender(context, carry + chunk);
+                carry = '';
+                return output;
+            }
+        };
+    };
+    const createWebHeadMarkerStripper = (context)=>{
+        const decoder = new TextDecoder();
+        const encoder = new TextEncoder();
+        const processor = createHeadChunkProcessor(context);
+        return new TransformStream({
+            transform (chunk, controller) {
+                const output = processor.push(decoder.decode(chunk, {
+                    stream: true
+                }));
+                if (output) controller.enqueue(encoder.encode(output));
+            },
+            flush (controller) {
+                const output = processor.finish(decoder.decode());
+                if (output) controller.enqueue(encoder.encode(output));
+            }
+        });
+    };
+    __webpack_require__.d(__webpack_exports__, {}, {
+        abortHeadRender: abortHeadRender,
+        beginHeadRender: beginHeadRender,
+        collectHeadRecord: collectHeadRecord,
+        collectHeadState: collectHeadState,
+        completeHeadRender: completeHeadRender,
+        createHeadChunkProcessor: createHeadChunkProcessor,
+        createWebHeadMarkerStripper: createWebHeadMarkerStripper,
+        finishHeadRender: finishHeadRender,
+        publishHeadRender: publishHeadRender
+    });
+})();
+exports.abortHeadRender = __webpack_exports__.abortHeadRender;
+exports.beginHeadRender = __webpack_exports__.beginHeadRender;
+exports.collectHeadRecord = __webpack_exports__.collectHeadRecord;
+exports.collectHeadState = __webpack_exports__.collectHeadState;
+exports.completeHeadRender = __webpack_exports__.completeHeadRender;
+exports.createHeadChunkProcessor = __webpack_exports__.createHeadChunkProcessor;
+exports.createWebHeadMarkerStripper = __webpack_exports__.createWebHeadMarkerStripper;
+exports.finishHeadRender = __webpack_exports__.finishHeadRender;
+exports.publishHeadRender = __webpack_exports__.publishHeadRender;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "abortHeadRender",
+    "beginHeadRender",
+    "collectHeadRecord",
+    "collectHeadState",
+    "completeHeadRender",
+    "createHeadChunkProcessor",
+    "createWebHeadMarkerStripper",
+    "finishHeadRender",
+    "publishHeadRender"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/rscHtmlStream.js

@@ -0,0 +1,128 @@
+"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 encoder = new TextEncoder();
+const closingTagsPattern = /<\/body>\s*<\/html>\s*$/i;
+const closingTagsPrefixPattern = /(?:<\/body>\s*(?:<\/html>\s*|<\/h(?:t(?:m(?:l>?)?)?)?|<\/?|<)?|<\/b(?:o(?:d(?:y>?)?)?)?|<\/?|<[^>]*)$/i;
+const RSC_HTML_CLOSING_TAIL_LIMIT = 8192;
+function injectRSCPayload(rscStream, { injectClosingTags = true } = {}) {
+    const decoder = new TextDecoder();
+    let retainedTail = '';
+    let committedClosingBody = false;
+    let committedHtmlClose = false;
+    let committedProbe = '';
+    let flightPromise;
+    const startFlight = (controller)=>{
+        if (!flightPromise) {
+            flightPromise = writeRSCStream(rscStream, controller);
+            flightPromise.catch((error)=>controller.error(error));
+        }
+        return flightPromise;
+    };
+    const enqueueHtml = (value, controller)=>{
+        if (value) controller.enqueue(encoder.encode(value));
+    };
+    const processHtml = async (value, controller)=>{
+        if (!value) return;
+        if (committedClosingBody) {
+            const probe = committedProbe + value;
+            committedHtmlClose ||= /<\/html>/i.test(probe);
+            committedProbe = probe.slice(-6);
+            enqueueHtml(value, controller);
+            return;
+        }
+        const html = retainedTail + value;
+        retainedTail = '';
+        const suffix = html.match(closingTagsPrefixPattern)?.[0] ?? '';
+        const prefix = suffix ? html.slice(0, -suffix.length) : html;
+        enqueueHtml(prefix, controller);
+        if (!suffix) return void startFlight(controller);
+        if (suffix.length <= RSC_HTML_CLOSING_TAIL_LIMIT) {
+            retainedTail = suffix;
+            return;
+        }
+        await startFlight(controller);
+        if (/<\/body>/i.test(suffix)) {
+            committedClosingBody = true;
+            committedHtmlClose = /<\/html>/i.test(suffix);
+            committedProbe = suffix.slice(-6);
+        }
+        enqueueHtml(suffix, controller);
+    };
+    return new TransformStream({
+        async transform (chunk, controller) {
+            await processHtml(decoder.decode(chunk, {
+                stream: true
+            }), controller);
+        },
+        async flush (controller) {
+            await processHtml(decoder.decode(), controller);
+            await startFlight(controller);
+            const retainedClosingTags = closingTagsPattern.test(retainedTail);
+            enqueueHtml(retainedTail, controller);
+            if (!injectClosingTags) return;
+            if (committedClosingBody) {
+                if (!committedHtmlClose) enqueueHtml('</html>', controller);
+            } else if (!retainedClosingTags) enqueueHtml('</body></html>', controller);
+        }
+    });
+}
+async function writeRSCStream(rscStream, controller) {
+    const decoder = new TextDecoder('utf-8', {
+        fatal: true
+    });
+    for await (const chunk of rscStream)try {
+        writeChunk(JSON.stringify(decoder.decode(chunk, {
+            stream: true
+        })), controller);
+    } catch  {
+        const base64 = JSON.stringify(btoa(String.fromCodePoint(...chunk)));
+        writeChunk(`Uint8Array.from(atob(${base64}), m => m.codePointAt(0))`, controller);
+    }
+    const remaining = decoder.decode();
+    if (remaining) writeChunk(JSON.stringify(remaining), controller);
+}
+function writeChunk(chunk, controller) {
+    const script = `(self.__FLIGHT_DATA||=[]).push(${chunk})`;
+    controller.enqueue(encoder.encode(`<script>${script.replace(/<!--/g, '<\\!--').replace(/<\/(script)/gi, '</\\$1')}</script>`));
+}
+__webpack_require__.d(__webpack_exports__, {
+    injectRSCPayload: ()=>injectRSCPayload
+}, {
+    RSC_HTML_CLOSING_TAIL_LIMIT: RSC_HTML_CLOSING_TAIL_LIMIT
+});
+exports.RSC_HTML_CLOSING_TAIL_LIMIT = __webpack_exports__.RSC_HTML_CLOSING_TAIL_LIMIT;
+exports.injectRSCPayload = __webpack_exports__.injectRSCPayload;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "RSC_HTML_CLOSING_TAIL_LIMIT",
+    "injectRSCPayload"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/safeFailure.js

@@ -0,0 +1,125 @@
+"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 SAFE_FAILURE_MESSAGES = {
+    500: 'Internal Server Error',
+    503: 'Service Unavailable'
+};
+const SAFE_FAILURE_CODES = {
+    500: 'INTERNAL_SERVER_ERROR',
+    503: 'SERVICE_UNAVAILABLE'
+};
+const readErrorProperty = (error, key)=>{
+    if ('object' != typeof error || null === error) return;
+    try {
+        return error[key];
+    } catch  {
+        return;
+    }
+};
+const normalizeFailureStatus = (value)=>'number' == typeof value && Number.isInteger(value) && value >= 400 && value <= 599 ? value : void 0;
+const normalizeDelaySeconds = (value)=>{
+    if ('number' == typeof value) {
+        const seconds = Math.ceil(value);
+        return Number.isFinite(value) && value >= 0 && Number.isSafeInteger(seconds) ? String(seconds) : void 0;
+    }
+    if ('string' == typeof value) {
+        const trimmed = value.trim();
+        if (!/^\d+$/u.test(trimmed)) return;
+        const seconds = Number(trimmed);
+        return Number.isSafeInteger(seconds) ? String(seconds) : void 0;
+    }
+};
+const normalizeHttpDate = (value)=>{
+    try {
+        if (value instanceof Date) {
+            const timestamp = Date.prototype.getTime.call(value);
+            return Number.isFinite(timestamp) ? new Date(timestamp).toUTCString() : void 0;
+        }
+        if ('string' == typeof value) {
+            const trimmed = value.trim();
+            const timestamp = Date.parse(trimmed);
+            if (Number.isFinite(timestamp)) {
+                const canonical = new Date(timestamp).toUTCString();
+                return canonical === trimmed ? canonical : void 0;
+            }
+        }
+    } catch  {}
+};
+const normalizeRetryAfter = (value)=>normalizeDelaySeconds(value) ?? normalizeHttpDate(value);
+const getSafeFailureStatus = (error)=>normalizeFailureStatus(readErrorProperty(error, 'status')) ?? normalizeFailureStatus(readErrorProperty(error, 'statusCode')) ?? 500;
+const createSafeFailureHttpResult = (error)=>{
+    const status = getSafeFailureStatus(error);
+    const retryAfterMs = readErrorProperty(error, 'retryAfterMs');
+    const retryAfter = 503 === status ? normalizeRetryAfter(readErrorProperty(error, 'retryAfter')) ?? normalizeRetryAfter(readErrorProperty(error, 'retryAfterSeconds')) ?? normalizeRetryAfter('number' == typeof retryAfterMs ? retryAfterMs / 1000 : void 0) : void 0;
+    return {
+        status,
+        body: {
+            success: false,
+            error: {
+                code: SAFE_FAILURE_CODES[status] ?? 'REQUEST_FAILED',
+                message: SAFE_FAILURE_MESSAGES[status] ?? 'Request failed',
+                status
+            }
+        },
+        headers: {
+            'content-type': 'application/json; charset=utf-8',
+            ...void 0 === retryAfter ? {} : {
+                'Retry-After': retryAfter
+            }
+        }
+    };
+};
+const createSafeJsonFailureResponse = (error)=>{
+    const result = createSafeFailureHttpResult(error);
+    return new Response(JSON.stringify(result.body), {
+        status: result.status,
+        headers: result.headers
+    });
+};
+const createSafeFailureResponse = createSafeJsonFailureResponse;
+__webpack_require__.d(__webpack_exports__, {}, {
+    createSafeFailureHttpResult: createSafeFailureHttpResult,
+    createSafeFailureResponse: createSafeFailureResponse,
+    createSafeJsonFailureResponse: createSafeJsonFailureResponse,
+    getSafeFailureStatus: getSafeFailureStatus
+});
+exports.createSafeFailureHttpResult = __webpack_exports__.createSafeFailureHttpResult;
+exports.createSafeFailureResponse = __webpack_exports__.createSafeFailureResponse;
+exports.createSafeJsonFailureResponse = __webpack_exports__.createSafeJsonFailureResponse;
+exports.getSafeFailureStatus = __webpack_exports__.getSafeFailureStatus;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createSafeFailureHttpResult",
+    "createSafeFailureResponse",
+    "createSafeJsonFailureResponse",
+    "getSafeFailureStatus"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});