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

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

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PonyfillWritableStream = void 0;
+const node_events_1 = require("node:events");
+const node_stream_1 = require("node:stream");
+const promise_helpers_1 = require("@whatwg-node/promise-helpers");
+const utils_js_1 = require("./utils.js");
+class PonyfillWritableStream {
+    writable;
+    constructor(underlyingSink) {
+        if (underlyingSink instanceof node_stream_1.Writable) {
+            this.writable = underlyingSink;
+        }
+        else if (underlyingSink) {
+            const writable = new node_stream_1.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 node_stream_1.Writable();
+        }
+    }
+    getWriter() {
+        const writable = this.writable;
+        return {
+            get closed() {
+                return (0, node_events_1.once)(writable, 'close');
+            },
+            get desiredSize() {
+                return writable.writableLength;
+            },
+            get ready() {
+                return (0, node_events_1.once)(writable, 'drain');
+            },
+            releaseLock() {
+                // no-op
+            },
+            write(chunk) {
+                const promise = (0, utils_js_1.fakePromise)();
+                if (chunk == null) {
+                    return promise;
+                }
+                return promise.then(() => (0, utils_js_1.safeWrite)(chunk, writable));
+            },
+            close() {
+                if (!writable.errored && writable.closed) {
+                    return (0, utils_js_1.fakePromise)();
+                }
+                if (writable.errored) {
+                    return (0, promise_helpers_1.fakeRejectPromise)(writable.errored);
+                }
+                return (0, utils_js_1.fakePromise)().then(() => (0, utils_js_1.endStream)(writable));
+            },
+            abort(reason) {
+                writable.destroy(reason);
+                return (0, node_events_1.once)(writable, 'close');
+            },
+        };
+    }
+    close() {
+        if (!this.writable.errored && this.writable.closed) {
+            return (0, utils_js_1.fakePromise)();
+        }
+        if (this.writable.errored) {
+            return (0, promise_helpers_1.fakeRejectPromise)(this.writable.errored);
+        }
+        return (0, utils_js_1.fakePromise)().then(() => (0, utils_js_1.endStream)(this.writable));
+    }
+    abort(reason) {
+        this.writable.destroy(reason);
+        return (0, node_events_1.once)(this.writable, 'close');
+    }
+    locked = false;
+}
+exports.PonyfillWritableStream = PonyfillWritableStream;

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

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchPonyfill = fetchPonyfill;
+const node_buffer_1 = require("node:buffer");
+const node_fs_1 = require("node:fs");
+const node_url_1 = require("node:url");
+const fetchCurl_js_1 = require("./fetchCurl.js");
+const fetchNodeHttp_js_1 = require("./fetchNodeHttp.js");
+const Request_js_1 = require("./Request.js");
+const Response_js_1 = require("./Response.js");
+const URL_js_1 = require("./URL.js");
+const utils_js_1 = require("./utils.js");
+const BASE64_SUFFIX = ';base64';
+async function getResponseForFile(url) {
+    const path = (0, node_url_1.fileURLToPath)(url);
+    try {
+        await node_fs_1.promises.access(path, node_fs_1.promises.constants.R_OK);
+        const stats = await node_fs_1.promises.stat(path, {
+            bigint: true,
+        });
+        const readable = (0, node_fs_1.createReadStream)(path);
+        return new Response_js_1.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 Response_js_1.PonyfillResponse(null, {
+                status: 404,
+                statusText: 'Not Found',
+            });
+        }
+        else if (err.code === 'EACCES') {
+            return new Response_js_1.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 = node_buffer_1.Buffer.from(data, 'base64url');
+        const realMimeType = mimeType.slice(0, -BASE64_SUFFIX.length);
+        return new Response_js_1.PonyfillResponse(buffer, {
+            status: 200,
+            statusText: 'OK',
+            headers: {
+                'content-type': realMimeType,
+            },
+        });
+    }
+    return new Response_js_1.PonyfillResponse(data, {
+        status: 200,
+        statusText: 'OK',
+        headers: {
+            'content-type': mimeType,
+        },
+    });
+}
+function getResponseForBlob(url) {
+    const blob = URL_js_1.PonyfillURL.getBlobFromURL(url);
+    if (!blob) {
+        throw new TypeError('Invalid Blob URL');
+    }
+    return new Response_js_1.PonyfillResponse(blob, {
+        status: 200,
+        headers: {
+            'content-type': blob.type,
+            'content-length': blob.size.toString(),
+        },
+    });
+}
+function isURL(obj) {
+    return obj != null && obj.href != null;
+}
+function fetchPonyfill(info, init) {
+    if (typeof info === 'string' || isURL(info)) {
+        const ponyfillRequest = new Request_js_1.PonyfillRequest(info, init);
+        return fetchPonyfill(ponyfillRequest);
+    }
+    const fetchRequest = info;
+    if (fetchRequest.url.startsWith('data:')) {
+        const response = getResponseForDataUri(fetchRequest.url);
+        return (0, utils_js_1.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 (0, utils_js_1.fakePromise)(response);
+    }
+    if (globalThis.libcurl && !fetchRequest.agent) {
+        return (0, fetchCurl_js_1.fetchCurl)(fetchRequest);
+    }
+    return (0, fetchNodeHttp_js_1.fetchNodeHttp)(fetchRequest);
+}

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

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchCurl = fetchCurl;
+const node_stream_1 = require("node:stream");
+const node_tls_1 = require("node:tls");
+const promise_helpers_1 = require("@whatwg-node/promise-helpers");
+const Response_js_1 = require("./Response.js");
+const utils_js_1 = require("./utils.js");
+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', node_tls_1.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
+            ? (0, utils_js_1.isNodeReadable)(fetchRequest.body)
+                ? fetchRequest.body
+                : node_stream_1.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 || utils_js_1.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 = (0, promise_helpers_1.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 node_stream_1.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') &&
+                    (0, utils_js_1.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 Response_js_1.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/cjs/fetchNodeHttp.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchNodeHttp = fetchNodeHttp;
+const tslib_1 = require("tslib");
+const node_http_1 = require("node:http");
+const node_https_1 = require("node:https");
+const node_stream_1 = require("node:stream");
+const node_zlib_1 = tslib_1.__importDefault(require("node:zlib"));
+const promise_helpers_1 = require("@whatwg-node/promise-helpers");
+const Request_js_1 = require("./Request.js");
+const Response_js_1 = require("./Response.js");
+const URL_js_1 = require("./URL.js");
+const utils_js_1 = require("./utils.js");
+function getRequestFnForProtocol(url) {
+    if (url.startsWith('http:')) {
+        return node_http_1.request;
+    }
+    else if (url.startsWith('https:')) {
+        return node_https_1.request;
+    }
+    throw new Error(`Unsupported protocol: ${url.split(':')[0] || url}`);
+}
+function fetchNodeHttp(fetchRequest) {
+    return new Promise((resolve, reject) => {
+        try {
+            const requestFn = getRequestFnForProtocol(fetchRequest.parsedUrl?.protocol || fetchRequest.url);
+            const headersSerializer = fetchRequest.headersSerializer || utils_js_1.getHeadersObj;
+            const nodeHeaders = headersSerializer(fetchRequest.headers);
+            nodeHeaders['accept-encoding'] ||= utils_js_1.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 = node_zlib_1.default.createGunzip();
+                        break;
+                    case 'x-deflate':
+                    case 'deflate':
+                        outputStream = node_zlib_1.default.createInflate();
+                        break;
+                    case 'x-deflate-raw':
+                    case 'deflate-raw':
+                        outputStream = node_zlib_1.default.createInflateRaw();
+                        break;
+                    case 'br':
+                        outputStream = node_zlib_1.default.createBrotliDecompress();
+                        break;
+                    case 'zstd':
+                        if (node_zlib_1.default.createZstdDecompress != null) {
+                            outputStream = node_zlib_1.default.createZstdDecompress();
+                        }
+                        break;
+                }
+                if (nodeResponse.headers.location && (0, utils_js_1.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 URL_js_1.PonyfillURL(nodeResponse.headers.location, fetchRequest.parsedUrl || fetchRequest.url);
+                        const redirectResponse$ = fetchNodeHttp(new Request_js_1.PonyfillRequest(redirectedUrl, fetchRequest));
+                        resolve(redirectResponse$.then(redirectResponse => {
+                            redirectResponse.redirected = true;
+                            return redirectResponse;
+                        }));
+                        nodeResponse.resume();
+                        return;
+                    }
+                }
+                outputStream ||= new node_stream_1.PassThrough();
+                (0, utils_js_1.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 || node_http_1.STATUS_CODES[statusCode];
+                if (statusText == null) {
+                    statusText = '';
+                }
+                const ponyfillResponse = new Response_js_1.PonyfillResponse(outputStream || nodeResponse, {
+                    status: statusCode,
+                    statusText,
+                    headers: nodeResponse.headers,
+                    url: fetchRequest.url,
+                    signal,
+                });
+                resolve(ponyfillResponse);
+            });
+            if (fetchRequest['_buffer'] != null) {
+                (0, promise_helpers_1.handleMaybePromise)(() => (0, utils_js_1.safeWrite)(fetchRequest['_buffer'], nodeRequest), () => (0, utils_js_1.endStream)(nodeRequest), reject);
+            }
+            else {
+                const nodeReadable = (fetchRequest.body != null
+                    ? (0, utils_js_1.isNodeReadable)(fetchRequest.body)
+                        ? fetchRequest.body
+                        : node_stream_1.Readable.from(fetchRequest.body)
+                    : null);
+                if (nodeReadable) {
+                    nodeReadable.pipe(nodeRequest);
+                }
+                else {
+                    (0, utils_js_1.endStream)(nodeRequest);
+                }
+            }
+        }
+        catch (e) {
+            reject(e);
+        }
+    });
+}

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextEncoderStream = exports.TextDecoderStream = exports.IteratorObject = exports.DecompressionStream = exports.CompressionStream = exports.TransformStream = exports.WritableStream = exports.URLSearchParams = exports.URL = exports.btoa = exports.TextDecoder = exports.TextEncoder = exports.Blob = exports.FormData = exports.File = exports.ReadableStream = exports.Response = exports.Request = exports.Body = exports.Headers = exports.fetch = void 0;
+var fetch_js_1 = require("./fetch.js");
+Object.defineProperty(exports, "fetch", { enumerable: true, get: function () { return fetch_js_1.fetchPonyfill; } });
+var Headers_js_1 = require("./Headers.js");
+Object.defineProperty(exports, "Headers", { enumerable: true, get: function () { return Headers_js_1.PonyfillHeaders; } });
+var Body_js_1 = require("./Body.js");
+Object.defineProperty(exports, "Body", { enumerable: true, get: function () { return Body_js_1.PonyfillBody; } });
+var Request_js_1 = require("./Request.js");
+Object.defineProperty(exports, "Request", { enumerable: true, get: function () { return Request_js_1.PonyfillRequest; } });
+var Response_js_1 = require("./Response.js");
+Object.defineProperty(exports, "Response", { enumerable: true, get: function () { return Response_js_1.PonyfillResponse; } });
+var ReadableStream_js_1 = require("./ReadableStream.js");
+Object.defineProperty(exports, "ReadableStream", { enumerable: true, get: function () { return ReadableStream_js_1.PonyfillReadableStream; } });
+var File_js_1 = require("./File.js");
+Object.defineProperty(exports, "File", { enumerable: true, get: function () { return File_js_1.PonyfillFile; } });
+var FormData_js_1 = require("./FormData.js");
+Object.defineProperty(exports, "FormData", { enumerable: true, get: function () { return FormData_js_1.PonyfillFormData; } });
+var Blob_js_1 = require("./Blob.js");
+Object.defineProperty(exports, "Blob", { enumerable: true, get: function () { return Blob_js_1.PonyfillBlob; } });
+var TextEncoderDecoder_js_1 = require("./TextEncoderDecoder.js");
+Object.defineProperty(exports, "TextEncoder", { enumerable: true, get: function () { return TextEncoderDecoder_js_1.PonyfillTextEncoder; } });
+Object.defineProperty(exports, "TextDecoder", { enumerable: true, get: function () { return TextEncoderDecoder_js_1.PonyfillTextDecoder; } });
+Object.defineProperty(exports, "btoa", { enumerable: true, get: function () { return TextEncoderDecoder_js_1.PonyfillBtoa; } });
+var URL_js_1 = require("./URL.js");
+Object.defineProperty(exports, "URL", { enumerable: true, get: function () { return URL_js_1.PonyfillURL; } });
+var URLSearchParams_js_1 = require("./URLSearchParams.js");
+Object.defineProperty(exports, "URLSearchParams", { enumerable: true, get: function () { return URLSearchParams_js_1.PonyfillURLSearchParams; } });
+var WritableStream_js_1 = require("./WritableStream.js");
+Object.defineProperty(exports, "WritableStream", { enumerable: true, get: function () { return WritableStream_js_1.PonyfillWritableStream; } });
+var TransformStream_js_1 = require("./TransformStream.js");
+Object.defineProperty(exports, "TransformStream", { enumerable: true, get: function () { return TransformStream_js_1.PonyfillTransformStream; } });
+var CompressionStream_js_1 = require("./CompressionStream.js");
+Object.defineProperty(exports, "CompressionStream", { enumerable: true, get: function () { return CompressionStream_js_1.PonyfillCompressionStream; } });
+var DecompressionStream_js_1 = require("./DecompressionStream.js");
+Object.defineProperty(exports, "DecompressionStream", { enumerable: true, get: function () { return DecompressionStream_js_1.PonyfillDecompressionStream; } });
+var IteratorObject_js_1 = require("./IteratorObject.js");
+Object.defineProperty(exports, "IteratorObject", { enumerable: true, get: function () { return IteratorObject_js_1.PonyfillIteratorObject; } });
+var TextEncoderDecoderStream_js_1 = require("./TextEncoderDecoderStream.js");
+Object.defineProperty(exports, "TextDecoderStream", { enumerable: true, get: function () { return TextEncoderDecoderStream_js_1.PonyfillTextDecoderStream; } });
+Object.defineProperty(exports, "TextEncoderStream", { enumerable: true, get: function () { return TextEncoderDecoderStream_js_1.PonyfillTextEncoderStream; } });

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

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