@comapeo/map-server 1.0.0-pre.0 → 1.0.0-pre.2

package/node_modules/@whatwg-node/node-fetch/esm/WritableStream.js

@@ -0,0 +1,111 @@
+import { once } from 'node:events';
+import { Writable } from 'node:stream';
+import { fakeRejectPromise } from '@whatwg-node/promise-helpers';
+import { endStream, fakePromise, safeWrite } from './utils.js';
+export class PonyfillWritableStream {
+    writable;
+    constructor(underlyingSink) {
+        if (underlyingSink instanceof Writable) {
+            this.writable = underlyingSink;
+        }
+        else if (underlyingSink) {
+            const writable = new Writable({
+                write(chunk, _encoding, callback) {
+                    try {
+                        const result = underlyingSink.write?.(chunk, controller);
+                        if (result instanceof Promise) {
+                            result.then(() => {
+                                callback();
+                            }, err => {
+                                callback(err);
+                            });
+                        }
+                        else {
+                            callback();
+                        }
+                    }
+                    catch (err) {
+                        callback(err);
+                    }
+                },
+                final(callback) {
+                    const result = underlyingSink.close?.();
+                    if (result instanceof Promise) {
+                        result.then(() => {
+                            callback();
+                        }, err => {
+                            callback(err);
+                        });
+                    }
+                    else {
+                        callback();
+                    }
+                },
+            });
+            this.writable = writable;
+            const abortCtrl = new AbortController();
+            const controller = {
+                signal: abortCtrl.signal,
+                error(e) {
+                    writable.destroy(e);
+                },
+            };
+            writable.once('error', err => abortCtrl.abort(err));
+            writable.once('close', () => abortCtrl.abort());
+        }
+        else {
+            this.writable = new Writable();
+        }
+    }
+    getWriter() {
+        const writable = this.writable;
+        return {
+            get closed() {
+                return once(writable, 'close');
+            },
+            get desiredSize() {
+                return writable.writableLength;
+            },
+            get ready() {
+                return once(writable, 'drain');
+            },
+            releaseLock() {
+                // no-op
+            },
+            write(chunk) {
+                const promise = fakePromise();
+                if (chunk == null) {
+                    return promise;
+                }
+                return promise.then(() => safeWrite(chunk, writable));
+            },
+            close() {
+                if (!writable.errored && writable.closed) {
+                    return fakePromise();
+                }
+                if (writable.errored) {
+                    return fakeRejectPromise(writable.errored);
+                }
+                return fakePromise().then(() => endStream(writable));
+            },
+            abort(reason) {
+                writable.destroy(reason);
+                return once(writable, 'close');
+            },
+        };
+    }
+    close() {
+        if (!this.writable.errored && this.writable.closed) {
+            return fakePromise();
+        }
+        if (this.writable.errored) {
+            return fakeRejectPromise(this.writable.errored);
+        }
+        return fakePromise().then(() => endStream(this.writable));
+    }
+    abort(reason) {
+        this.writable.destroy(reason);
+        return once(this.writable, 'close');
+    }
+    locked = false;
+}

package/node_modules/@whatwg-node/node-fetch/esm/fetch.js

@@ -0,0 +1,104 @@
+import { Buffer } from 'node:buffer';
+import { createReadStream, promises as fsPromises } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { fetchCurl } from './fetchCurl.js';
+import { fetchNodeHttp } from './fetchNodeHttp.js';
+import { PonyfillRequest } from './Request.js';
+import { PonyfillResponse } from './Response.js';
+import { PonyfillURL } from './URL.js';
+import { fakePromise } from './utils.js';
+const BASE64_SUFFIX = ';base64';
+async function getResponseForFile(url) {
+    const path = fileURLToPath(url);
+    try {
+        await fsPromises.access(path, fsPromises.constants.R_OK);
+        const stats = await fsPromises.stat(path, {
+            bigint: true,
+        });
+        const readable = createReadStream(path);
+        return new PonyfillResponse(readable, {
+            status: 200,
+            statusText: 'OK',
+            headers: {
+                'content-type': 'application/octet-stream',
+                'last-modified': stats.mtime.toUTCString(),
+            },
+        });
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            return new PonyfillResponse(null, {
+                status: 404,
+                statusText: 'Not Found',
+            });
+        }
+        else if (err.code === 'EACCES') {
+            return new PonyfillResponse(null, {
+                status: 403,
+                statusText: 'Forbidden',
+            });
+        }
+        throw err;
+    }
+}
+function getResponseForDataUri(url) {
+    const [mimeType = 'text/plain', ...datas] = url.substring(5).split(',');
+    const data = decodeURIComponent(datas.join(','));
+    if (mimeType.endsWith(BASE64_SUFFIX)) {
+        const buffer = Buffer.from(data, 'base64url');
+        const realMimeType = mimeType.slice(0, -BASE64_SUFFIX.length);
+        return new PonyfillResponse(buffer, {
+            status: 200,
+            statusText: 'OK',
+            headers: {
+                'content-type': realMimeType,
+            },
+        });
+    }
+    return new PonyfillResponse(data, {
+        status: 200,
+        statusText: 'OK',
+        headers: {
+            'content-type': mimeType,
+        },
+    });
+}
+function getResponseForBlob(url) {
+    const blob = PonyfillURL.getBlobFromURL(url);
+    if (!blob) {
+        throw new TypeError('Invalid Blob URL');
+    }
+    return new PonyfillResponse(blob, {
+        status: 200,
+        headers: {
+            'content-type': blob.type,
+            'content-length': blob.size.toString(),
+        },
+    });
+}
+function isURL(obj) {
+    return obj != null && obj.href != null;
+}
+export function fetchPonyfill(info, init) {
+    if (typeof info === 'string' || isURL(info)) {
+        const ponyfillRequest = new PonyfillRequest(info, init);
+        return fetchPonyfill(ponyfillRequest);
+    }
+    const fetchRequest = info;
+    if (fetchRequest.url.startsWith('data:')) {
+        const response = getResponseForDataUri(fetchRequest.url);
+        return fakePromise(response);
+    }
+    if (fetchRequest.url.startsWith('file:')) {
+        const response = getResponseForFile(fetchRequest.url);
+        return response;
+    }
+    if (fetchRequest.url.startsWith('blob:')) {
+        const response = getResponseForBlob(fetchRequest.url);
+        return fakePromise(response);
+    }
+    if (globalThis.libcurl && !fetchRequest.agent) {
+        return fetchCurl(fetchRequest);
+    }
+    return fetchNodeHttp(fetchRequest);
+}

package/node_modules/@whatwg-node/node-fetch/esm/fetchCurl.js

@@ -0,0 +1,139 @@
+import { PassThrough, Readable } from 'node:stream';
+import { rootCertificates } from 'node:tls';
+import { createDeferredPromise } from '@whatwg-node/promise-helpers';
+import { PonyfillResponse } from './Response.js';
+import { defaultHeadersSerializer, isNodeReadable, shouldRedirect } from './utils.js';
+export function fetchCurl(fetchRequest) {
+    const { Curl, CurlFeature, CurlPause, CurlProgressFunc } = globalThis['libcurl'];
+    const curlHandle = new Curl();
+    curlHandle.enable(CurlFeature.NoDataParsing);
+    curlHandle.setOpt('URL', fetchRequest.url);
+    if (process.env.NODE_TLS_REJECT_UNAUTHORIZED === '0') {
+        curlHandle.setOpt('SSL_VERIFYPEER', false);
+    }
+    if (process.env.NODE_EXTRA_CA_CERTS) {
+        curlHandle.setOpt('CAINFO', process.env.NODE_EXTRA_CA_CERTS);
+    }
+    else {
+        curlHandle.setOpt('CAINFO_BLOB', rootCertificates.join('\n'));
+    }
+    curlHandle.enable(CurlFeature.StreamResponse);
+    let signal;
+    if (fetchRequest._signal === null) {
+        signal = undefined;
+    }
+    else if (fetchRequest._signal) {
+        signal = fetchRequest._signal;
+    }
+    curlHandle.setStreamProgressCallback(function () {
+        return signal?.aborted ? (process.env.DEBUG ? CurlProgressFunc.Continue : 1) : 0;
+    });
+    if (fetchRequest['bodyType'] === 'String') {
+        curlHandle.setOpt('POSTFIELDS', fetchRequest['bodyInit']);
+    }
+    else {
+        const nodeReadable = (fetchRequest.body != null
+            ? isNodeReadable(fetchRequest.body)
+                ? fetchRequest.body
+                : Readable.from(fetchRequest.body)
+            : null);
+        if (nodeReadable) {
+            curlHandle.setOpt('UPLOAD', true);
+            curlHandle.setUploadStream(nodeReadable);
+        }
+    }
+    if (process.env.DEBUG) {
+        curlHandle.setOpt('VERBOSE', true);
+    }
+    curlHandle.setOpt('TRANSFER_ENCODING', false);
+    curlHandle.setOpt('HTTP_TRANSFER_DECODING', true);
+    curlHandle.setOpt('FOLLOWLOCATION', fetchRequest.redirect === 'follow');
+    curlHandle.setOpt('MAXREDIRS', 20);
+    curlHandle.setOpt('ACCEPT_ENCODING', '');
+    curlHandle.setOpt('CUSTOMREQUEST', fetchRequest.method);
+    const headersSerializer = fetchRequest.headersSerializer || defaultHeadersSerializer;
+    let size;
+    const curlHeaders = headersSerializer(fetchRequest.headers, value => {
+        size = Number(value);
+    });
+    if (size != null) {
+        curlHandle.setOpt('INFILESIZE', size);
+    }
+    curlHandle.setOpt('HTTPHEADER', curlHeaders);
+    curlHandle.enable(CurlFeature.NoHeaderParsing);
+    const deferredPromise = createDeferredPromise();
+    let streamResolved;
+    function onAbort() {
+        if (curlHandle.isOpen) {
+            try {
+                curlHandle.pause(CurlPause.Recv);
+            }
+            catch (e) {
+                deferredPromise.reject(e);
+            }
+        }
+    }
+    signal?.addEventListener('abort', onAbort, { once: true });
+    curlHandle.once('end', function endListener() {
+        try {
+            curlHandle.close();
+        }
+        catch (e) {
+            deferredPromise.reject(e);
+        }
+        signal?.removeEventListener('abort', onAbort);
+    });
+    curlHandle.once('error', function errorListener(error) {
+        if (streamResolved && !streamResolved.closed && !streamResolved.destroyed) {
+            streamResolved.destroy(error);
+        }
+        else {
+            if (error.message === 'Operation was aborted by an application callback') {
+                error.message = 'The operation was aborted.';
+            }
+            deferredPromise.reject(error);
+        }
+        try {
+            curlHandle.close();
+        }
+        catch (e) {
+            deferredPromise.reject(e);
+        }
+    });
+    curlHandle.once('stream', function streamListener(stream, status, headersBuf) {
+        const outputStream = stream.pipe(new PassThrough(), {
+            end: true,
+        });
+        const headersFlat = headersBuf
+            .toString('utf8')
+            .split(/\r?\n|\r/g)
+            .filter(headerFilter => {
+            if (headerFilter && !headerFilter.startsWith('HTTP/')) {
+                if (fetchRequest.redirect === 'error' &&
+                    headerFilter.toLowerCase().includes('location') &&
+                    shouldRedirect(status)) {
+                    if (!stream.destroyed) {
+                        stream.resume();
+                    }
+                    outputStream.destroy();
+                    deferredPromise.reject(new Error('redirect is not allowed'));
+                }
+                return true;
+            }
+            return false;
+        });
+        const headersInit = headersFlat.map(headerFlat => headerFlat.split(/:\s(.+)/).slice(0, 2));
+        const ponyfillResponse = new PonyfillResponse(outputStream, {
+            status,
+            headers: headersInit,
+            url: curlHandle.getInfo(Curl.info.REDIRECT_URL)?.toString() || fetchRequest.url,
+            redirected: Number(curlHandle.getInfo(Curl.info.REDIRECT_COUNT)) > 0,
+        });
+        deferredPromise.resolve(ponyfillResponse);
+        streamResolved = outputStream;
+    });
+    setImmediate(() => {
+        curlHandle.perform();
+    });
+    return deferredPromise.promise;
+}

package/node_modules/@whatwg-node/node-fetch/esm/fetchNodeHttp.js

@@ -0,0 +1,148 @@
+import { request as httpRequest, STATUS_CODES } from 'node:http';
+import { request as httpsRequest } from 'node:https';
+import { PassThrough, Readable } from 'node:stream';
+import zlib from 'node:zlib';
+import { handleMaybePromise } from '@whatwg-node/promise-helpers';
+import { PonyfillRequest } from './Request.js';
+import { PonyfillResponse } from './Response.js';
+import { PonyfillURL } from './URL.js';
+import { DEFAULT_ACCEPT_ENCODING, endStream, getHeadersObj, isNodeReadable, pipeThrough, safeWrite, shouldRedirect, } from './utils.js';
+function getRequestFnForProtocol(url) {
+    if (url.startsWith('http:')) {
+        return httpRequest;
+    }
+    else if (url.startsWith('https:')) {
+        return httpsRequest;
+    }
+    throw new Error(`Unsupported protocol: ${url.split(':')[0] || url}`);
+}
+export function fetchNodeHttp(fetchRequest) {
+    return new Promise((resolve, reject) => {
+        try {
+            const requestFn = getRequestFnForProtocol(fetchRequest.parsedUrl?.protocol || fetchRequest.url);
+            const headersSerializer = fetchRequest.headersSerializer || getHeadersObj;
+            const nodeHeaders = headersSerializer(fetchRequest.headers);
+            nodeHeaders['accept-encoding'] ||= DEFAULT_ACCEPT_ENCODING;
+            if (nodeHeaders['user-agent'] == null && nodeHeaders['User-Agent'] == null) {
+                nodeHeaders['user-agent'] = 'node';
+            }
+            let signal;
+            if (fetchRequest._signal == null) {
+                signal = undefined;
+            }
+            else if (fetchRequest._signal) {
+                signal = fetchRequest._signal;
+            }
+            let nodeRequest;
+            // If it is our ponyfilled Request, it should have `parsedUrl` which is a `URL` object
+            if (fetchRequest.parsedUrl) {
+                nodeRequest = requestFn(fetchRequest.parsedUrl, {
+                    method: fetchRequest.method,
+                    headers: nodeHeaders,
+                    signal,
+                    agent: fetchRequest.agent,
+                });
+            }
+            else {
+                nodeRequest = requestFn(fetchRequest.url, {
+                    method: fetchRequest.method,
+                    headers: nodeHeaders,
+                    signal,
+                    agent: fetchRequest.agent,
+                });
+            }
+            nodeRequest.once('error', reject);
+            nodeRequest.once('response', nodeResponse => {
+                let outputStream;
+                const contentEncoding = nodeResponse.headers['content-encoding'];
+                switch (contentEncoding) {
+                    case 'x-gzip':
+                    case 'gzip':
+                        outputStream = zlib.createGunzip();
+                        break;
+                    case 'x-deflate':
+                    case 'deflate':
+                        outputStream = zlib.createInflate();
+                        break;
+                    case 'x-deflate-raw':
+                    case 'deflate-raw':
+                        outputStream = zlib.createInflateRaw();
+                        break;
+                    case 'br':
+                        outputStream = zlib.createBrotliDecompress();
+                        break;
+                    case 'zstd':
+                        if (zlib.createZstdDecompress != null) {
+                            outputStream = zlib.createZstdDecompress();
+                        }
+                        break;
+                }
+                if (nodeResponse.headers.location && shouldRedirect(nodeResponse.statusCode)) {
+                    if (fetchRequest.redirect === 'error') {
+                        const redirectError = new Error('Redirects are not allowed');
+                        reject(redirectError);
+                        nodeResponse.resume();
+                        return;
+                    }
+                    if (fetchRequest.redirect === 'follow') {
+                        const redirectedUrl = new PonyfillURL(nodeResponse.headers.location, fetchRequest.parsedUrl || fetchRequest.url);
+                        const redirectResponse$ = fetchNodeHttp(new PonyfillRequest(redirectedUrl, fetchRequest));
+                        resolve(redirectResponse$.then(redirectResponse => {
+                            redirectResponse.redirected = true;
+                            return redirectResponse;
+                        }));
+                        nodeResponse.resume();
+                        return;
+                    }
+                }
+                outputStream ||= new PassThrough();
+                pipeThrough({
+                    src: nodeResponse,
+                    dest: outputStream,
+                    signal,
+                    onError: e => {
+                        if (!nodeResponse.destroyed) {
+                            nodeResponse.destroy(e);
+                        }
+                        if (!outputStream.destroyed) {
+                            outputStream.destroy(e);
+                        }
+                        reject(e);
+                    },
+                });
+                const statusCode = nodeResponse.statusCode || 200;
+                let statusText = nodeResponse.statusMessage || STATUS_CODES[statusCode];
+                if (statusText == null) {
+                    statusText = '';
+                }
+                const ponyfillResponse = new PonyfillResponse(outputStream || nodeResponse, {
+                    status: statusCode,
+                    statusText,
+                    headers: nodeResponse.headers,
+                    url: fetchRequest.url,
+                    signal,
+                });
+                resolve(ponyfillResponse);
+            });
+            if (fetchRequest['_buffer'] != null) {
+                handleMaybePromise(() => safeWrite(fetchRequest['_buffer'], nodeRequest), () => endStream(nodeRequest), reject);
+            }
+            else {
+                const nodeReadable = (fetchRequest.body != null
+                    ? isNodeReadable(fetchRequest.body)
+                        ? fetchRequest.body
+                        : Readable.from(fetchRequest.body)
+                    : null);
+                if (nodeReadable) {
+                    nodeReadable.pipe(nodeRequest);
+                }
+                else {
+                    endStream(nodeRequest);
+                }
+            }
+        }
+        catch (e) {
+            reject(e);
+        }
+    });
+}

package/node_modules/@whatwg-node/node-fetch/esm/index.js

@@ -0,0 +1,18 @@
+export { fetchPonyfill as fetch } from './fetch.js';
+export { PonyfillHeaders as Headers } from './Headers.js';
+export { PonyfillBody as Body } from './Body.js';
+export { PonyfillRequest as Request } from './Request.js';
+export { PonyfillResponse as Response, } from './Response.js';
+export { PonyfillReadableStream as ReadableStream } from './ReadableStream.js';
+export { PonyfillFile as File } from './File.js';
+export { PonyfillFormData as FormData } from './FormData.js';
+export { PonyfillBlob as Blob } from './Blob.js';
+export { PonyfillTextEncoder as TextEncoder, PonyfillTextDecoder as TextDecoder, PonyfillBtoa as btoa, } from './TextEncoderDecoder.js';
+export { PonyfillURL as URL } from './URL.js';
+export { PonyfillURLSearchParams as URLSearchParams } from './URLSearchParams.js';
+export { PonyfillWritableStream as WritableStream } from './WritableStream.js';
+export { PonyfillTransformStream as TransformStream } from './TransformStream.js';
+export { PonyfillCompressionStream as CompressionStream } from './CompressionStream.js';
+export { PonyfillDecompressionStream as DecompressionStream } from './DecompressionStream.js';
+export { PonyfillIteratorObject as IteratorObject } from './IteratorObject.js';
+export { PonyfillTextDecoderStream as TextDecoderStream, PonyfillTextEncoderStream as TextEncoderStream, } from './TextEncoderDecoderStream.js';

package/node_modules/@whatwg-node/node-fetch/esm/utils.js

@@ -0,0 +1,110 @@
+import { once } from 'node:events';
+import zlib from 'node:zlib';
+function isHeadersInstance(obj) {
+    return obj?.forEach != null;
+}
+export function getHeadersObj(headers) {
+    if (headers == null || !isHeadersInstance(headers)) {
+        return headers;
+    }
+    // @ts-expect-error - `headersInit` is not a public property
+    if (headers.headersInit && !headers._map && !isHeadersInstance(headers.headersInit)) {
+        // @ts-expect-error - `headersInit` is not a public property
+        return headers.headersInit;
+    }
+    return Object.fromEntries(headers.entries());
+}
+export function defaultHeadersSerializer(headers, onContentLength) {
+    const headerArray = [];
+    headers.forEach((value, key) => {
+        if (onContentLength && key === 'content-length') {
+            onContentLength(value);
+        }
+        headerArray.push(`${key}: ${value}`);
+    });
+    return headerArray;
+}
+export { fakePromise } from '@whatwg-node/promise-helpers';
+export function isArrayBufferView(obj) {
+    return obj != null && obj.buffer != null && obj.byteLength != null && obj.byteOffset != null;
+}
+export function isNodeReadable(obj) {
+    return obj != null && obj.pipe != null;
+}
+export function isIterable(value) {
+    return value?.[Symbol.iterator] != null;
+}
+export function shouldRedirect(status) {
+    return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
+}
+export function pipeThrough({ src, dest, signal, onError, }) {
+    if (onError) {
+        // listen for errors on the destination stream if necessary. if the readable
+        // stream (src) emits an error, the writable destination (dest) will be
+        // destroyed with that error (see below)
+        dest.once('error', onError);
+    }
+    src.once('error', (e) => {
+        // if the readable stream (src) emits an error during pipe, the writable
+        // destination (dest) is not closed automatically. that needs to be
+        // done manually. the readable stream is closed when error is emitted,
+        // so only the writable destination needs to be destroyed
+        dest.destroy(e);
+    });
+    dest.once('close', () => {
+        // if the writable destination (dest) is closed, the readable stream (src)
+        // is not closed automatically. that needs to be done manually
+        if (!src.destroyed) {
+            src.destroy();
+        }
+    });
+    if (signal) {
+        // this is faster than `import('node:signal').addAbortSignal(signal, src)`
+        const srcRef = new WeakRef(src);
+        const signalRef = new WeakRef(signal);
+        function cleanup() {
+            signalRef.deref()?.removeEventListener('abort', onAbort);
+            srcRef.deref()?.removeListener('end', cleanup);
+            srcRef.deref()?.removeListener('error', cleanup);
+            srcRef.deref()?.removeListener('close', cleanup);
+        }
+        function onAbort() {
+            srcRef.deref()?.destroy(new AbortError());
+            cleanup();
+        }
+        signal.addEventListener('abort', onAbort, { once: true });
+        // this is faster than `import('node:signal').finished(src, cleanup)`
+        src.once('end', cleanup);
+        src.once('error', cleanup);
+        src.once('close', cleanup);
+    }
+    src.pipe(dest, { end: true /* already default */ });
+}
+export function endStream(stream) {
+    // @ts-expect-error Avoid arguments adaptor trampoline https://v8.dev/blog/adaptor-frame
+    return stream.end(null, null, null);
+}
+export function safeWrite(chunk, stream) {
+    const result = stream.write(chunk);
+    if (!result) {
+        return once(stream, 'drain');
+    }
+}
+// https://github.com/nodejs/node/blob/f692878dec6354c0a82241f224906981861bc840/lib/internal/errors.js#L961-L973
+class AbortError extends Error {
+    constructor(message = 'The operation was aborted', options = undefined) {
+        super(message, options);
+        this.name = 'AbortError';
+    }
+}
+export const DEFAULT_ACCEPT_ENCODING = getSupportedFormats().join(', ');
+export function getSupportedFormats() {
+    const baseFormats = ['gzip', 'deflate', 'br'];
+    if (!globalThis.process?.versions?.node?.startsWith('2')) {
+        baseFormats.push('deflate-raw');
+    }
+    if (zlib.createZstdCompress != null) {
+        baseFormats.push('zstd');
+    }
+    return baseFormats;
+}

package/node_modules/@whatwg-node/node-fetch/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@whatwg-node/node-fetch",
+  "version": "0.8.4",
+  "description": "Fetch API implementation for Node",
+  "sideEffects": false,
+  "dependencies": {
+    "@fastify/busboy": "^3.1.1",
+    "@whatwg-node/disposablestack": "^0.0.6",
+    "@whatwg-node/promise-helpers": "^1.3.2",
+    "tslib": "^2.6.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "ardatan/whatwg-node",
+    "directory": "packages/node-fetch"
+  },
+  "author": "Arda TANRIKULU <ardatanrikulu@gmail.com>",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
+  "typescript": {
+    "definition": "typings/index.d.ts"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./typings/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  }
+}

package/node_modules/@whatwg-node/node-fetch/typings/AbortError.d.cts

@@ -0,0 +1,4 @@
+export declare class PonyfillAbortError extends Error {
+    constructor(reason?: any);
+    get reason(): unknown;
+}