@comapeo/map-server 1.0.0-pre.0

package/node_modules/@whatwg-node/server/cjs/createServerAdapter.js

@@ -0,0 +1,368 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServerAdapter = createServerAdapter;
+const tslib_1 = require("tslib");
+const instrumentation_1 = require("@envelop/instrumentation");
+const disposablestack_1 = require("@whatwg-node/disposablestack");
+const promise_helpers_1 = require("@whatwg-node/promise-helpers");
+const utils_js_1 = require("./utils.js");
+const uwebsockets_js_1 = require("./uwebsockets.js");
+// Required for envs like nextjs edge runtime
+function isRequestAccessible(serverContext) {
+    try {
+        return !!serverContext?.request;
+    }
+    catch {
+        return false;
+    }
+}
+const EMPTY_OBJECT = {};
+function createServerAdapter(serverAdapterBaseObject, options) {
+    const useSingleWriteHead = options?.__useSingleWriteHead == null ? true : options.__useSingleWriteHead;
+    const fetchAPI = {
+        ...options?.fetchAPI,
+    };
+    const useCustomAbortCtrl = options?.__useCustomAbortCtrl == null
+        ? fetchAPI.Request !== globalThis.Request
+        : options.__useCustomAbortCtrl;
+    const givenHandleRequest = typeof serverAdapterBaseObject === 'function'
+        ? serverAdapterBaseObject
+        : serverAdapterBaseObject.handle;
+    const onRequestHooks = [];
+    const onResponseHooks = [];
+    let instrumentation;
+    const waitUntilPromises = new Set();
+    let _disposableStack;
+    function ensureDisposableStack() {
+        if (!_disposableStack) {
+            _disposableStack = new disposablestack_1.AsyncDisposableStack();
+            if (options?.disposeOnProcessTerminate) {
+                (0, utils_js_1.ensureDisposableStackRegisteredForTerminateEvents)(_disposableStack);
+            }
+            _disposableStack.defer(() => {
+                if (waitUntilPromises.size > 0) {
+                    return Promise.allSettled(waitUntilPromises).then(() => {
+                        waitUntilPromises.clear();
+                    }, () => {
+                        waitUntilPromises.clear();
+                    });
+                }
+            });
+        }
+        return _disposableStack;
+    }
+    function waitUntil(maybePromise) {
+        // Ensure that the disposable stack is created
+        if ((0, utils_js_1.isPromise)(maybePromise)) {
+            ensureDisposableStack();
+            waitUntilPromises.add(maybePromise);
+            maybePromise.then(() => {
+                waitUntilPromises.delete(maybePromise);
+            }, err => {
+                console.error(`Unexpected error while waiting: ${err.message || err}`);
+                waitUntilPromises.delete(maybePromise);
+            });
+        }
+    }
+    if (options?.plugins != null) {
+        for (const plugin of options.plugins) {
+            if (plugin.instrumentation) {
+                instrumentation = instrumentation
+                    ? (0, instrumentation_1.chain)(instrumentation, plugin.instrumentation)
+                    : plugin.instrumentation;
+            }
+            if (plugin.onRequest) {
+                onRequestHooks.push(plugin.onRequest);
+            }
+            if (plugin.onResponse) {
+                onResponseHooks.push(plugin.onResponse);
+            }
+            const disposeFn = plugin[disposablestack_1.DisposableSymbols.dispose];
+            if (disposeFn) {
+                ensureDisposableStack().defer(disposeFn);
+            }
+            const asyncDisposeFn = plugin[disposablestack_1.DisposableSymbols.asyncDispose];
+            if (asyncDisposeFn) {
+                ensureDisposableStack().defer(asyncDisposeFn);
+            }
+            if (plugin.onDispose) {
+                ensureDisposableStack().defer(plugin.onDispose);
+            }
+        }
+    }
+    let handleRequest = onRequestHooks.length > 0 || onResponseHooks.length > 0
+        ? function handleRequest(request, serverContext) {
+            let requestHandler = givenHandleRequest;
+            let response;
+            if (onRequestHooks.length === 0) {
+                return handleEarlyResponse();
+            }
+            let url = request['parsedUrl'] ||
+                new Proxy(EMPTY_OBJECT, {
+                    get(_target, prop, _receiver) {
+                        url = new fetchAPI.URL(request.url, 'http://localhost');
+                        return Reflect.get(url, prop, url);
+                    },
+                });
+            function handleResponse(response) {
+                if (onResponseHooks.length === 0) {
+                    return response;
+                }
+                return (0, promise_helpers_1.handleMaybePromise)(() => (0, utils_js_1.iterateAsyncVoid)(onResponseHooks, onResponseHook => onResponseHook({
+                    request,
+                    response,
+                    serverContext,
+                    setResponse(newResponse) {
+                        response = newResponse;
+                    },
+                    fetchAPI,
+                })), () => response);
+            }
+            function handleEarlyResponse() {
+                if (!response) {
+                    return (0, promise_helpers_1.handleMaybePromise)(() => requestHandler(request, serverContext), handleResponse);
+                }
+                return handleResponse(response);
+            }
+            return (0, promise_helpers_1.handleMaybePromise)(() => (0, utils_js_1.iterateAsyncVoid)(onRequestHooks, (onRequestHook, stopEarly) => onRequestHook({
+                request,
+                setRequest(newRequest) {
+                    request = newRequest;
+                },
+                serverContext,
+                fetchAPI,
+                url,
+                requestHandler,
+                setRequestHandler(newRequestHandler) {
+                    requestHandler = newRequestHandler;
+                },
+                endResponse(newResponse) {
+                    response = newResponse;
+                    if (newResponse) {
+                        stopEarly();
+                    }
+                },
+            })), handleEarlyResponse);
+        }
+        : givenHandleRequest;
+    if (instrumentation?.request) {
+        const originalRequestHandler = handleRequest;
+        handleRequest = (request, initialContext) => {
+            return (0, instrumentation_1.getInstrumented)({ request }).asyncFn(instrumentation.request, originalRequestHandler)(request, initialContext);
+        };
+    }
+    // TODO: Remove this on the next major version
+    function handleNodeRequest(nodeRequest, ...ctx) {
+        const serverContext = ctx.length > 1 ? (0, utils_js_1.completeAssign)(...ctx) : ctx[0] || {};
+        // Ensure `waitUntil` is available in the server context
+        if (!serverContext.waitUntil) {
+            serverContext.waitUntil = waitUntil;
+        }
+        const request = (0, utils_js_1.normalizeNodeRequest)(nodeRequest, fetchAPI, undefined, useCustomAbortCtrl);
+        return handleRequest(request, serverContext);
+    }
+    function handleNodeRequestAndResponse(nodeRequest, nodeResponseOrContainer, ...ctx) {
+        const nodeResponse = nodeResponseOrContainer.raw || nodeResponseOrContainer;
+        const serverContext = ctx.length > 1 ? (0, utils_js_1.completeAssign)(...ctx) : ctx[0] || {};
+        // Ensure `waitUntil` is available in the server context
+        if (!serverContext.waitUntil) {
+            serverContext.waitUntil = waitUntil;
+        }
+        const request = (0, utils_js_1.normalizeNodeRequest)(nodeRequest, fetchAPI, nodeResponse, useCustomAbortCtrl);
+        return handleRequest(request, serverContext);
+    }
+    function requestListener(nodeRequest, nodeResponse, ...ctx) {
+        const defaultServerContext = {
+            req: nodeRequest,
+            res: nodeResponse,
+            waitUntil,
+        };
+        return (0, promise_helpers_1.unfakePromise)((0, uwebsockets_js_1.fakePromise)()
+            .then(() => handleNodeRequestAndResponse(nodeRequest, nodeResponse, defaultServerContext, ...ctx))
+            .catch(err => (0, utils_js_1.handleErrorFromRequestHandler)(err, fetchAPI.Response))
+            .then(response => (0, utils_js_1.sendNodeResponse)(response, nodeResponse, nodeRequest, useSingleWriteHead))
+            .catch(err => console.error(`Unexpected error while handling request: ${err.message || err}`)));
+    }
+    function handleUWS(res, req, ...ctx) {
+        const defaultServerContext = {
+            res,
+            req,
+            waitUntil,
+        };
+        const filteredCtxParts = ctx.filter(partCtx => partCtx != null);
+        const serverContext = filteredCtxParts.length > 0
+            ? (0, utils_js_1.completeAssign)(defaultServerContext, ...ctx)
+            : defaultServerContext;
+        const controller = useCustomAbortCtrl
+            ? (0, utils_js_1.createCustomAbortControllerSignal)()
+            : new AbortController();
+        const originalResEnd = res.end.bind(res);
+        let resEnded = false;
+        res.end = function (data) {
+            resEnded = true;
+            return originalResEnd(data);
+        };
+        const originalOnAborted = res.onAborted.bind(res);
+        originalOnAborted(function () {
+            controller.abort();
+        });
+        res.onAborted = function (cb) {
+            controller.signal.addEventListener('abort', cb, { once: true });
+        };
+        const request = (0, uwebsockets_js_1.getRequestFromUWSRequest)({
+            req,
+            res,
+            fetchAPI,
+            controller,
+        });
+        return (0, promise_helpers_1.handleMaybePromise)(() => (0, promise_helpers_1.handleMaybePromise)(() => handleRequest(request, serverContext), response => response, err => (0, utils_js_1.handleErrorFromRequestHandler)(err, fetchAPI.Response)), response => {
+            if (!controller.signal.aborted && !resEnded) {
+                return (0, promise_helpers_1.handleMaybePromise)(() => (0, uwebsockets_js_1.sendResponseToUwsOpts)(res, response, controller, fetchAPI), r => r, err => {
+                    console.error(`Unexpected error while handling request: ${err.message || err}`);
+                });
+            }
+        });
+    }
+    function handleEvent(event, ...ctx) {
+        if (!event.respondWith || !event.request) {
+            throw new TypeError(`Expected FetchEvent, got ${event}`);
+        }
+        const filteredCtxParts = ctx.filter(partCtx => partCtx != null);
+        const serverContext = filteredCtxParts.length > 0
+            ? (0, utils_js_1.completeAssign)({}, event, ...filteredCtxParts)
+            : (0, utils_js_1.isolateObject)(event);
+        const response$ = handleRequest(event.request, serverContext);
+        event.respondWith(response$);
+    }
+    function handleRequestWithWaitUntil(request, ...ctx) {
+        const filteredCtxParts = ctx.filter(partCtx => partCtx != null);
+        const serverContext = filteredCtxParts.length > 1
+            ? (0, utils_js_1.completeAssign)({}, ...filteredCtxParts)
+            : (0, utils_js_1.isolateObject)(filteredCtxParts[0], filteredCtxParts[0] == null || filteredCtxParts[0].waitUntil == null
+                ? waitUntil
+                : undefined);
+        return handleRequest(request, serverContext);
+    }
+    const fetchFn = (input, ...maybeCtx) => {
+        if (typeof input === 'string' || 'href' in input) {
+            const [initOrCtx, ...restOfCtx] = maybeCtx;
+            if ((0, utils_js_1.isRequestInit)(initOrCtx)) {
+                const request = new fetchAPI.Request(input, initOrCtx);
+                const res$ = handleRequestWithWaitUntil(request, ...restOfCtx);
+                const signal = initOrCtx.signal;
+                if (signal) {
+                    return (0, utils_js_1.handleAbortSignalAndPromiseResponse)(res$, signal);
+                }
+                return res$;
+            }
+            const request = new fetchAPI.Request(input);
+            return handleRequestWithWaitUntil(request, ...maybeCtx);
+        }
+        const res$ = handleRequestWithWaitUntil(input, ...maybeCtx);
+        return (0, utils_js_1.handleAbortSignalAndPromiseResponse)(res$, input.signal);
+    };
+    const genericRequestHandler = (input, ...maybeCtx) => {
+        // If it is a Node request
+        const [initOrCtxOrRes, ...restOfCtx] = maybeCtx;
+        if ((0, utils_js_1.isNodeRequest)(input)) {
+            if (!(0, utils_js_1.isServerResponse)(initOrCtxOrRes)) {
+                throw new TypeError(`Expected ServerResponse, got ${initOrCtxOrRes}`);
+            }
+            return requestListener(input, initOrCtxOrRes, ...restOfCtx);
+        }
+        if ((0, uwebsockets_js_1.isUWSResponse)(input)) {
+            return handleUWS(input, initOrCtxOrRes, ...restOfCtx);
+        }
+        if ((0, utils_js_1.isServerResponse)(initOrCtxOrRes)) {
+            throw new TypeError('Got Node response without Node request');
+        }
+        // Is input a container object over Request?
+        if (isRequestAccessible(input)) {
+            // Is it FetchEvent?
+            if ((0, utils_js_1.isFetchEvent)(input)) {
+                return handleEvent(input, ...maybeCtx);
+            }
+            // In this input is also the context
+            return handleRequestWithWaitUntil(input.request, input, ...maybeCtx);
+        }
+        // Or is it Request itself?
+        // Then ctx is present and it is the context
+        return fetchFn(input, ...maybeCtx);
+    };
+    const adapterObj = {
+        handleRequest: handleRequestWithWaitUntil,
+        fetch: fetchFn,
+        handleNodeRequest,
+        handleNodeRequestAndResponse,
+        requestListener,
+        handleEvent,
+        handleUWS,
+        handle: genericRequestHandler,
+        get disposableStack() {
+            return ensureDisposableStack();
+        },
+        [disposablestack_1.DisposableSymbols.asyncDispose]() {
+            if (_disposableStack && !_disposableStack.disposed) {
+                return _disposableStack.disposeAsync();
+            }
+            return (0, uwebsockets_js_1.fakePromise)();
+        },
+        dispose() {
+            if (_disposableStack && !_disposableStack.disposed) {
+                return _disposableStack.disposeAsync();
+            }
+            return (0, uwebsockets_js_1.fakePromise)();
+        },
+        waitUntil,
+    };
+    const serverAdapter = new Proxy(genericRequestHandler, {
+        // It should have all the attributes of the handler function and the server instance
+        has: (_, prop) => {
+            return (prop in adapterObj ||
+                prop in genericRequestHandler ||
+                (serverAdapterBaseObject && prop in serverAdapterBaseObject));
+        },
+        get: (_, prop) => {
+            // Somehow Deno and Node 24 don't like bound dispose functions
+            if (globalThis.Deno || prop === Symbol.asyncDispose || prop === Symbol.dispose) {
+                const adapterProp = Reflect.get(adapterObj, prop, adapterObj);
+                if (adapterProp) {
+                    return adapterProp;
+                }
+            }
+            const adapterProp = adapterObj[prop];
+            if (adapterProp) {
+                if (adapterProp.bind) {
+                    return adapterProp.bind(adapterObj);
+                }
+                return adapterProp;
+            }
+            const handleProp = genericRequestHandler[prop];
+            if (handleProp) {
+                if (handleProp.bind) {
+                    return handleProp.bind(genericRequestHandler);
+                }
+                return handleProp;
+            }
+            if (serverAdapterBaseObject) {
+                const serverAdapterBaseObjectProp = serverAdapterBaseObject[prop];
+                if (serverAdapterBaseObjectProp) {
+                    if (serverAdapterBaseObjectProp.bind) {
+                        return function (...args) {
+                            const returnedVal = serverAdapterBaseObject[prop](...args);
+                            if (returnedVal === serverAdapterBaseObject) {
+                                return serverAdapter;
+                            }
+                            return returnedVal;
+                        };
+                    }
+                    return serverAdapterBaseObjectProp;
+                }
+            }
+        },
+        apply(_, __, args) {
+            return genericRequestHandler(...args);
+        },
+    });
+    return serverAdapter;
+}

package/node_modules/@whatwg-node/server/cjs/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DisposableSymbols = exports.Response = void 0;
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./createServerAdapter.js"), exports);
+tslib_1.__exportStar(require("./types.js"), exports);
+tslib_1.__exportStar(require("./utils.js"), exports);
+tslib_1.__exportStar(require("./plugins/types.js"), exports);
+tslib_1.__exportStar(require("./plugins/useCors.js"), exports);
+tslib_1.__exportStar(require("./plugins/useErrorHandling.js"), exports);
+tslib_1.__exportStar(require("./plugins/useContentEncoding.js"), exports);
+tslib_1.__exportStar(require("./uwebsockets.js"), exports);
+var fetch_1 = require("@whatwg-node/fetch");
+Object.defineProperty(exports, "Response", { enumerable: true, get: function () { return fetch_1.Response; } });
+var disposablestack_1 = require("@whatwg-node/disposablestack");
+Object.defineProperty(exports, "DisposableSymbols", { enumerable: true, get: function () { return disposablestack_1.DisposableSymbols; } });
+tslib_1.__exportStar(require("@envelop/instrumentation"), exports);

package/node_modules/@whatwg-node/server/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/node_modules/@whatwg-node/server/cjs/plugins/useContentEncoding.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useContentEncoding = useContentEncoding;
+const utils_js_1 = require("../utils.js");
+const emptyEncodings = ['none', 'identity'];
+function useContentEncoding() {
+    return {
+        onRequest({ request, setRequest, fetchAPI, endResponse }) {
+            const contentEncodingHeader = request.headers.get('content-encoding');
+            if (contentEncodingHeader &&
+                contentEncodingHeader !== 'none' &&
+                contentEncodingHeader !== 'identity' &&
+                request.body) {
+                const contentEncodings = contentEncodingHeader
+                    .split(',')
+                    .filter(encoding => !emptyEncodings.includes(encoding));
+                if (contentEncodings.length) {
+                    if (!contentEncodings.every(encoding => (0, utils_js_1.getSupportedEncodings)(fetchAPI).includes(encoding))) {
+                        endResponse(new fetchAPI.Response(`Unsupported 'Content-Encoding': ${contentEncodingHeader}`, {
+                            status: 415,
+                            statusText: 'Unsupported Media Type',
+                        }));
+                        return;
+                    }
+                    let newBody = request.body;
+                    for (const contentEncoding of contentEncodings) {
+                        newBody = request.body.pipeThrough(new fetchAPI.DecompressionStream(contentEncoding));
+                    }
+                    setRequest(new fetchAPI.Request(request.url, {
+                        body: newBody,
+                        cache: request.cache,
+                        credentials: request.credentials,
+                        headers: request.headers,
+                        integrity: request.integrity,
+                        keepalive: request.keepalive,
+                        method: request.method,
+                        mode: request.mode,
+                        redirect: request.redirect,
+                        referrer: request.referrer,
+                        referrerPolicy: request.referrerPolicy,
+                        signal: request.signal,
+                        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                        // @ts-ignore - not in the TS types yet
+                        duplex: 'half',
+                    }));
+                }
+            }
+        },
+        onResponse({ request, response, setResponse, fetchAPI }) {
+            const acceptEncoding = request.headers.get('accept-encoding');
+            if (acceptEncoding) {
+                const encodings = acceptEncoding.split(',');
+                if (encodings.length && response.body) {
+                    const supportedEncoding = encodings.find(encoding => (0, utils_js_1.getSupportedEncodings)(fetchAPI).includes(encoding));
+                    if (supportedEncoding) {
+                        const compressionStream = new fetchAPI.CompressionStream(supportedEncoding);
+                        const newHeaders = new fetchAPI.Headers(response.headers);
+                        newHeaders.set('content-encoding', supportedEncoding);
+                        newHeaders.delete('content-length');
+                        const compressedBody = response.body.pipeThrough(compressionStream);
+                        const compressedResponse = new fetchAPI.Response(compressedBody, {
+                            status: response.status,
+                            statusText: response.statusText,
+                            headers: newHeaders,
+                        });
+                        utils_js_1.decompressedResponseMap.set(compressedResponse, response);
+                        setResponse(compressedResponse);
+                    }
+                }
+            }
+        },
+    };
+}

package/node_modules/@whatwg-node/server/cjs/plugins/useCors.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCORSHeadersByRequestAndOptions = getCORSHeadersByRequestAndOptions;
+exports.useCORS = useCORS;
+const promise_helpers_1 = require("@whatwg-node/promise-helpers");
+function getCORSHeadersByRequestAndOptions(request, corsOptions) {
+    const currentOrigin = request.headers.get('origin');
+    if (corsOptions === false || currentOrigin == null) {
+        return null;
+    }
+    const headers = {};
+    // If defined origins have '*' or undefined by any means, we should allow all origins
+    if (corsOptions.origin == null ||
+        corsOptions.origin.length === 0 ||
+        corsOptions.origin.includes('*')) {
+        headers['Access-Control-Allow-Origin'] = currentOrigin;
+        // Vary by origin because there are multiple origins
+        headers['Vary'] = 'Origin';
+    }
+    else if (typeof corsOptions.origin === 'string') {
+        // If there is one specific origin is specified, use it directly
+        headers['Access-Control-Allow-Origin'] = corsOptions.origin;
+    }
+    else if (Array.isArray(corsOptions.origin)) {
+        // If there is only one origin defined in the array, consider it as a single one
+        if (corsOptions.origin.length === 1) {
+            headers['Access-Control-Allow-Origin'] = corsOptions.origin[0];
+        }
+        else if (corsOptions.origin.includes(currentOrigin)) {
+            // If origin is available in the headers, use it
+            headers['Access-Control-Allow-Origin'] = currentOrigin;
+            // Vary by origin because there are multiple origins
+            headers['Vary'] = 'Origin';
+        }
+        else {
+            // There is no origin found in the headers, so we should return null
+            headers['Access-Control-Allow-Origin'] = 'null';
+        }
+    }
+    if (corsOptions.methods?.length) {
+        headers['Access-Control-Allow-Methods'] = corsOptions.methods.join(', ');
+    }
+    else {
+        const requestMethod = request.headers.get('access-control-request-method');
+        if (requestMethod) {
+            headers['Access-Control-Allow-Methods'] = requestMethod;
+        }
+    }
+    if (corsOptions.allowedHeaders?.length) {
+        headers['Access-Control-Allow-Headers'] = corsOptions.allowedHeaders.join(', ');
+    }
+    else {
+        const requestHeaders = request.headers.get('access-control-request-headers');
+        if (requestHeaders) {
+            headers['Access-Control-Allow-Headers'] = requestHeaders;
+            if (headers['Vary']) {
+                headers['Vary'] += ', Access-Control-Request-Headers';
+            }
+            else {
+                headers['Vary'] = 'Access-Control-Request-Headers';
+            }
+        }
+    }
+    if (corsOptions.credentials != null) {
+        if (corsOptions.credentials === true) {
+            headers['Access-Control-Allow-Credentials'] = 'true';
+        }
+    }
+    else if (headers['Access-Control-Allow-Origin'] !== '*') {
+        headers['Access-Control-Allow-Credentials'] = 'true';
+    }
+    if (corsOptions.exposedHeaders) {
+        headers['Access-Control-Expose-Headers'] = corsOptions.exposedHeaders.join(', ');
+    }
+    if (corsOptions.maxAge) {
+        headers['Access-Control-Max-Age'] = corsOptions.maxAge.toString();
+    }
+    return headers;
+}
+function getCORSResponseHeaders(request, corsOptionsFactory, serverContext) {
+    return (0, promise_helpers_1.handleMaybePromise)(() => corsOptionsFactory(request, serverContext), corsOptions => getCORSHeadersByRequestAndOptions(request, corsOptions));
+}
+function useCORS(options) {
+    let corsOptionsFactory = () => ({});
+    if (options != null) {
+        if (typeof options === 'function') {
+            corsOptionsFactory = options;
+        }
+        else if (typeof options === 'object') {
+            const corsOptions = {
+                ...options,
+            };
+            corsOptionsFactory = () => corsOptions;
+        }
+        else if (options === false) {
+            corsOptionsFactory = () => false;
+        }
+    }
+    return {
+        onRequest({ request, fetchAPI, endResponse }) {
+            if (request.method.toUpperCase() === 'OPTIONS') {
+                const response = new fetchAPI.Response(null, {
+                    status: 204,
+                    // Safari (and potentially other browsers) need content-length 0,
+                    // for 204 or they just hang waiting for a body
+                    // see: https://github.com/expressjs/cors/blob/master/lib/index.js#L176
+                    headers: {
+                        'Content-Length': '0',
+                    },
+                });
+                endResponse(response);
+            }
+        },
+        onResponse({ request, serverContext, response }) {
+            return (0, promise_helpers_1.handleMaybePromise)(() => getCORSResponseHeaders(request, corsOptionsFactory, serverContext), headers => {
+                if (headers != null) {
+                    for (const headerName in headers) {
+                        response.headers.set(headerName, headers[headerName]);
+                    }
+                }
+            });
+        },
+    };
+}

package/node_modules/@whatwg-node/server/cjs/plugins/useErrorHandling.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HTTPError = void 0;
+exports.createDefaultErrorHandler = createDefaultErrorHandler;
+exports.useErrorHandling = useErrorHandling;
+const fetch_1 = require("@whatwg-node/fetch");
+const promise_helpers_1 = require("@whatwg-node/promise-helpers");
+function createDefaultErrorHandler(ResponseCtor = fetch_1.Response) {
+    return function defaultErrorHandler(e) {
+        if (e.details || e.status || e.headers || e.name === 'HTTPError') {
+            return new ResponseCtor(typeof e.details === 'object' ? JSON.stringify(e.details) : e.message, {
+                status: e.status,
+                headers: e.headers || {},
+            });
+        }
+        console.error(e);
+        return createDefaultErrorResponse(ResponseCtor);
+    };
+}
+function createDefaultErrorResponse(ResponseCtor) {
+    if (ResponseCtor.error) {
+        return ResponseCtor.error();
+    }
+    return new ResponseCtor(null, { status: 500 });
+}
+class HTTPError extends Error {
+    status;
+    message;
+    headers;
+    details;
+    name = 'HTTPError';
+    constructor(status = 500, message, headers = {}, details) {
+        super(message);
+        this.status = status;
+        this.message = message;
+        this.headers = headers;
+        this.details = details;
+        Error.captureStackTrace(this, HTTPError);
+    }
+}
+exports.HTTPError = HTTPError;
+function useErrorHandling(onError) {
+    return {
+        onRequest({ requestHandler, setRequestHandler, fetchAPI }) {
+            const errorHandler = onError || createDefaultErrorHandler(fetchAPI.Response);
+            setRequestHandler(function handlerWithErrorHandling(request, serverContext) {
+                return (0, promise_helpers_1.handleMaybePromise)(() => requestHandler(request, serverContext), response => response, e => errorHandler(e, request, serverContext) ||
+                    createDefaultErrorResponse(fetchAPI.Response));
+            });
+        },
+    };
+}