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

package/node_modules/@whatwg-node/fetch/README.md

@@ -0,0 +1,141 @@
+# `@whatwg-node/fetch`
+
+A ponyfill package for the [Fetch Standard](https://fetch.spec.whatwg.org/). If your JavaScript
+environment doesn't implement this standard natively, this package automatically ponyfills the
+missing parts, and export them as a module; otherwise it exports the native ones without touching
+the environment's internals. It also exports some additional standard APIs that are required by the
+Fetch Standard.
+
+## Installation
+
+```bash
+npm install @whatwg-node/fetch
+```
+
+## Why Fetch API and why this ponyfill in general?
+
+If you are building a JavaScript library, and you want it to support all JavaScript environments not
+only Node.js. Fetch API is the best choice for you. Because it's a standard, and it's implemented by
+the most environments out there expect Node.js :). So you can use Fetch API in your library, and
+your users can use it in their browsers, Deno, Bun, Cloudflare Works, and in Node.js.
+
+> This is how we support all JavaScript environments in
+> [GraphQL Yoga](https://the-guild.dev/graphql/yoga-server/docs/integrations/z-other-environments).
+> In GraphQL Yoga, we don't care which JavaScript environment you prefer, we support all of them.
+
+## Why we should still use these for Node.js even if it already implements them natively
+
+Even if newer Node.js already implements Fetch API and Data Text Encoding API natively, we still
+recommend to use this package, because this package implements them for Node.js in more efficient
+way.
+
+- [See problems with the global fetch/undici in Node.js](https://github.com/nodejs/undici/issues/1203)
+- - We offer a patched version of `node-fetch` that doesn't use `undici` and Node.js streams
+    internally, so it's more efficient than the native one.
+- [See problems with text encoding API in Node.js](https://github.com/nodejs/node/issues/39879)
+- - We use [`Buffer`](https://nodejs.org/api/buffer.html) instead of the native one, because
+    `Buffer` is faster than the native one unfortunately.
+- `Body.formData()` is not implemented by Node.js, so we implement it with `busboy` internally. So
+  you can consume incoming multipart(file uploads) requests with `.formData` in Node.js.
+- `fetch` implementation of Node.js uses `undici` and it doesn't support HTTP 2, our implementation
+  supports it natively thanks to `node-libcurl`.
+
+### Faster HTTP Client in Node.js with HTTP/2 support
+
+If you install `node-libcurl` seperately, `@whatwg-node/fetch` will select `libcurl` instead of
+`node:http` which is faster.
+
+[See benchmarks](https://github.com/JCMais/node-libcurl/tree/develop/benchmark#ubuntu-1910-i7-5500u-24ghz---linux-530-42---node-v12162)
+
+### Handling file uploads with Fetch API
+
+```ts
+import { Request } from '@whatwg-node/fetch'
+
+// See how you can handle file uploads with Fetch API
+http.createServer(async (req, res) => {
+  const request = new Request(req)
+  const formData = await request.formData()
+  const file = formData.get('file')
+  // ...
+})
+```
+
+> If you want to limit the size of the multipart form data, you can use `createFetch`. See the
+> [API](#api) section for more details.
+
+## API
+
+The following are exported by this package:
+
+### WHATWG Fetch Standard
+
+- [fetch](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/fetch)
+- [Request](https://developer.mozilla.org/en-US/docs/Web/API/Request)
+- [Response](https://developer.mozilla.org/en-US/docs/Web/API/Response)
+- [Headers](https://developer.mozilla.org/en-US/docs/Web/API/Headers)
+- [FormData](https://developer.mozilla.org/en-US/docs/Web/API/FormData)
+- [AbortController](https://developer.mozilla.org/en-US/docs/Web/API/AbortController)
+
+### Web Streams API
+
+- [ReadableStream](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream)
+- [WritableStream](https://developer.mozilla.org/en-US/docs/Web/API/WritableStream)
+- [TransformStream](https://developer.mozilla.org/en-US/docs/Web/API/TransformStream)
+
+### URL Standard
+
+- [URL](https://developer.mozilla.org/en-US/docs/Web/API/URL)
+- [URLSearchParams](https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams)
+- [URLPattern](https://developer.mozilla.org/en-US/docs/Web/API/URLPattern)
+
+### Data Types
+
+- [Blob](https://developer.mozilla.org/en-US/docs/Web/API/Blob)
+- [File](https://developer.mozilla.org/en-US/docs/Web/API/File)
+
+### Data Encoding/Decoding API
+
+- [TextEncoder](https://developer.mozilla.org/en-US/docs/Web/API/TextEncoder)
+- [TextDecoder](https://developer.mozilla.org/en-US/docs/Web/API/TextDecoder)
+- [btoa](https://developer.mozilla.org/en-US/docs/Web/API/WindowOrWorkerGlobalScope/btoa)
+
+### Web Crypto API
+
+- [crypto](https://developer.mozilla.org/en-US/docs/Web/API/Web_Crypto_API)
+
+### Create variations of the implementation
+
+- `createFetch`
+
+`createFetch` allows you to create an API with some specific flags that are not available in the
+actual API.
+
+#### Limit the multipart form data size
+
+This is useful if you parse the multipart request bodies with `.formData()`.
+
+```ts
+import { createFetch } from '@whatwg-node/fetch'
+
+const fetchAPI = createFetch({
+  formDataLimits: {
+    // Maximum allowed file size (in bytes)
+    fileSize: 1000000,
+    // Maximum allowed number of files
+    files: 10,
+    // Maximum allowed size of content (operations, variables etc...)
+    fieldSize: 1000000,
+    // Maximum allowed header size for form data
+    headerSize: 1000000
+  }
+})
+
+// See how you can handle file uploads with Fetch API
+http.createServer(async (req, res) => {
+  const request = new Request(req)
+  const formData = await request.formData()
+  const file = formData.get('file')
+  // ...
+})
+```

package/node_modules/@whatwg-node/fetch/dist/create-node-ponyfill.js

@@ -0,0 +1,100 @@
+const shouldSkipPonyfill = require('./shouldSkipPonyfill');
+let newNodeFetch;
+
+module.exports = function createNodePonyfill(opts = {}) {
+  const ponyfills = {};
+  
+  ponyfills.URLPattern = globalThis.URLPattern;
+
+  // We call this previously to patch `Bun`
+  if (!ponyfills.URLPattern) {
+    const urlPatternModule = require('urlpattern-polyfill');
+    ponyfills.URLPattern = urlPatternModule.URLPattern;
+  }
+
+  if (opts.skipPonyfill || shouldSkipPonyfill()) {
+    return {
+      fetch: globalThis.fetch,
+      Headers: globalThis.Headers,
+      Request: globalThis.Request,
+      Response: globalThis.Response,
+      FormData: globalThis.FormData,
+      ReadableStream: globalThis.ReadableStream,
+      WritableStream: globalThis.WritableStream,
+      TransformStream: globalThis.TransformStream,
+      CompressionStream: globalThis.CompressionStream,
+      DecompressionStream: globalThis.DecompressionStream,
+      TextDecoderStream: globalThis.TextDecoderStream,
+      TextEncoderStream: globalThis.TextEncoderStream,
+      Blob: globalThis.Blob,
+      File: globalThis.File,
+      crypto: globalThis.crypto,
+      btoa: globalThis.btoa,
+      TextEncoder: globalThis.TextEncoder,
+      TextDecoder: globalThis.TextDecoder,
+      URLPattern: ponyfills.URLPattern,
+      URL: globalThis.URL,
+      URLSearchParams: globalThis.URLSearchParams
+    };
+  }
+
+  newNodeFetch ||= require('@whatwg-node/node-fetch');
+
+  ponyfills.fetch = newNodeFetch.fetch;
+  ponyfills.Request = newNodeFetch.Request;
+  ponyfills.Response = newNodeFetch.Response;
+  ponyfills.Headers = newNodeFetch.Headers;
+  ponyfills.FormData = newNodeFetch.FormData;
+  ponyfills.ReadableStream = newNodeFetch.ReadableStream;
+
+  ponyfills.URL = newNodeFetch.URL;
+  ponyfills.URLSearchParams = newNodeFetch.URLSearchParams;
+
+  ponyfills.WritableStream = newNodeFetch.WritableStream;
+  ponyfills.TransformStream = newNodeFetch.TransformStream;
+  ponyfills.CompressionStream = newNodeFetch.CompressionStream;
+  ponyfills.DecompressionStream = newNodeFetch.DecompressionStream;
+  ponyfills.TextDecoderStream = newNodeFetch.TextDecoderStream;
+  ponyfills.TextEncoderStream = newNodeFetch.TextEncoderStream;
+
+  ponyfills.Blob = newNodeFetch.Blob;
+  ponyfills.File = newNodeFetch.File;
+  ponyfills.crypto = globalThis.crypto;
+  ponyfills.btoa = newNodeFetch.btoa;
+  ponyfills.TextEncoder = newNodeFetch.TextEncoder;
+  ponyfills.TextDecoder = newNodeFetch.TextDecoder;
+
+  if (opts.formDataLimits) {
+    ponyfills.Body = class Body extends newNodeFetch.Body {
+      constructor(body, userOpts) {
+        super(body, {
+          formDataLimits: opts.formDataLimits,
+          ...userOpts,
+        });
+      }
+    }
+    ponyfills.Request = class Request extends newNodeFetch.Request {
+      constructor(input, userOpts) {
+        super(input, {
+          formDataLimits: opts.formDataLimits,
+          ...userOpts,
+        });
+      }
+    }
+    ponyfills.Response = class Response extends newNodeFetch.Response {
+      constructor(body, userOpts) {
+        super(body, {
+          formDataLimits: opts.formDataLimits,
+          ...userOpts,
+        });
+      }
+    }
+  }
+
+  if (!ponyfills.crypto) {
+    const cryptoModule = require("crypto");
+    ponyfills.crypto = cryptoModule.webcrypto;
+  }
+
+  return ponyfills;
+}

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

@@ -0,0 +1,71 @@
+const fetch = globalThis.fetch;
+const Headers = globalThis.Headers;
+const Request = globalThis.Request;
+const Response = globalThis.Response;
+const FormData = globalThis.FormData;
+const ReadableStream = globalThis.ReadableStream;
+const WritableStream = globalThis.WritableStream;
+const TransformStream = globalThis.TransformStream;
+const CompressionStream = globalThis.CompressionStream;
+const DecompressionStream = globalThis.DecompressionStream;
+const TextDecoderStream = globalThis.TextDecoderStream;
+const TextEncoderStream = globalThis.TextEncoderStream;
+const Blob = globalThis.Blob;
+const File = globalThis.File;
+const crypto = globalThis.crypto;
+const btoa = globalThis.btoa;
+const TextEncoder = globalThis.TextEncoder;
+const TextDecoder = globalThis.TextDecoder;
+const URLPattern = globalThis.URLPattern;
+const URL = globalThis.URL;
+const URLSearchParams = globalThis.URLSearchParams;
+
+export {
+    fetch,
+    Headers,
+    Request,
+    Response,
+    FormData,
+    ReadableStream,
+    WritableStream,
+    TransformStream,
+    CompressionStream,
+    DecompressionStream,
+    TextDecoderStream,
+    TextEncoderStream,
+    Blob,
+    File,
+    crypto,
+    btoa,
+    TextEncoder,
+    TextDecoder,
+    URLPattern,
+    URL,
+    URLSearchParams
+}
+
+export function createFetch() {
+    return {
+    fetch,
+    Headers,
+    Request,
+    Response,
+    FormData,
+    ReadableStream,
+    WritableStream,
+    TransformStream,
+    CompressionStream,
+    DecompressionStream,
+    TextDecoderStream,
+    TextEncoderStream,
+    Blob,
+    File,
+    crypto,
+    btoa,
+    TextEncoder,
+    TextDecoder,
+    URLPattern,
+    URL,
+    URLSearchParams
+    };
+}

package/node_modules/@whatwg-node/fetch/dist/global-ponyfill.js

@@ -0,0 +1,22 @@
+module.exports.fetch = globalThis.fetch;
+module.exports.Headers = globalThis.Headers;
+module.exports.Request = globalThis.Request;
+module.exports.Response = globalThis.Response;
+module.exports.FormData = globalThis.FormData;
+module.exports.ReadableStream = globalThis.ReadableStream;
+module.exports.WritableStream = globalThis.WritableStream;
+module.exports.TransformStream = globalThis.TransformStream;
+module.exports.CompressionStream = globalThis.CompressionStream;
+module.exports.DecompressionStream = globalThis.DecompressionStream;
+module.exports.TextDecoderStream = globalThis.TextDecoderStream;
+module.exports.TextEncoderStream = globalThis.TextEncoderStream;
+module.exports.Blob = globalThis.Blob;
+module.exports.File = globalThis.File;
+module.exports.crypto = globalThis.crypto;
+module.exports.btoa = globalThis.btoa;
+module.exports.TextEncoder = globalThis.TextEncoder;
+module.exports.TextDecoder = globalThis.TextDecoder;
+module.exports.URLPattern = globalThis.URLPattern;
+module.exports.URL = globalThis.URL;
+module.exports.URLSearchParams = globalThis.URLSearchParams;
+module.exports.createFetch = () => globalThis;

package/node_modules/@whatwg-node/fetch/dist/index.d.ts

@@ -0,0 +1,73 @@
+/// <reference lib="dom" />
+/// <reference lib="dom.iterable" />
+
+declare type _URLPattern = typeof URLPattern
+
+declare module '@whatwg-node/fetch' {
+  export const fetch: typeof globalThis.fetch;
+  export const Request: typeof globalThis.Request;
+  export const Response: typeof globalThis.Response & {
+    json(data: any, init?: ResponseInit): globalThis.Response;
+  };
+  export const Headers: typeof globalThis.Headers;
+  export const FormData: typeof globalThis.FormData;
+  export const ReadableStream: typeof globalThis.ReadableStream;
+  export const WritableStream: typeof globalThis.WritableStream;
+  export const TransformStream: typeof globalThis.TransformStream;
+  export const CompressionStream: typeof globalThis.CompressionStream;
+  export const DecompressionStream: typeof globalThis.DecompressionStream;
+  export const TextDecoderStream: typeof globalThis.TextDecoderStream;
+  export const TextEncoderStream: typeof globalThis.TextEncoderStream;
+  export const Blob: typeof globalThis.Blob;
+  export const File: typeof globalThis.File;
+  export const crypto: typeof globalThis.crypto;
+  export const btoa: typeof globalThis.btoa;
+  export const TextDecoder: typeof globalThis.TextDecoder;
+  export const TextEncoder: typeof globalThis.TextEncoder;
+  export const URL: typeof globalThis.URL;
+  export const URLSearchParams: typeof globalThis.URLSearchParams;
+  export const URLPattern: _URLPattern;
+  export interface FormDataLimits {
+    /* Max field name size (in bytes). Default: 100. */
+    fieldNameSize?: number;
+    /* Max field value size (in bytes). Default: 1MB. */
+    fieldSize?: number;
+    /* Max number of fields. Default: Infinity. */
+    fields?: number;
+    /* For multipart forms, the max file size (in bytes). Default: Infinity. */
+    fileSize?: number;
+    /* For multipart forms, the max number of file fields. Default: Infinity. */
+    files?: number;
+    /* For multipart forms, the max number of parts (fields + files). Default: Infinity. */
+    parts?: number;
+    /* For multipart forms, the max number of header key-value pairs to parse. Default: 2000. */
+    headerSize?: number;
+  }
+  export const createFetch: (opts?: {
+    useNodeFetch?: boolean;
+    formDataLimits?: FormDataLimits;
+    skipPonyfill?: boolean;
+  }) => {
+    fetch: typeof fetch;
+    Request: typeof Request;
+    Response: typeof Response;
+    Headers: typeof Headers;
+    FormData: typeof FormData;
+    ReadableStream: typeof ReadableStream;
+    WritableStream: typeof WritableStream;
+    TransformStream: typeof TransformStream;
+    CompressionStream: typeof CompressionStream;
+    DecompressionStream: typeof DecompressionStream;
+    TextDecoderStream: typeof TextDecoderStream;
+    TextEncoderStream: typeof TextEncoderStream;
+    Blob: typeof Blob;
+    File: typeof File;
+    crypto: typeof crypto;
+    btoa: typeof btoa;
+    TextEncoder: typeof TextEncoder;
+    TextDecoder: typeof TextDecoder;
+    URLPattern: typeof URLPattern;
+    URL: typeof URL;
+    URLSearchParams: typeof URLSearchParams;
+  };
+}

package/node_modules/@whatwg-node/fetch/dist/node-ponyfill.js

@@ -0,0 +1,35 @@
+
+const createNodePonyfill = require('./create-node-ponyfill');
+const shouldSkipPonyfill = require('./shouldSkipPonyfill');
+const ponyfills = createNodePonyfill();
+
+if (!shouldSkipPonyfill()) {
+  try {
+    const nodelibcurlName = 'node-libcurl'
+    globalThis.libcurl = globalThis.libcurl || require(nodelibcurlName);
+  } catch (e) { }
+}
+
+module.exports.fetch = ponyfills.fetch;
+module.exports.Headers = ponyfills.Headers;
+module.exports.Request = ponyfills.Request;
+module.exports.Response = ponyfills.Response;
+module.exports.FormData = ponyfills.FormData;
+module.exports.ReadableStream = ponyfills.ReadableStream;
+module.exports.WritableStream = ponyfills.WritableStream;
+module.exports.TransformStream = ponyfills.TransformStream;
+module.exports.CompressionStream = ponyfills.CompressionStream;
+module.exports.DecompressionStream = ponyfills.DecompressionStream;
+module.exports.TextDecoderStream = ponyfills.TextDecoderStream;
+module.exports.TextEncoderStream = ponyfills.TextEncoderStream;
+module.exports.Blob = ponyfills.Blob;
+module.exports.File = ponyfills.File;
+module.exports.crypto = ponyfills.crypto;
+module.exports.btoa = ponyfills.btoa;
+module.exports.TextEncoder = ponyfills.TextEncoder;
+module.exports.TextDecoder = ponyfills.TextDecoder;
+module.exports.URLPattern = ponyfills.URLPattern;
+module.exports.URL = ponyfills.URL;
+module.exports.URLSearchParams = ponyfills.URLSearchParams;
+
+exports.createFetch = createNodePonyfill;

package/node_modules/@whatwg-node/fetch/dist/shouldSkipPonyfill.js

@@ -0,0 +1,17 @@
+
+function isNextJs() {
+  return Object.keys(globalThis).some(key => key.startsWith('__NEXT'))
+}
+
+module.exports = function shouldSkipPonyfill() {
+  if (globalThis.Deno) {
+    return true
+  }
+  if (globalThis.Bun) {
+    return true
+  }
+  if (isNextJs()) {
+    return true
+  }
+  return false
+}

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

@@ -0,0 +1,31 @@
+{
+  "name": "@whatwg-node/fetch",
+  "version": "0.10.13",
+  "description": "Cross Platform Smart Fetch Ponyfill",
+  "repository": {
+    "type": "git",
+    "url": "ardatan/whatwg-node",
+    "directory": "packages/fetch"
+  },
+  "author": "Arda TANRIKULU <ardatanrikulu@gmail.com>",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "main": "dist/node-ponyfill.js",
+  "browser": "dist/global-ponyfill.js",
+  "types": "dist/index.d.ts",
+  "dependencies": {
+    "@whatwg-node/node-fetch": "^0.8.3",
+    "urlpattern-polyfill": "^10.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false,
+  "bob": false,
+  "denoify": {
+    "index": "dist/esm-ponyfill.js"
+  },
+  "react-native": "dist/global-ponyfill.js"
+}

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PonyfillAbortError = void 0;
+class PonyfillAbortError extends Error {
+    constructor(reason) {
+        let message = 'The operation was aborted';
+        if (reason) {
+            message += ` reason: ${reason}`;
+        }
+        super(message, {
+            cause: reason,
+        });
+        this.name = 'AbortError';
+    }
+    get reason() {
+        return this.cause;
+    }
+}
+exports.PonyfillAbortError = PonyfillAbortError;