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

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

@@ -0,0 +1,241 @@
+import { Buffer } from 'node:buffer';
+import { once } from 'node:events';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { handleMaybePromise } from '@whatwg-node/promise-helpers';
+import { fakePromise } from './utils.js';
+function createController(desiredSize, readable) {
+    let chunks = [];
+    let _closed = false;
+    let flushed = false;
+    return {
+        desiredSize,
+        enqueue(chunk) {
+            const buf = typeof chunk === 'string' ? Buffer.from(chunk) : chunk;
+            if (!flushed) {
+                chunks.push(buf);
+            }
+            else {
+                readable.push(buf);
+            }
+        },
+        close() {
+            if (chunks.length > 0) {
+                this._flush();
+            }
+            readable.push(null);
+            _closed = true;
+        },
+        error(error) {
+            if (chunks.length > 0) {
+                this._flush();
+            }
+            readable.destroy(error);
+        },
+        get _closed() {
+            return _closed;
+        },
+        _flush() {
+            flushed = true;
+            if (chunks.length > 0) {
+                const concatenated = chunks.length > 1 ? Buffer.concat(chunks) : chunks[0];
+                readable.push(concatenated);
+                chunks = [];
+            }
+        },
+    };
+}
+function isNodeReadable(obj) {
+    return obj?.read != null;
+}
+function isReadableStream(obj) {
+    return obj?.getReader != null;
+}
+export class PonyfillReadableStream {
+    readable;
+    constructor(underlyingSource) {
+        if (underlyingSource instanceof PonyfillReadableStream && underlyingSource.readable != null) {
+            this.readable = underlyingSource.readable;
+        }
+        else if (isNodeReadable(underlyingSource)) {
+            this.readable = underlyingSource;
+        }
+        else if (isReadableStream(underlyingSource)) {
+            this.readable = Readable.fromWeb(underlyingSource);
+        }
+        else {
+            let started = false;
+            let ongoing = false;
+            const handleStart = (desiredSize) => {
+                if (!started) {
+                    const controller = createController(desiredSize, this.readable);
+                    started = true;
+                    return handleMaybePromise(() => underlyingSource?.start?.(controller), () => {
+                        controller._flush();
+                        if (controller._closed) {
+                            return false;
+                        }
+                        return true;
+                    });
+                }
+                return true;
+            };
+            const readImpl = (desiredSize) => {
+                return handleMaybePromise(() => handleStart(desiredSize), shouldContinue => {
+                    if (!shouldContinue) {
+                        return;
+                    }
+                    const controller = createController(desiredSize, this.readable);
+                    return handleMaybePromise(() => underlyingSource?.pull?.(controller), () => {
+                        controller._flush();
+                        ongoing = false;
+                    });
+                });
+            };
+            this.readable = new Readable({
+                read(desiredSize) {
+                    if (ongoing) {
+                        return;
+                    }
+                    ongoing = true;
+                    return readImpl(desiredSize);
+                },
+                destroy(err, callback) {
+                    if (underlyingSource?.cancel) {
+                        try {
+                            const res$ = underlyingSource.cancel(err);
+                            if (res$?.then) {
+                                return res$.then(() => {
+                                    callback(null);
+                                }, err => {
+                                    callback(err);
+                                });
+                            }
+                        }
+                        catch (err) {
+                            callback(err);
+                            return;
+                        }
+                    }
+                    callback(null);
+                },
+            });
+        }
+    }
+    cancel(reason) {
+        this.readable.destroy(reason);
+        // @ts-expect-error - we know it is void
+        return once(this.readable, 'close');
+    }
+    locked = false;
+    getReader(_options) {
+        const iterator = this.readable[Symbol.asyncIterator]();
+        this.locked = true;
+        const thisReadable = this.readable;
+        return {
+            read() {
+                return iterator.next();
+            },
+            releaseLock: () => {
+                if (iterator.return) {
+                    const retResult$ = iterator.return();
+                    if (retResult$.then) {
+                        retResult$.then(() => {
+                            this.locked = false;
+                        });
+                        return;
+                    }
+                }
+                this.locked = false;
+            },
+            cancel: reason => {
+                if (iterator.return) {
+                    const retResult$ = iterator.return(reason);
+                    if (retResult$.then) {
+                        return retResult$.then(() => {
+                            this.locked = false;
+                        });
+                    }
+                }
+                this.locked = false;
+                return fakePromise();
+            },
+            get closed() {
+                return Promise.race([
+                    once(thisReadable, 'end'),
+                    once(thisReadable, 'error').then(err => Promise.reject(err)),
+                ]);
+            },
+        };
+    }
+    [Symbol.asyncIterator]() {
+        const iterator = this.readable[Symbol.asyncIterator]();
+        return {
+            [Symbol.asyncIterator]() {
+                return this;
+            },
+            next: () => iterator.next(),
+            return: () => {
+                if (!this.readable.destroyed) {
+                    this.readable.destroy();
+                }
+                return iterator.return?.() || fakePromise({ done: true, value: undefined });
+            },
+            throw: (err) => {
+                if (!this.readable.destroyed) {
+                    this.readable.destroy(err);
+                }
+                return iterator.throw?.(err) || fakePromise({ done: true, value: undefined });
+            },
+        };
+    }
+    tee() {
+        throw new Error('Not implemented');
+    }
+    async pipeToWriter(writer) {
+        try {
+            for await (const chunk of this) {
+                await writer.write(chunk);
+            }
+            await writer.close();
+        }
+        catch (err) {
+            await writer.abort(err);
+        }
+    }
+    pipeTo(destination) {
+        if (isPonyfillWritableStream(destination)) {
+            return pipeline(this.readable, destination.writable, {
+                end: true,
+            });
+        }
+        else {
+            const writer = destination.getWriter();
+            return this.pipeToWriter(writer);
+        }
+    }
+    pipeThrough({ writable, readable, }) {
+        this.pipeTo(writable).catch(err => {
+            this.readable.destroy(err);
+        });
+        if (isPonyfillReadableStream(readable)) {
+            readable.readable.once('error', err => this.readable.destroy(err));
+            readable.readable.once('finish', () => this.readable.push(null));
+            readable.readable.once('close', () => this.readable.push(null));
+        }
+        return readable;
+    }
+    static [Symbol.hasInstance](instance) {
+        return isReadableStream(instance);
+    }
+    static from(iterable) {
+        return new PonyfillReadableStream(Readable.from(iterable));
+    }
+    [Symbol.toStringTag] = 'ReadableStream';
+}
+function isPonyfillReadableStream(obj) {
+    return obj?.readable != null;
+}
+function isPonyfillWritableStream(obj) {
+    return obj?.writable != null;
+}

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

@@ -0,0 +1,124 @@
+import { Agent as HTTPAgent } from 'node:http';
+import { Agent as HTTPSAgent } from 'node:https';
+import { PonyfillBody } from './Body.js';
+import { isHeadersLike, PonyfillHeaders } from './Headers.js';
+import { PonyfillURL } from './URL.js';
+function isRequest(input) {
+    return input[Symbol.toStringTag] === 'Request';
+}
+function isURL(obj) {
+    return obj?.href != null;
+}
+export class PonyfillRequest extends PonyfillBody {
+    constructor(input, options) {
+        let _url;
+        let _parsedUrl;
+        let bodyInit = null;
+        let requestInit;
+        if (typeof input === 'string') {
+            _url = input;
+        }
+        else if (isURL(input)) {
+            _parsedUrl = input;
+        }
+        else if (isRequest(input)) {
+            if (input._parsedUrl) {
+                _parsedUrl = input._parsedUrl;
+            }
+            else if (input._url) {
+                _url = input._url;
+            }
+            else {
+                _url = input.url;
+            }
+            bodyInit = input.body;
+            requestInit = input;
+        }
+        if (options != null) {
+            bodyInit = options.body || null;
+            requestInit = options;
+        }
+        super(bodyInit, requestInit);
+        this._url = _url;
+        this._parsedUrl = _parsedUrl;
+        this.cache = requestInit?.cache || 'default';
+        this.credentials = requestInit?.credentials || 'same-origin';
+        this.headers =
+            requestInit?.headers && isHeadersLike(requestInit.headers)
+                ? requestInit.headers
+                : new PonyfillHeaders(requestInit?.headers);
+        this.integrity = requestInit?.integrity || '';
+        this.keepalive = requestInit?.keepalive != null ? requestInit?.keepalive : false;
+        this.method = requestInit?.method?.toUpperCase() || 'GET';
+        this.mode = requestInit?.mode || 'cors';
+        this.redirect = requestInit?.redirect || 'follow';
+        this.referrer = requestInit?.referrer || 'about:client';
+        this.referrerPolicy = requestInit?.referrerPolicy || 'no-referrer';
+        this.headersSerializer = requestInit?.headersSerializer;
+        this.duplex = requestInit?.duplex || 'half';
+        this.destination = 'document';
+        this.priority = 'auto';
+        if (this.method !== 'GET' && this.method !== 'HEAD') {
+            this.handleContentLengthHeader(true);
+        }
+        if (requestInit?.agent != null) {
+            const protocol = _parsedUrl?.protocol || _url || this.url;
+            if (requestInit.agent === false) {
+                this.agent = false;
+            }
+            else if (protocol.startsWith('http:') && requestInit.agent instanceof HTTPAgent) {
+                this.agent = requestInit.agent;
+            }
+            else if (protocol.startsWith('https:') && requestInit.agent instanceof HTTPSAgent) {
+                this.agent = requestInit.agent;
+            }
+        }
+    }
+    headersSerializer;
+    cache;
+    credentials;
+    destination;
+    headers;
+    integrity;
+    keepalive;
+    method;
+    mode;
+    priority;
+    redirect;
+    referrer;
+    referrerPolicy;
+    _url;
+    get signal() {
+        this._signal ||= new AbortController().signal;
+        return this._signal;
+    }
+    get url() {
+        if (this._url == null) {
+            if (this._parsedUrl) {
+                this._url = this._parsedUrl.toString();
+            }
+            else {
+                throw new TypeError('Invalid URL');
+            }
+        }
+        return this._url;
+    }
+    _parsedUrl;
+    get parsedUrl() {
+        if (this._parsedUrl == null) {
+            if (this._url != null) {
+                this._parsedUrl = new PonyfillURL(this._url, 'http://localhost');
+            }
+            else {
+                throw new TypeError('Invalid URL');
+            }
+        }
+        return this._parsedUrl;
+    }
+    duplex;
+    agent;
+    clone() {
+        return this;
+    }
+    [Symbol.toStringTag] = 'Request';
+}

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

@@ -0,0 +1,104 @@
+import { STATUS_CODES } from 'node:http';
+import { PonyfillBody } from './Body.js';
+import { isHeadersLike, PonyfillHeaders } from './Headers.js';
+const JSON_CONTENT_TYPE = 'application/json; charset=utf-8';
+export class PonyfillResponse extends PonyfillBody {
+    headers;
+    constructor(body, init) {
+        super(body || null, init);
+        this.headers =
+            init?.headers && isHeadersLike(init.headers)
+                ? init.headers
+                : new PonyfillHeaders(init?.headers);
+        this.status = init?.status || 200;
+        this.statusText = init?.statusText || STATUS_CODES[this.status] || 'OK';
+        this.url = init?.url || '';
+        this.redirected = init?.redirected || false;
+        this.type = init?.type || 'default';
+        this.handleContentLengthHeader();
+    }
+    get ok() {
+        return this.status >= 200 && this.status < 300;
+    }
+    status;
+    statusText;
+    url;
+    redirected;
+    type;
+    clone() {
+        return this;
+    }
+    static error() {
+        return new PonyfillResponse(null, {
+            status: 500,
+            statusText: 'Internal Server Error',
+        });
+    }
+    static redirect(url, status = 302) {
+        if (status < 300 || status > 399) {
+            throw new RangeError('Invalid status code');
+        }
+        return new PonyfillResponse(null, {
+            headers: {
+                location: url,
+            },
+            status,
+        });
+    }
+    static json(data, init) {
+        const bodyInit = JSON.stringify(data);
+        if (!init) {
+            init = {
+                headers: {
+                    'content-type': JSON_CONTENT_TYPE,
+                    'content-length': Buffer.byteLength(bodyInit).toString(),
+                },
+            };
+        }
+        else if (!init.headers) {
+            init.headers = {
+                'content-type': JSON_CONTENT_TYPE,
+                'content-length': Buffer.byteLength(bodyInit).toString(),
+            };
+        }
+        else if (isHeadersLike(init.headers)) {
+            if (!init.headers.has('content-type')) {
+                init.headers.set('content-type', JSON_CONTENT_TYPE);
+            }
+            if (!init.headers.has('content-length')) {
+                init.headers.set('content-length', Buffer.byteLength(bodyInit).toString());
+            }
+        }
+        else if (Array.isArray(init.headers)) {
+            let contentTypeExists = false;
+            let contentLengthExists = false;
+            for (const [key] of init.headers) {
+                if (contentLengthExists && contentTypeExists) {
+                    break;
+                }
+                if (!contentTypeExists && key.toLowerCase() === 'content-type') {
+                    contentTypeExists = true;
+                }
+                else if (!contentLengthExists && key.toLowerCase() === 'content-length') {
+                    contentLengthExists = true;
+                }
+            }
+            if (!contentTypeExists) {
+                init.headers.push(['content-type', JSON_CONTENT_TYPE]);
+            }
+            if (!contentLengthExists) {
+                init.headers.push(['content-length', Buffer.byteLength(bodyInit).toString()]);
+            }
+        }
+        else if (typeof init.headers === 'object') {
+            if (init.headers?.['content-type'] == null) {
+                init.headers['content-type'] = JSON_CONTENT_TYPE;
+            }
+            if (init.headers?.['content-length'] == null) {
+                init.headers['content-length'] = Buffer.byteLength(bodyInit).toString();
+            }
+        }
+        return new PonyfillResponse(bodyInit, init);
+    }
+    [Symbol.toStringTag] = 'Response';
+}

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

@@ -0,0 +1,43 @@
+import { Buffer } from 'node:buffer';
+import { isArrayBufferView } from './utils.js';
+export class PonyfillTextEncoder {
+    encoding;
+    constructor(encoding = 'utf-8') {
+        this.encoding = encoding;
+    }
+    encode(input) {
+        return Buffer.from(input, this.encoding);
+    }
+    encodeInto(source, destination) {
+        const buffer = this.encode(source);
+        const copied = buffer.copy(destination);
+        return {
+            read: copied,
+            written: copied,
+        };
+    }
+}
+export class PonyfillTextDecoder {
+    encoding;
+    fatal = false;
+    ignoreBOM = false;
+    constructor(encoding = 'utf-8', options) {
+        this.encoding = encoding;
+        if (options) {
+            this.fatal = options.fatal || false;
+            this.ignoreBOM = options.ignoreBOM || false;
+        }
+    }
+    decode(input) {
+        if (Buffer.isBuffer(input)) {
+            return input.toString(this.encoding);
+        }
+        if (isArrayBufferView(input)) {
+            return Buffer.from(input.buffer, input.byteOffset, input.byteLength).toString(this.encoding);
+        }
+        return Buffer.from(input).toString(this.encoding);
+    }
+}
+export function PonyfillBtoa(input) {
+    return Buffer.from(input, 'binary').toString('base64');
+}

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

@@ -0,0 +1,35 @@
+import { PonyfillTextDecoder, PonyfillTextEncoder } from './TextEncoderDecoder.js';
+import { PonyfillTransformStream } from './TransformStream.js';
+export class PonyfillTextDecoderStream extends PonyfillTransformStream {
+    textDecoder;
+    constructor(encoding, options) {
+        super({
+            transform: (chunk, controller) => controller.enqueue(this.textDecoder.decode(chunk, { stream: true })),
+        });
+        this.textDecoder = new PonyfillTextDecoder(encoding, options);
+    }
+    get encoding() {
+        return this.textDecoder.encoding;
+    }
+    get fatal() {
+        return this.textDecoder.fatal;
+    }
+    get ignoreBOM() {
+        return this.textDecoder.ignoreBOM;
+    }
+}
+export class PonyfillTextEncoderStream extends PonyfillTransformStream {
+    textEncoder;
+    constructor(encoding) {
+        super({
+            transform: (chunk, controller) => controller.enqueue(this.textEncoder.encode(chunk)),
+        });
+        this.textEncoder = new PonyfillTextEncoder(encoding);
+    }
+    get encoding() {
+        return this.textEncoder.encoding;
+    }
+    encode(input) {
+        return this.textEncoder.encode(input);
+    }
+}

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

@@ -0,0 +1,75 @@
+import { Transform } from 'node:stream';
+import { PonyfillReadableStream } from './ReadableStream.js';
+import { endStream } from './utils.js';
+import { PonyfillWritableStream } from './WritableStream.js';
+export class PonyfillTransformStream {
+    transform;
+    writable;
+    readable;
+    constructor(transformer) {
+        if (transformer instanceof Transform) {
+            this.transform = transformer;
+        }
+        else if (transformer) {
+            const controller = {
+                enqueue(chunk) {
+                    transform.push(chunk);
+                },
+                error(reason) {
+                    transform.destroy(reason);
+                },
+                terminate() {
+                    endStream(transform);
+                },
+                get desiredSize() {
+                    return transform.writableLength;
+                },
+            };
+            const transform = new Transform({
+                read() { },
+                write(chunk, _encoding, callback) {
+                    try {
+                        const result = transformer.transform?.(chunk, controller);
+                        if (result instanceof Promise) {
+                            result.then(() => {
+                                callback();
+                            }, err => {
+                                callback(err);
+                            });
+                        }
+                        else {
+                            callback();
+                        }
+                    }
+                    catch (err) {
+                        callback(err);
+                    }
+                },
+                final(callback) {
+                    try {
+                        const result = transformer.flush?.(controller);
+                        if (result instanceof Promise) {
+                            result.then(() => {
+                                callback();
+                            }, err => {
+                                callback(err);
+                            });
+                        }
+                        else {
+                            callback();
+                        }
+                    }
+                    catch (err) {
+                        callback(err);
+                    }
+                },
+            });
+            this.transform = transform;
+        }
+        else {
+            this.transform = new Transform();
+        }
+        this.writable = new PonyfillWritableStream(this.transform);
+        this.readable = new PonyfillReadableStream(this.transform);
+    }
+}

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

@@ -0,0 +1,24 @@
+import NodeBuffer from 'node:buffer';
+import { randomUUID } from 'node:crypto';
+const NativeURL = globalThis.URL;
+class URL extends NativeURL {
+    // This part is only needed to handle `PonyfillBlob` objects
+    static blobRegistry = new Map();
+    static createObjectURL(blob) {
+        const blobUrl = `blob:whatwgnode:${randomUUID()}`;
+        this.blobRegistry.set(blobUrl, blob);
+        return blobUrl;
+    }
+    static revokeObjectURL(url) {
+        if (!this.blobRegistry.has(url)) {
+            NativeURL.revokeObjectURL(url);
+        }
+        else {
+            this.blobRegistry.delete(url);
+        }
+    }
+    static getBlobFromURL(url) {
+        return (this.blobRegistry.get(url) || NodeBuffer?.resolveObjectURL?.(url));
+    }
+}
+export { URL as PonyfillURL };

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

@@ -0,0 +1 @@
+export const PonyfillURLSearchParams = globalThis.URLSearchParams;