full site update

node_modules/ofetch/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Pooya Parsa <pooya@pi0.io>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/ofetch/README.md

@@ -0,0 +1,417 @@
+# ofetch
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![bundle][bundle-src]][bundle-href]
+[![Codecov][codecov-src]][codecov-href]
+[![License][license-src]][license-href]
+[![JSDocs][jsdocs-src]][jsdocs-href]
+
+A better fetch API. Works on node, browser, and workers.
+
+<details>
+  <summary>Spoiler</summary>
+  <img src="https://media.giphy.com/media/Dn1QRA9hqMcoMz9zVZ/giphy.gif">
+</details>
+
+## 🚀 Quick Start
+
+Install:
+
+```bash
+# npm
+npm i ofetch
+
+# yarn
+yarn add ofetch
+```
+
+Import:
+
+```js
+// ESM / Typescript
+import { ofetch } from "ofetch";
+
+// CommonJS
+const { ofetch } = require("ofetch");
+```
+
+## ✔️ Works with Node.js
+
+We use [conditional exports](https://nodejs.org/api/packages.html#packages_conditional_exports) to detect Node.js
+and automatically use [unjs/node-fetch-native](https://github.com/unjs/node-fetch-native). If `globalThis.fetch` is available, will be used instead. To leverage Node.js 17.5.0 experimental native fetch API use [`--experimental-fetch` flag](https://nodejs.org/dist/latest-v17.x/docs/api/cli.html#--experimental-fetch).
+
+## ✔️ Parsing Response
+
+`ofetch` will smartly parse JSON and native values using [destr](https://github.com/unjs/destr), falling back to the text if it fails to parse.
+
+```js
+const { users } = await ofetch("/api/users");
+```
+
+For binary content types, `ofetch` will instead return a `Blob` object.
+
+You can optionally provide a different parser than `destr`, or specify `blob`, `arrayBuffer`, or `text` to force parsing the body with the respective `FetchResponse` method.
+
+```js
+// Use JSON.parse
+await ofetch("/movie?lang=en", { parseResponse: JSON.parse });
+
+// Return text as is
+await ofetch("/movie?lang=en", { parseResponse: (txt) => txt });
+
+// Get the blob version of the response
+await ofetch("/api/generate-image", { responseType: "blob" });
+```
+
+## ✔️ JSON Body
+
+If an object or a class with a `.toJSON()` method is passed to the `body` option, `ofetch` automatically stringifies it.
+
+`ofetch` utilizes `JSON.stringify()` to convert the passed object. Classes without a `.toJSON()` method have to be converted into a string value in advance before being passed to the `body` option.
+
+For `PUT`, `PATCH`, and `POST` request methods, when a string or object body is set, `ofetch` adds the default `content-type: "application/json"` and `accept: "application/json"` headers (which you can always override).
+
+Additionally, `ofetch` supports binary responses with `Buffer`, `ReadableStream`, `Stream`, and [compatible body types](https://developer.mozilla.org/en-US/docs/Web/API/fetch#body). ofetch will automatically set the `duplex: "half"` option for streaming support!
+
+**Example:**
+
+```js
+const { users } = await ofetch("/api/users", {
+  method: "POST",
+  body: { some: "json" },
+});
+```
+
+## ✔️ Handling Errors
+
+`ofetch` Automatically throws errors when `response.ok` is `false` with a friendly error message and compact stack (hiding internals).
+
+A parsed error body is available with `error.data`. You may also use `FetchError` type.
+
+```ts
+await ofetch("https://google.com/404");
+// FetchError: [GET] "https://google/404": 404 Not Found
+//     at async main (/project/playground.ts:4:3)
+```
+
+To catch error response:
+
+```ts
+await ofetch("/url").catch((error) => error.data);
+```
+
+To bypass status error catching you can set `ignoreResponseError` option:
+
+```ts
+await ofetch("/url", { ignoreResponseError: true });
+```
+
+## ✔️ Auto Retry
+
+`ofetch` Automatically retries the request if an error happens and if the response status code is included in `retryStatusCodes` list:
+
+**Retry status codes:**
+
+- `408` - Request Timeout
+- `409` - Conflict
+- `425` - Too Early ([Experimental](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Early-Data))
+- `429` - Too Many Requests
+- `500` - Internal Server Error
+- `502` - Bad Gateway
+- `503` - Service Unavailable
+- `504` - Gateway Timeout
+
+You can specify the amount of retry and delay between them using `retry` and `retryDelay` options and also pass a custom array of codes using `retryStatusCodes` option.
+
+The default for `retry` is `1` retry, except for `POST`, `PUT`, `PATCH`, and `DELETE` methods where `ofetch` does not retry by default to avoid introducing side effects. If you set a custom value for `retry` it will **always retry** for all requests.
+
+The default for `retryDelay` is `0` ms.
+
+```ts
+await ofetch("http://google.com/404", {
+  retry: 3,
+  retryDelay: 500, // ms
+});
+```
+
+## ✔️ Timeout
+
+You can specify `timeout` in milliseconds to automatically abort a request after a timeout (default is disabled).
+
+```ts
+await ofetch("http://google.com/404", {
+  timeout: 3000, // Timeout after 3 seconds
+});
+```
+
+## ✔️ Type Friendly
+
+The response can be type assisted:
+
+```ts
+const article = await ofetch<Article>(`/api/article/${id}`);
+// Auto complete working with article.id
+```
+
+## ✔️ Adding `baseURL`
+
+By using `baseURL` option, `ofetch` prepends it for trailing/leading slashes and query search params for baseURL using [ufo](https://github.com/unjs/ufo):
+
+```js
+await ofetch("/config", { baseURL });
+```
+
+## ✔️ Adding Query Search Params
+
+By using `query` option (or `params` as alias), `ofetch` adds query search params to the URL by preserving the query in the request itself using [ufo](https://github.com/unjs/ufo):
+
+```js
+await ofetch("/movie?lang=en", { query: { id: 123 } });
+```
+
+## ✔️ Interceptors
+
+Providing async interceptors to hook into lifecycle events of `ofetch` call is possible.
+
+You might want to use `ofetch.create` to set shared interceptors.
+
+### `onRequest({ request, options })`
+
+`onRequest` is called as soon as `ofetch` is called, allowing you to modify options or do simple logging.
+
+```js
+await ofetch("/api", {
+  async onRequest({ request, options }) {
+    // Log request
+    console.log("[fetch request]", request, options);
+
+    // Add `?t=1640125211170` to query search params
+    options.query = options.query || {};
+    options.query.t = new Date();
+  },
+});
+```
+
+### `onRequestError({ request, options, error })`
+
+`onRequestError` will be called when the fetch request fails.
+
+```js
+await ofetch("/api", {
+  async onRequestError({ request, options, error }) {
+    // Log error
+    console.log("[fetch request error]", request, error);
+  },
+});
+```
+
+### `onResponse({ request, options, response })`
+
+`onResponse` will be called after `fetch` call and parsing body.
+
+```js
+await ofetch("/api", {
+  async onResponse({ request, response, options }) {
+    // Log response
+    console.log("[fetch response]", request, response.status, response.body);
+  },
+});
+```
+
+### `onResponseError({ request, options, response })`
+
+`onResponseError` is the same as `onResponse` but will be called when fetch happens but `response.ok` is not `true`.
+
+```js
+await ofetch("/api", {
+  async onResponseError({ request, response, options }) {
+    // Log error
+    console.log(
+      "[fetch response error]",
+      request,
+      response.status,
+      response.body
+    );
+  },
+});
+```
+
+### Passing array of interceptors
+
+If necessary, it's also possible to pass an array of function that will be called sequentially.
+
+```js
+await ofetch("/api", {
+  onRequest: [
+    () => {
+      /* Do something */
+    },
+    () => {
+      /* Do something else */
+    },
+  ],
+});
+```
+
+## ✔️ Create fetch with default options
+
+This utility is useful if you need to use common options across several fetch calls.
+
+**Note:** Defaults will be cloned at one level and inherited. Be careful about nested options like `headers`.
+
+```js
+const apiFetch = ofetch.create({ baseURL: "/api" });
+
+apiFetch("/test"); // Same as ofetch('/test', { baseURL: '/api' })
+```
+
+## 💡 Adding headers
+
+By using `headers` option, `ofetch` adds extra headers in addition to the request default headers:
+
+```js
+await ofetch("/movies", {
+  headers: {
+    Accept: "application/json",
+    "Cache-Control": "no-cache",
+  },
+});
+```
+
+## 🍣 Access to Raw Response
+
+If you need to access raw response (for headers, etc), can use `ofetch.raw`:
+
+```js
+const response = await ofetch.raw("/sushi");
+
+// response._data
+// response.headers
+// ...
+```
+
+## 🌿 Using Native Fetch
+
+As a shortcut, you can use `ofetch.native` that provides native `fetch` API
+
+```js
+const json = await ofetch.native("/sushi").then((r) => r.json());
+```
+
+## 🕵️ Adding HTTP(S) Agent
+
+In Node.js (>= 18) environments, you can provide a custom dispatcher to intercept requests and support features such as Proxy and self-signed certificates. This feature is enabled by [undici](https://undici.nodejs.org/) built-in Node.js. [read more](https://undici.nodejs.org/#/docs/api/Dispatcher) about the Dispatcher API.
+
+Some available agents:
+
+- `ProxyAgent`: A Proxy Agent class that implements the Agent API. It allows the connection through a proxy in a simple way. ([docs](https://undici.nodejs.org/#/docs/api/ProxyAgent))
+- `MockAgent`: A mocked Agent class that implements the Agent API. It allows one to intercept HTTP requests made through undici and return mocked responses instead. ([docs](https://undici.nodejs.org/#/docs/api/MockAgent))
+- `Agent`: Agent allows dispatching requests against multiple different origins. ([docs](https://undici.nodejs.org/#/docs/api/Agent))
+
+**Example:** Set a proxy agent for one request:
+
+```ts
+import { ProxyAgent } from "undici";
+import { ofetch } from "ofetch";
+
+const proxyAgent = new ProxyAgent("http://localhost:3128");
+const data = await ofetch("https://icanhazip.com", { dispatcher: proxyAgent });
+```
+
+**Example:** Create a custom fetch instance that has proxy enabled:
+
+```ts
+import { ProxyAgent, setGlobalDispatcher } from "undici";
+import { ofetch } from "ofetch";
+
+const proxyAgent = new ProxyAgent("http://localhost:3128");
+const fetchWithProxy = ofetch.create({ dispatcher: proxyAgent });
+
+const data = await fetchWithProxy("https://icanhazip.com");
+```
+
+**Example:** Set a proxy agent for all requests:
+
+```ts
+import { ProxyAgent, setGlobalDispatcher } from "undici";
+import { ofetch } from "ofetch";
+
+const proxyAgent = new ProxyAgent("http://localhost:3128");
+setGlobalDispatcher(proxyAgent);
+
+const data = await ofetch("https://icanhazip.com");
+```
+
+**Example:** Allow self-signed certificates (USE AT YOUR OWN RISK!)
+
+```ts
+import { Agent } from "undici";
+import { ofetch } from "ofetch";
+
+// Note: This makes fetch unsecure against MITM attacks. USE AT YOUW OWN RISK!
+const unsecureAgent = new Agent({ connect: { rejectUnauthorized: false } });
+const unsecureFetch = ofetch.create({ dispatcher: unsecureAgent });
+
+const data = await unsecureFetch("https://www.squid-cache.org/");
+```
+
+On older Node.js version (<18), you might also use use `agent`:
+
+```ts
+import { HttpsProxyAgent } from "https-proxy-agent";
+
+await ofetch("/api", {
+  agent: new HttpsProxyAgent("http://example.com"),
+});
+```
+
+### `keepAlive` support (only works for Node < 18)
+
+By setting the `FETCH_KEEP_ALIVE` environment variable to `true`, an HTTP/HTTPS agent will be registered that keeps sockets around even when there are no outstanding requests, so they can be used for future requests without having to re-establish a TCP connection.
+
+**Note:** This option can potentially introduce memory leaks. Please check [node-fetch/node-fetch#1325](https://github.com/node-fetch/node-fetch/pull/1325).
+
+## 📦 Bundler Notes
+
+- All targets are exported with Module and CommonJS format and named exports
+- No export is transpiled for the sake of modern syntax
+  - You probably need to transpile `ofetch`, `destr`, and `ufo` packages with Babel for ES5 support
+- You need to polyfill `fetch` global for supporting legacy browsers like using [unfetch](https://github.com/developit/unfetch)
+
+## ❓ FAQ
+
+**Why export is called `ofetch` instead of `fetch`?**
+
+Using the same name of `fetch` can be confusing since API is different but still, it is a fetch so using the closest possible alternative. You can, however, import `{ fetch }` from `ofetch` which is auto-polyfill for Node.js and using native otherwise.
+
+**Why not have default export?**
+
+Default exports are always risky to be mixed with CommonJS exports.
+
+This also guarantees we can introduce more utils without breaking the package and also encourage using `ofetch` name.
+
+**Why not transpiled?**
+
+By transpiling libraries, we push the web backward with legacy code which is unneeded for most of the users.
+
+If you need to support legacy users, you can optionally transpile the library in your build pipeline.
+
+## License
+
+MIT. Made with 💖
+
+<!-- Badges -->
+
+[npm-version-src]: https://img.shields.io/npm/v/ofetch?style=flat&colorA=18181B&colorB=F0DB4F
+[npm-version-href]: https://npmjs.com/package/ofetch
+[npm-downloads-src]: https://img.shields.io/npm/dm/ofetch?style=flat&colorA=18181B&colorB=F0DB4F
+[npm-downloads-href]: https://npmjs.com/package/ofetch
+[codecov-src]: https://img.shields.io/codecov/c/gh/unjs/ofetch/main?style=flat&colorA=18181B&colorB=F0DB4F
+[codecov-href]: https://codecov.io/gh/unjs/ofetch
+[bundle-src]: https://img.shields.io/bundlephobia/minzip/ofetch?style=flat&colorA=18181B&colorB=F0DB4F
+[bundle-href]: https://bundlephobia.com/result?p=ofetch
+[license-src]: https://img.shields.io/github/license/unjs/ofetch.svg?style=flat&colorA=18181B&colorB=F0DB4F
+[license-href]: https://github.com/unjs/ofetch/blob/main/LICENSE
+[jsdocs-src]: https://img.shields.io/badge/jsDocs.io-reference-18181B?style=flat&colorA=18181B&colorB=F0DB4F
+[jsdocs-href]: https://www.jsdocs.io/package/ofetch

node_modules/ofetch/dist/index.cjs

@@ -0,0 +1,35 @@
+'use strict';
+
+const fetch$1 = require('./shared/ofetch.d8adb063.cjs');
+require('destr');
+require('ufo');
+
+const _globalThis = function() {
+  if (typeof globalThis !== "undefined") {
+    return globalThis;
+  }
+  if (typeof self !== "undefined") {
+    return self;
+  }
+  if (typeof window !== "undefined") {
+    return window;
+  }
+  if (typeof global !== "undefined") {
+    return global;
+  }
+  throw new Error("unable to locate global object");
+}();
+const fetch = _globalThis.fetch ? (...args) => _globalThis.fetch(...args) : () => Promise.reject(new Error("[ofetch] global.fetch is not supported!"));
+const Headers = _globalThis.Headers;
+const AbortController = _globalThis.AbortController;
+const ofetch = fetch$1.createFetch({ fetch, Headers, AbortController });
+const $fetch = ofetch;
+
+exports.FetchError = fetch$1.FetchError;
+exports.createFetch = fetch$1.createFetch;
+exports.createFetchError = fetch$1.createFetchError;
+exports.$fetch = $fetch;
+exports.AbortController = AbortController;
+exports.Headers = Headers;
+exports.fetch = fetch;
+exports.ofetch = ofetch;

node_modules/ofetch/dist/index.d.cts

@@ -0,0 +1,17 @@
+import { $ as $Fetch } from './shared/ofetch.d0b3d489.cjs';
+export { C as CreateFetchOptions, j as Fetch, d as FetchContext, F as FetchError, e as FetchHook, f as FetchHooks, b as FetchOptions, k as FetchRequest, i as FetchResponse, G as GlobalOptions, I as IFetchError, M as MappedResponseType, R as ResolvedFetchOptions, g as ResponseMap, h as ResponseType, S as SearchParameters, c as createFetch, a as createFetchError } from './shared/ofetch.d0b3d489.cjs';
+import 'undici';
+
+declare const fetch: (input: string | URL | Request, init?: RequestInit | undefined) => Promise<Response>;
+declare const Headers: {
+    new (init?: HeadersInit): Headers;
+    prototype: Headers;
+};
+declare const AbortController: {
+    new (): AbortController;
+    prototype: AbortController;
+};
+declare const ofetch: $Fetch;
+declare const $fetch: $Fetch;
+
+export { $Fetch, $fetch, AbortController, Headers, fetch, ofetch };

node_modules/ofetch/dist/index.d.mts

@@ -0,0 +1,17 @@
+import { $ as $Fetch } from './shared/ofetch.d0b3d489.mjs';
+export { C as CreateFetchOptions, j as Fetch, d as FetchContext, F as FetchError, e as FetchHook, f as FetchHooks, b as FetchOptions, k as FetchRequest, i as FetchResponse, G as GlobalOptions, I as IFetchError, M as MappedResponseType, R as ResolvedFetchOptions, g as ResponseMap, h as ResponseType, S as SearchParameters, c as createFetch, a as createFetchError } from './shared/ofetch.d0b3d489.mjs';
+import 'undici';
+
+declare const fetch: (input: string | URL | Request, init?: RequestInit | undefined) => Promise<Response>;
+declare const Headers: {
+    new (init?: HeadersInit): Headers;
+    prototype: Headers;
+};
+declare const AbortController: {
+    new (): AbortController;
+    prototype: AbortController;
+};
+declare const ofetch: $Fetch;
+declare const $fetch: $Fetch;
+
+export { $Fetch, $fetch, AbortController, Headers, fetch, ofetch };

node_modules/ofetch/dist/index.d.ts

@@ -0,0 +1,17 @@
+import { $ as $Fetch } from './shared/ofetch.d0b3d489.js';
+export { C as CreateFetchOptions, j as Fetch, d as FetchContext, F as FetchError, e as FetchHook, f as FetchHooks, b as FetchOptions, k as FetchRequest, i as FetchResponse, G as GlobalOptions, I as IFetchError, M as MappedResponseType, R as ResolvedFetchOptions, g as ResponseMap, h as ResponseType, S as SearchParameters, c as createFetch, a as createFetchError } from './shared/ofetch.d0b3d489.js';
+import 'undici';
+
+declare const fetch: (input: string | URL | Request, init?: RequestInit | undefined) => Promise<Response>;
+declare const Headers: {
+    new (init?: HeadersInit): Headers;
+    prototype: Headers;
+};
+declare const AbortController: {
+    new (): AbortController;
+    prototype: AbortController;
+};
+declare const ofetch: $Fetch;
+declare const $fetch: $Fetch;
+
+export { $Fetch, $fetch, AbortController, Headers, fetch, ofetch };

node_modules/ofetch/dist/index.mjs

@@ -0,0 +1,27 @@
+import { c as createFetch } from './shared/ofetch.03887fc3.mjs';
+export { F as FetchError, a as createFetchError } from './shared/ofetch.03887fc3.mjs';
+import 'destr';
+import 'ufo';
+
+const _globalThis = function() {
+  if (typeof globalThis !== "undefined") {
+    return globalThis;
+  }
+  if (typeof self !== "undefined") {
+    return self;
+  }
+  if (typeof window !== "undefined") {
+    return window;
+  }
+  if (typeof global !== "undefined") {
+    return global;
+  }
+  throw new Error("unable to locate global object");
+}();
+const fetch = _globalThis.fetch ? (...args) => _globalThis.fetch(...args) : () => Promise.reject(new Error("[ofetch] global.fetch is not supported!"));
+const Headers = _globalThis.Headers;
+const AbortController = _globalThis.AbortController;
+const ofetch = createFetch({ fetch, Headers, AbortController });
+const $fetch = ofetch;
+
+export { $fetch, AbortController, Headers, createFetch, fetch, ofetch };

node_modules/ofetch/dist/node.cjs

@@ -0,0 +1,47 @@
+'use strict';
+
+const http = require('node:http');
+const https = require('node:https');
+const nodeFetch = require('node-fetch-native');
+const fetch$1 = require('./shared/ofetch.d8adb063.cjs');
+require('destr');
+require('ufo');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const http__default = /*#__PURE__*/_interopDefaultCompat(http);
+const https__default = /*#__PURE__*/_interopDefaultCompat(https);
+const nodeFetch__default = /*#__PURE__*/_interopDefaultCompat(nodeFetch);
+
+function createNodeFetch() {
+  const useKeepAlive = JSON.parse(process.env.FETCH_KEEP_ALIVE || "false");
+  if (!useKeepAlive) {
+    return nodeFetch__default;
+  }
+  const agentOptions = { keepAlive: true };
+  const httpAgent = new http__default.Agent(agentOptions);
+  const httpsAgent = new https__default.Agent(agentOptions);
+  const nodeFetchOptions = {
+    agent(parsedURL) {
+      return parsedURL.protocol === "http:" ? httpAgent : httpsAgent;
+    }
+  };
+  return function nodeFetchWithKeepAlive(input, init) {
+    return nodeFetch__default(input, { ...nodeFetchOptions, ...init });
+  };
+}
+const fetch = globalThis.fetch ? (...args) => globalThis.fetch(...args) : createNodeFetch();
+const Headers = globalThis.Headers || nodeFetch.Headers;
+const AbortController = globalThis.AbortController || nodeFetch.AbortController;
+const ofetch = fetch$1.createFetch({ fetch, Headers, AbortController });
+const $fetch = ofetch;
+
+exports.FetchError = fetch$1.FetchError;
+exports.createFetch = fetch$1.createFetch;
+exports.createFetchError = fetch$1.createFetchError;
+exports.$fetch = $fetch;
+exports.AbortController = AbortController;
+exports.Headers = Headers;
+exports.createNodeFetch = createNodeFetch;
+exports.fetch = fetch;
+exports.ofetch = ofetch;

node_modules/ofetch/dist/node.d.cts

@@ -0,0 +1,18 @@
+import { $ as $Fetch } from './shared/ofetch.d0b3d489.cjs';
+export { C as CreateFetchOptions, j as Fetch, d as FetchContext, F as FetchError, e as FetchHook, f as FetchHooks, b as FetchOptions, k as FetchRequest, i as FetchResponse, G as GlobalOptions, I as IFetchError, M as MappedResponseType, R as ResolvedFetchOptions, g as ResponseMap, h as ResponseType, S as SearchParameters, c as createFetch, a as createFetchError } from './shared/ofetch.d0b3d489.cjs';
+import 'undici';
+
+declare function createNodeFetch(): (input: RequestInfo, init?: RequestInit) => any;
+declare const fetch: typeof globalThis.fetch;
+declare const Headers: {
+    new (init?: HeadersInit): Headers;
+    prototype: Headers;
+};
+declare const AbortController: {
+    new (): AbortController;
+    prototype: AbortController;
+};
+declare const ofetch: $Fetch;
+declare const $fetch: $Fetch;
+
+export { $Fetch, $fetch, AbortController, Headers, createNodeFetch, fetch, ofetch };

node_modules/ofetch/dist/node.d.mts

@@ -0,0 +1,18 @@
+import { $ as $Fetch } from './shared/ofetch.d0b3d489.mjs';
+export { C as CreateFetchOptions, j as Fetch, d as FetchContext, F as FetchError, e as FetchHook, f as FetchHooks, b as FetchOptions, k as FetchRequest, i as FetchResponse, G as GlobalOptions, I as IFetchError, M as MappedResponseType, R as ResolvedFetchOptions, g as ResponseMap, h as ResponseType, S as SearchParameters, c as createFetch, a as createFetchError } from './shared/ofetch.d0b3d489.mjs';
+import 'undici';
+
+declare function createNodeFetch(): (input: RequestInfo, init?: RequestInit) => any;
+declare const fetch: typeof globalThis.fetch;
+declare const Headers: {
+    new (init?: HeadersInit): Headers;
+    prototype: Headers;
+};
+declare const AbortController: {
+    new (): AbortController;
+    prototype: AbortController;
+};
+declare const ofetch: $Fetch;
+declare const $fetch: $Fetch;
+
+export { $Fetch, $fetch, AbortController, Headers, createNodeFetch, fetch, ofetch };

node_modules/ofetch/dist/node.d.ts

@@ -0,0 +1,18 @@
+import { $ as $Fetch } from './shared/ofetch.d0b3d489.js';
+export { C as CreateFetchOptions, j as Fetch, d as FetchContext, F as FetchError, e as FetchHook, f as FetchHooks, b as FetchOptions, k as FetchRequest, i as FetchResponse, G as GlobalOptions, I as IFetchError, M as MappedResponseType, R as ResolvedFetchOptions, g as ResponseMap, h as ResponseType, S as SearchParameters, c as createFetch, a as createFetchError } from './shared/ofetch.d0b3d489.js';
+import 'undici';
+
+declare function createNodeFetch(): (input: RequestInfo, init?: RequestInit) => any;
+declare const fetch: typeof globalThis.fetch;
+declare const Headers: {
+    new (init?: HeadersInit): Headers;
+    prototype: Headers;
+};
+declare const AbortController: {
+    new (): AbortController;
+    prototype: AbortController;
+};
+declare const ofetch: $Fetch;
+declare const $fetch: $Fetch;
+
+export { $Fetch, $fetch, AbortController, Headers, createNodeFetch, fetch, ofetch };

node_modules/ofetch/dist/node.mjs

@@ -0,0 +1,32 @@
+import http from 'node:http';
+import https from 'node:https';
+import nodeFetch, { Headers as Headers$1, AbortController as AbortController$1 } from 'node-fetch-native';
+import { c as createFetch } from './shared/ofetch.03887fc3.mjs';
+export { F as FetchError, a as createFetchError } from './shared/ofetch.03887fc3.mjs';
+import 'destr';
+import 'ufo';
+
+function createNodeFetch() {
+  const useKeepAlive = JSON.parse(process.env.FETCH_KEEP_ALIVE || "false");
+  if (!useKeepAlive) {
+    return nodeFetch;
+  }
+  const agentOptions = { keepAlive: true };
+  const httpAgent = new http.Agent(agentOptions);
+  const httpsAgent = new https.Agent(agentOptions);
+  const nodeFetchOptions = {
+    agent(parsedURL) {
+      return parsedURL.protocol === "http:" ? httpAgent : httpsAgent;
+    }
+  };
+  return function nodeFetchWithKeepAlive(input, init) {
+    return nodeFetch(input, { ...nodeFetchOptions, ...init });
+  };
+}
+const fetch = globalThis.fetch ? (...args) => globalThis.fetch(...args) : createNodeFetch();
+const Headers = globalThis.Headers || Headers$1;
+const AbortController = globalThis.AbortController || AbortController$1;
+const ofetch = createFetch({ fetch, Headers, AbortController });
+const $fetch = ofetch;
+
+export { $fetch, AbortController, Headers, createFetch, createNodeFetch, fetch, ofetch };

node_modules/ofetch/dist/shared/ofetch.03887fc3.mjs

@@ -0,0 +1,333 @@
+import destr from 'destr';
+import { withBase, withQuery } from 'ufo';
+
+class FetchError extends Error {
+  constructor(message, opts) {
+    super(message, opts);
+    this.name = "FetchError";
+    if (opts?.cause && !this.cause) {
+      this.cause = opts.cause;
+    }
+  }
+}
+function createFetchError(ctx) {
+  const errorMessage = ctx.error?.message || ctx.error?.toString() || "";
+  const method = ctx.request?.method || ctx.options?.method || "GET";
+  const url = ctx.request?.url || String(ctx.request) || "/";
+  const requestStr = `[${method}] ${JSON.stringify(url)}`;
+  const statusStr = ctx.response ? `${ctx.response.status} ${ctx.response.statusText}` : "<no response>";
+  const message = `${requestStr}: ${statusStr}${errorMessage ? ` ${errorMessage}` : ""}`;
+  const fetchError = new FetchError(
+    message,
+    ctx.error ? { cause: ctx.error } : void 0
+  );
+  for (const key of ["request", "options", "response"]) {
+    Object.defineProperty(fetchError, key, {
+      get() {
+        return ctx[key];
+      }
+    });
+  }
+  for (const [key, refKey] of [
+    ["data", "_data"],
+    ["status", "status"],
+    ["statusCode", "status"],
+    ["statusText", "statusText"],
+    ["statusMessage", "statusText"]
+  ]) {
+    Object.defineProperty(fetchError, key, {
+      get() {
+        return ctx.response && ctx.response[refKey];
+      }
+    });
+  }
+  return fetchError;
+}
+
+const payloadMethods = new Set(
+  Object.freeze(["PATCH", "POST", "PUT", "DELETE"])
+);
+function isPayloadMethod(method = "GET") {
+  return payloadMethods.has(method.toUpperCase());
+}
+function isJSONSerializable(value) {
+  if (value === void 0) {
+    return false;
+  }
+  const t = typeof value;
+  if (t === "string" || t === "number" || t === "boolean" || t === null) {
+    return true;
+  }
+  if (t !== "object") {
+    return false;
+  }
+  if (Array.isArray(value)) {
+    return true;
+  }
+  if (value.buffer) {
+    return false;
+  }
+  return value.constructor && value.constructor.name === "Object" || typeof value.toJSON === "function";
+}
+const textTypes = /* @__PURE__ */ new Set([
+  "image/svg",
+  "application/xml",
+  "application/xhtml",
+  "application/html"
+]);
+const JSON_RE = /^application\/(?:[\w!#$%&*.^`~-]*\+)?json(;.+)?$/i;
+function detectResponseType(_contentType = "") {
+  if (!_contentType) {
+    return "json";
+  }
+  const contentType = _contentType.split(";").shift() || "";
+  if (JSON_RE.test(contentType)) {
+    return "json";
+  }
+  if (textTypes.has(contentType) || contentType.startsWith("text/")) {
+    return "text";
+  }
+  return "blob";
+}
+function resolveFetchOptions(request, input, defaults, Headers) {
+  const headers = mergeHeaders(
+    input?.headers ?? request?.headers,
+    defaults?.headers,
+    Headers
+  );
+  let query;
+  if (defaults?.query || defaults?.params || input?.params || input?.query) {
+    query = {
+      ...defaults?.params,
+      ...defaults?.query,
+      ...input?.params,
+      ...input?.query
+    };
+  }
+  return {
+    ...defaults,
+    ...input,
+    query,
+    params: query,
+    headers
+  };
+}
+function mergeHeaders(input, defaults, Headers) {
+  if (!defaults) {
+    return new Headers(input);
+  }
+  const headers = new Headers(defaults);
+  if (input) {
+    for (const [key, value] of Symbol.iterator in input || Array.isArray(input) ? input : new Headers(input)) {
+      headers.set(key, value);
+    }
+  }
+  return headers;
+}
+async function callHooks(context, hooks) {
+  if (hooks) {
+    if (Array.isArray(hooks)) {
+      for (const hook of hooks) {
+        await hook(context);
+      }
+    } else {
+      await hooks(context);
+    }
+  }
+}
+
+const retryStatusCodes = /* @__PURE__ */ new Set([
+  408,
+  // Request Timeout
+  409,
+  // Conflict
+  425,
+  // Too Early (Experimental)
+  429,
+  // Too Many Requests
+  500,
+  // Internal Server Error
+  502,
+  // Bad Gateway
+  503,
+  // Service Unavailable
+  504
+  // Gateway Timeout
+]);
+const nullBodyResponses = /* @__PURE__ */ new Set([101, 204, 205, 304]);
+function createFetch(globalOptions = {}) {
+  const {
+    fetch = globalThis.fetch,
+    Headers = globalThis.Headers,
+    AbortController = globalThis.AbortController
+  } = globalOptions;
+  async function onError(context) {
+    const isAbort = context.error && context.error.name === "AbortError" && !context.options.timeout || false;
+    if (context.options.retry !== false && !isAbort) {
+      let retries;
+      if (typeof context.options.retry === "number") {
+        retries = context.options.retry;
+      } else {
+        retries = isPayloadMethod(context.options.method) ? 0 : 1;
+      }
+      const responseCode = context.response && context.response.status || 500;
+      if (retries > 0 && (Array.isArray(context.options.retryStatusCodes) ? context.options.retryStatusCodes.includes(responseCode) : retryStatusCodes.has(responseCode))) {
+        const retryDelay = typeof context.options.retryDelay === "function" ? context.options.retryDelay(context) : context.options.retryDelay || 0;
+        if (retryDelay > 0) {
+          await new Promise((resolve) => setTimeout(resolve, retryDelay));
+        }
+        return $fetchRaw(context.request, {
+          ...context.options,
+          retry: retries - 1
+        });
+      }
+    }
+    const error = createFetchError(context);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(error, $fetchRaw);
+    }
+    throw error;
+  }
+  const $fetchRaw = async function $fetchRaw2(_request, _options = {}) {
+    const context = {
+      request: _request,
+      options: resolveFetchOptions(
+        _request,
+        _options,
+        globalOptions.defaults,
+        Headers
+      ),
+      response: void 0,
+      error: void 0
+    };
+    if (context.options.method) {
+      context.options.method = context.options.method.toUpperCase();
+    }
+    if (context.options.onRequest) {
+      await callHooks(context, context.options.onRequest);
+    }
+    if (typeof context.request === "string") {
+      if (context.options.baseURL) {
+        context.request = withBase(context.request, context.options.baseURL);
+      }
+      if (context.options.query) {
+        context.request = withQuery(context.request, context.options.query);
+        delete context.options.query;
+      }
+      if ("query" in context.options) {
+        delete context.options.query;
+      }
+      if ("params" in context.options) {
+        delete context.options.params;
+      }
+    }
+    if (context.options.body && isPayloadMethod(context.options.method)) {
+      if (isJSONSerializable(context.options.body)) {
+        context.options.body = typeof context.options.body === "string" ? context.options.body : JSON.stringify(context.options.body);
+        context.options.headers = new Headers(context.options.headers || {});
+        if (!context.options.headers.has("content-type")) {
+          context.options.headers.set("content-type", "application/json");
+        }
+        if (!context.options.headers.has("accept")) {
+          context.options.headers.set("accept", "application/json");
+        }
+      } else if (
+        // ReadableStream Body
+        "pipeTo" in context.options.body && typeof context.options.body.pipeTo === "function" || // Node.js Stream Body
+        typeof context.options.body.pipe === "function"
+      ) {
+        if (!("duplex" in context.options)) {
+          context.options.duplex = "half";
+        }
+      }
+    }
+    let abortTimeout;
+    if (!context.options.signal && context.options.timeout) {
+      const controller = new AbortController();
+      abortTimeout = setTimeout(() => {
+        const error = new Error(
+          "[TimeoutError]: The operation was aborted due to timeout"
+        );
+        error.name = "TimeoutError";
+        error.code = 23;
+        controller.abort(error);
+      }, context.options.timeout);
+      context.options.signal = controller.signal;
+    }
+    try {
+      context.response = await fetch(
+        context.request,
+        context.options
+      );
+    } catch (error) {
+      context.error = error;
+      if (context.options.onRequestError) {
+        await callHooks(
+          context,
+          context.options.onRequestError
+        );
+      }
+      return await onError(context);
+    } finally {
+      if (abortTimeout) {
+        clearTimeout(abortTimeout);
+      }
+    }
+    const hasBody = (context.response.body || // https://github.com/unjs/ofetch/issues/324
+    // https://github.com/unjs/ofetch/issues/294
+    // https://github.com/JakeChampion/fetch/issues/1454
+    context.response._bodyInit) && !nullBodyResponses.has(context.response.status) && context.options.method !== "HEAD";
+    if (hasBody) {
+      const responseType = (context.options.parseResponse ? "json" : context.options.responseType) || detectResponseType(context.response.headers.get("content-type") || "");
+      switch (responseType) {
+        case "json": {
+          const data = await context.response.text();
+          const parseFunction = context.options.parseResponse || destr;
+          context.response._data = parseFunction(data);
+          break;
+        }
+        case "stream": {
+          context.response._data = context.response.body || context.response._bodyInit;
+          break;
+        }
+        default: {
+          context.response._data = await context.response[responseType]();
+        }
+      }
+    }
+    if (context.options.onResponse) {
+      await callHooks(
+        context,
+        context.options.onResponse
+      );
+    }
+    if (!context.options.ignoreResponseError && context.response.status >= 400 && context.response.status < 600) {
+      if (context.options.onResponseError) {
+        await callHooks(
+          context,
+          context.options.onResponseError
+        );
+      }
+      return await onError(context);
+    }
+    return context.response;
+  };
+  const $fetch = async function $fetch2(request, options) {
+    const r = await $fetchRaw(request, options);
+    return r._data;
+  };
+  $fetch.raw = $fetchRaw;
+  $fetch.native = (...args) => fetch(...args);
+  $fetch.create = (defaultOptions = {}, customGlobalOptions = {}) => createFetch({
+    ...globalOptions,
+    ...customGlobalOptions,
+    defaults: {
+      ...globalOptions.defaults,
+      ...customGlobalOptions.defaults,
+      ...defaultOptions
+    }
+  });
+  return $fetch;
+}
+
+export { FetchError as F, createFetchError as a, createFetch as c };

node_modules/ofetch/dist/shared/ofetch.d0b3d489.d.cts

@@ -0,0 +1,110 @@
+import * as undici from 'undici';
+
+interface $Fetch {
+    <T = any, R extends ResponseType = "json">(request: FetchRequest, options?: FetchOptions<R>): Promise<MappedResponseType<R, T>>;
+    raw<T = any, R extends ResponseType = "json">(request: FetchRequest, options?: FetchOptions<R>): Promise<FetchResponse<MappedResponseType<R, T>>>;
+    native: Fetch;
+    create(defaults: FetchOptions, globalOptions?: CreateFetchOptions): $Fetch;
+}
+interface FetchOptions<R extends ResponseType = ResponseType, T = any> extends Omit<RequestInit, "body">, FetchHooks<T, R> {
+    baseURL?: string;
+    body?: RequestInit["body"] | Record<string, any>;
+    ignoreResponseError?: boolean;
+    params?: Record<string, any>;
+    query?: Record<string, any>;
+    parseResponse?: (responseText: string) => any;
+    responseType?: R;
+    /**
+     * @experimental Set to "half" to enable duplex streaming.
+     * Will be automatically set to "half" when using a ReadableStream as body.
+     * @see https://fetch.spec.whatwg.org/#enumdef-requestduplex
+     */
+    duplex?: "half" | undefined;
+    /**
+     * Only supported in Node.js >= 18 using undici
+     *
+     * @see https://undici.nodejs.org/#/docs/api/Dispatcher
+     */
+    dispatcher?: InstanceType<typeof undici.Dispatcher>;
+    /**
+     * Only supported older Node.js versions using node-fetch-native polyfill.
+     */
+    agent?: unknown;
+    /** timeout in milliseconds */
+    timeout?: number;
+    retry?: number | false;
+    /** Delay between retries in milliseconds. */
+    retryDelay?: number | ((context: FetchContext<T, R>) => number);
+    /** Default is [408, 409, 425, 429, 500, 502, 503, 504] */
+    retryStatusCodes?: number[];
+}
+interface ResolvedFetchOptions<R extends ResponseType = ResponseType, T = any> extends FetchOptions<R, T> {
+    headers: Headers;
+}
+interface CreateFetchOptions {
+    defaults?: FetchOptions;
+    fetch?: Fetch;
+    Headers?: typeof Headers;
+    AbortController?: typeof AbortController;
+}
+type GlobalOptions = Pick<FetchOptions, "timeout" | "retry" | "retryDelay">;
+interface FetchContext<T = any, R extends ResponseType = ResponseType> {
+    request: FetchRequest;
+    options: ResolvedFetchOptions<R>;
+    response?: FetchResponse<T>;
+    error?: Error;
+}
+type MaybePromise<T> = T | Promise<T>;
+type MaybeArray<T> = T | T[];
+type FetchHook<C extends FetchContext = FetchContext> = (context: C) => MaybePromise<void>;
+interface FetchHooks<T = any, R extends ResponseType = ResponseType> {
+    onRequest?: MaybeArray<FetchHook<FetchContext<T, R>>>;
+    onRequestError?: MaybeArray<FetchHook<FetchContext<T, R> & {
+        error: Error;
+    }>>;
+    onResponse?: MaybeArray<FetchHook<FetchContext<T, R> & {
+        response: FetchResponse<T>;
+    }>>;
+    onResponseError?: MaybeArray<FetchHook<FetchContext<T, R> & {
+        response: FetchResponse<T>;
+    }>>;
+}
+interface ResponseMap {
+    blob: Blob;
+    text: string;
+    arrayBuffer: ArrayBuffer;
+    stream: ReadableStream<Uint8Array>;
+}
+type ResponseType = keyof ResponseMap | "json";
+type MappedResponseType<R extends ResponseType, JsonType = any> = R extends keyof ResponseMap ? ResponseMap[R] : JsonType;
+interface FetchResponse<T> extends Response {
+    _data?: T;
+}
+interface IFetchError<T = any> extends Error {
+    request?: FetchRequest;
+    options?: FetchOptions;
+    response?: FetchResponse<T>;
+    data?: T;
+    status?: number;
+    statusText?: string;
+    statusCode?: number;
+    statusMessage?: string;
+}
+type Fetch = typeof globalThis.fetch;
+type FetchRequest = RequestInfo;
+interface SearchParameters {
+    [key: string]: any;
+}
+
+declare function createFetch(globalOptions?: CreateFetchOptions): $Fetch;
+
+declare class FetchError<T = any> extends Error implements IFetchError<T> {
+    constructor(message: string, opts?: {
+        cause: unknown;
+    });
+}
+interface FetchError<T = any> extends IFetchError<T> {
+}
+declare function createFetchError<T = any>(ctx: FetchContext<T>): IFetchError<T>;
+
+export { type $Fetch as $, type CreateFetchOptions as C, FetchError as F, type GlobalOptions as G, type IFetchError as I, type MappedResponseType as M, type ResolvedFetchOptions as R, type SearchParameters as S, createFetchError as a, type FetchOptions as b, createFetch as c, type FetchContext as d, type FetchHook as e, type FetchHooks as f, type ResponseMap as g, type ResponseType as h, type FetchResponse as i, type Fetch as j, type FetchRequest as k };

node_modules/ofetch/dist/shared/ofetch.d0b3d489.d.mts

@@ -0,0 +1,110 @@
+import * as undici from 'undici';
+
+interface $Fetch {
+    <T = any, R extends ResponseType = "json">(request: FetchRequest, options?: FetchOptions<R>): Promise<MappedResponseType<R, T>>;
+    raw<T = any, R extends ResponseType = "json">(request: FetchRequest, options?: FetchOptions<R>): Promise<FetchResponse<MappedResponseType<R, T>>>;
+    native: Fetch;
+    create(defaults: FetchOptions, globalOptions?: CreateFetchOptions): $Fetch;
+}
+interface FetchOptions<R extends ResponseType = ResponseType, T = any> extends Omit<RequestInit, "body">, FetchHooks<T, R> {
+    baseURL?: string;
+    body?: RequestInit["body"] | Record<string, any>;
+    ignoreResponseError?: boolean;
+    params?: Record<string, any>;
+    query?: Record<string, any>;
+    parseResponse?: (responseText: string) => any;
+    responseType?: R;
+    /**
+     * @experimental Set to "half" to enable duplex streaming.
+     * Will be automatically set to "half" when using a ReadableStream as body.
+     * @see https://fetch.spec.whatwg.org/#enumdef-requestduplex
+     */
+    duplex?: "half" | undefined;
+    /**
+     * Only supported in Node.js >= 18 using undici
+     *
+     * @see https://undici.nodejs.org/#/docs/api/Dispatcher
+     */
+    dispatcher?: InstanceType<typeof undici.Dispatcher>;
+    /**
+     * Only supported older Node.js versions using node-fetch-native polyfill.
+     */
+    agent?: unknown;
+    /** timeout in milliseconds */
+    timeout?: number;
+    retry?: number | false;
+    /** Delay between retries in milliseconds. */
+    retryDelay?: number | ((context: FetchContext<T, R>) => number);
+    /** Default is [408, 409, 425, 429, 500, 502, 503, 504] */
+    retryStatusCodes?: number[];
+}
+interface ResolvedFetchOptions<R extends ResponseType = ResponseType, T = any> extends FetchOptions<R, T> {
+    headers: Headers;
+}
+interface CreateFetchOptions {
+    defaults?: FetchOptions;
+    fetch?: Fetch;
+    Headers?: typeof Headers;
+    AbortController?: typeof AbortController;
+}
+type GlobalOptions = Pick<FetchOptions, "timeout" | "retry" | "retryDelay">;
+interface FetchContext<T = any, R extends ResponseType = ResponseType> {
+    request: FetchRequest;
+    options: ResolvedFetchOptions<R>;
+    response?: FetchResponse<T>;
+    error?: Error;
+}
+type MaybePromise<T> = T | Promise<T>;
+type MaybeArray<T> = T | T[];
+type FetchHook<C extends FetchContext = FetchContext> = (context: C) => MaybePromise<void>;
+interface FetchHooks<T = any, R extends ResponseType = ResponseType> {
+    onRequest?: MaybeArray<FetchHook<FetchContext<T, R>>>;
+    onRequestError?: MaybeArray<FetchHook<FetchContext<T, R> & {
+        error: Error;
+    }>>;
+    onResponse?: MaybeArray<FetchHook<FetchContext<T, R> & {
+        response: FetchResponse<T>;
+    }>>;
+    onResponseError?: MaybeArray<FetchHook<FetchContext<T, R> & {
+        response: FetchResponse<T>;
+    }>>;
+}
+interface ResponseMap {
+    blob: Blob;
+    text: string;
+    arrayBuffer: ArrayBuffer;
+    stream: ReadableStream<Uint8Array>;
+}
+type ResponseType = keyof ResponseMap | "json";
+type MappedResponseType<R extends ResponseType, JsonType = any> = R extends keyof ResponseMap ? ResponseMap[R] : JsonType;
+interface FetchResponse<T> extends Response {
+    _data?: T;
+}
+interface IFetchError<T = any> extends Error {
+    request?: FetchRequest;
+    options?: FetchOptions;
+    response?: FetchResponse<T>;
+    data?: T;
+    status?: number;
+    statusText?: string;
+    statusCode?: number;
+    statusMessage?: string;
+}
+type Fetch = typeof globalThis.fetch;
+type FetchRequest = RequestInfo;
+interface SearchParameters {
+    [key: string]: any;
+}
+
+declare function createFetch(globalOptions?: CreateFetchOptions): $Fetch;
+
+declare class FetchError<T = any> extends Error implements IFetchError<T> {
+    constructor(message: string, opts?: {
+        cause: unknown;
+    });
+}
+interface FetchError<T = any> extends IFetchError<T> {
+}
+declare function createFetchError<T = any>(ctx: FetchContext<T>): IFetchError<T>;
+
+export { type $Fetch as $, type CreateFetchOptions as C, FetchError as F, type GlobalOptions as G, type IFetchError as I, type MappedResponseType as M, type ResolvedFetchOptions as R, type SearchParameters as S, createFetchError as a, type FetchOptions as b, createFetch as c, type FetchContext as d, type FetchHook as e, type FetchHooks as f, type ResponseMap as g, type ResponseType as h, type FetchResponse as i, type Fetch as j, type FetchRequest as k };

node_modules/ofetch/dist/shared/ofetch.d0b3d489.d.ts

@@ -0,0 +1,110 @@
+import * as undici from 'undici';
+
+interface $Fetch {
+    <T = any, R extends ResponseType = "json">(request: FetchRequest, options?: FetchOptions<R>): Promise<MappedResponseType<R, T>>;
+    raw<T = any, R extends ResponseType = "json">(request: FetchRequest, options?: FetchOptions<R>): Promise<FetchResponse<MappedResponseType<R, T>>>;
+    native: Fetch;
+    create(defaults: FetchOptions, globalOptions?: CreateFetchOptions): $Fetch;
+}
+interface FetchOptions<R extends ResponseType = ResponseType, T = any> extends Omit<RequestInit, "body">, FetchHooks<T, R> {
+    baseURL?: string;
+    body?: RequestInit["body"] | Record<string, any>;
+    ignoreResponseError?: boolean;
+    params?: Record<string, any>;
+    query?: Record<string, any>;
+    parseResponse?: (responseText: string) => any;
+    responseType?: R;
+    /**
+     * @experimental Set to "half" to enable duplex streaming.
+     * Will be automatically set to "half" when using a ReadableStream as body.
+     * @see https://fetch.spec.whatwg.org/#enumdef-requestduplex
+     */
+    duplex?: "half" | undefined;
+    /**
+     * Only supported in Node.js >= 18 using undici
+     *
+     * @see https://undici.nodejs.org/#/docs/api/Dispatcher
+     */
+    dispatcher?: InstanceType<typeof undici.Dispatcher>;
+    /**
+     * Only supported older Node.js versions using node-fetch-native polyfill.
+     */
+    agent?: unknown;
+    /** timeout in milliseconds */
+    timeout?: number;
+    retry?: number | false;
+    /** Delay between retries in milliseconds. */
+    retryDelay?: number | ((context: FetchContext<T, R>) => number);
+    /** Default is [408, 409, 425, 429, 500, 502, 503, 504] */
+    retryStatusCodes?: number[];
+}
+interface ResolvedFetchOptions<R extends ResponseType = ResponseType, T = any> extends FetchOptions<R, T> {
+    headers: Headers;
+}
+interface CreateFetchOptions {
+    defaults?: FetchOptions;
+    fetch?: Fetch;
+    Headers?: typeof Headers;
+    AbortController?: typeof AbortController;
+}
+type GlobalOptions = Pick<FetchOptions, "timeout" | "retry" | "retryDelay">;
+interface FetchContext<T = any, R extends ResponseType = ResponseType> {
+    request: FetchRequest;
+    options: ResolvedFetchOptions<R>;
+    response?: FetchResponse<T>;
+    error?: Error;
+}
+type MaybePromise<T> = T | Promise<T>;
+type MaybeArray<T> = T | T[];
+type FetchHook<C extends FetchContext = FetchContext> = (context: C) => MaybePromise<void>;
+interface FetchHooks<T = any, R extends ResponseType = ResponseType> {
+    onRequest?: MaybeArray<FetchHook<FetchContext<T, R>>>;
+    onRequestError?: MaybeArray<FetchHook<FetchContext<T, R> & {
+        error: Error;
+    }>>;
+    onResponse?: MaybeArray<FetchHook<FetchContext<T, R> & {
+        response: FetchResponse<T>;
+    }>>;
+    onResponseError?: MaybeArray<FetchHook<FetchContext<T, R> & {
+        response: FetchResponse<T>;
+    }>>;
+}
+interface ResponseMap {
+    blob: Blob;
+    text: string;
+    arrayBuffer: ArrayBuffer;
+    stream: ReadableStream<Uint8Array>;
+}
+type ResponseType = keyof ResponseMap | "json";
+type MappedResponseType<R extends ResponseType, JsonType = any> = R extends keyof ResponseMap ? ResponseMap[R] : JsonType;
+interface FetchResponse<T> extends Response {
+    _data?: T;
+}
+interface IFetchError<T = any> extends Error {
+    request?: FetchRequest;
+    options?: FetchOptions;
+    response?: FetchResponse<T>;
+    data?: T;
+    status?: number;
+    statusText?: string;
+    statusCode?: number;
+    statusMessage?: string;
+}
+type Fetch = typeof globalThis.fetch;
+type FetchRequest = RequestInfo;
+interface SearchParameters {
+    [key: string]: any;
+}
+
+declare function createFetch(globalOptions?: CreateFetchOptions): $Fetch;
+
+declare class FetchError<T = any> extends Error implements IFetchError<T> {
+    constructor(message: string, opts?: {
+        cause: unknown;
+    });
+}
+interface FetchError<T = any> extends IFetchError<T> {
+}
+declare function createFetchError<T = any>(ctx: FetchContext<T>): IFetchError<T>;
+
+export { type $Fetch as $, type CreateFetchOptions as C, FetchError as F, type GlobalOptions as G, type IFetchError as I, type MappedResponseType as M, type ResolvedFetchOptions as R, type SearchParameters as S, createFetchError as a, type FetchOptions as b, createFetch as c, type FetchContext as d, type FetchHook as e, type FetchHooks as f, type ResponseMap as g, type ResponseType as h, type FetchResponse as i, type Fetch as j, type FetchRequest as k };

node_modules/ofetch/dist/shared/ofetch.d8adb063.cjs

@@ -0,0 +1,341 @@
+'use strict';
+
+const destr = require('destr');
+const ufo = require('ufo');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const destr__default = /*#__PURE__*/_interopDefaultCompat(destr);
+
+class FetchError extends Error {
+  constructor(message, opts) {
+    super(message, opts);
+    this.name = "FetchError";
+    if (opts?.cause && !this.cause) {
+      this.cause = opts.cause;
+    }
+  }
+}
+function createFetchError(ctx) {
+  const errorMessage = ctx.error?.message || ctx.error?.toString() || "";
+  const method = ctx.request?.method || ctx.options?.method || "GET";
+  const url = ctx.request?.url || String(ctx.request) || "/";
+  const requestStr = `[${method}] ${JSON.stringify(url)}`;
+  const statusStr = ctx.response ? `${ctx.response.status} ${ctx.response.statusText}` : "<no response>";
+  const message = `${requestStr}: ${statusStr}${errorMessage ? ` ${errorMessage}` : ""}`;
+  const fetchError = new FetchError(
+    message,
+    ctx.error ? { cause: ctx.error } : void 0
+  );
+  for (const key of ["request", "options", "response"]) {
+    Object.defineProperty(fetchError, key, {
+      get() {
+        return ctx[key];
+      }
+    });
+  }
+  for (const [key, refKey] of [
+    ["data", "_data"],
+    ["status", "status"],
+    ["statusCode", "status"],
+    ["statusText", "statusText"],
+    ["statusMessage", "statusText"]
+  ]) {
+    Object.defineProperty(fetchError, key, {
+      get() {
+        return ctx.response && ctx.response[refKey];
+      }
+    });
+  }
+  return fetchError;
+}
+
+const payloadMethods = new Set(
+  Object.freeze(["PATCH", "POST", "PUT", "DELETE"])
+);
+function isPayloadMethod(method = "GET") {
+  return payloadMethods.has(method.toUpperCase());
+}
+function isJSONSerializable(value) {
+  if (value === void 0) {
+    return false;
+  }
+  const t = typeof value;
+  if (t === "string" || t === "number" || t === "boolean" || t === null) {
+    return true;
+  }
+  if (t !== "object") {
+    return false;
+  }
+  if (Array.isArray(value)) {
+    return true;
+  }
+  if (value.buffer) {
+    return false;
+  }
+  return value.constructor && value.constructor.name === "Object" || typeof value.toJSON === "function";
+}
+const textTypes = /* @__PURE__ */ new Set([
+  "image/svg",
+  "application/xml",
+  "application/xhtml",
+  "application/html"
+]);
+const JSON_RE = /^application\/(?:[\w!#$%&*.^`~-]*\+)?json(;.+)?$/i;
+function detectResponseType(_contentType = "") {
+  if (!_contentType) {
+    return "json";
+  }
+  const contentType = _contentType.split(";").shift() || "";
+  if (JSON_RE.test(contentType)) {
+    return "json";
+  }
+  if (textTypes.has(contentType) || contentType.startsWith("text/")) {
+    return "text";
+  }
+  return "blob";
+}
+function resolveFetchOptions(request, input, defaults, Headers) {
+  const headers = mergeHeaders(
+    input?.headers ?? request?.headers,
+    defaults?.headers,
+    Headers
+  );
+  let query;
+  if (defaults?.query || defaults?.params || input?.params || input?.query) {
+    query = {
+      ...defaults?.params,
+      ...defaults?.query,
+      ...input?.params,
+      ...input?.query
+    };
+  }
+  return {
+    ...defaults,
+    ...input,
+    query,
+    params: query,
+    headers
+  };
+}
+function mergeHeaders(input, defaults, Headers) {
+  if (!defaults) {
+    return new Headers(input);
+  }
+  const headers = new Headers(defaults);
+  if (input) {
+    for (const [key, value] of Symbol.iterator in input || Array.isArray(input) ? input : new Headers(input)) {
+      headers.set(key, value);
+    }
+  }
+  return headers;
+}
+async function callHooks(context, hooks) {
+  if (hooks) {
+    if (Array.isArray(hooks)) {
+      for (const hook of hooks) {
+        await hook(context);
+      }
+    } else {
+      await hooks(context);
+    }
+  }
+}
+
+const retryStatusCodes = /* @__PURE__ */ new Set([
+  408,
+  // Request Timeout
+  409,
+  // Conflict
+  425,
+  // Too Early (Experimental)
+  429,
+  // Too Many Requests
+  500,
+  // Internal Server Error
+  502,
+  // Bad Gateway
+  503,
+  // Service Unavailable
+  504
+  // Gateway Timeout
+]);
+const nullBodyResponses = /* @__PURE__ */ new Set([101, 204, 205, 304]);
+function createFetch(globalOptions = {}) {
+  const {
+    fetch = globalThis.fetch,
+    Headers = globalThis.Headers,
+    AbortController = globalThis.AbortController
+  } = globalOptions;
+  async function onError(context) {
+    const isAbort = context.error && context.error.name === "AbortError" && !context.options.timeout || false;
+    if (context.options.retry !== false && !isAbort) {
+      let retries;
+      if (typeof context.options.retry === "number") {
+        retries = context.options.retry;
+      } else {
+        retries = isPayloadMethod(context.options.method) ? 0 : 1;
+      }
+      const responseCode = context.response && context.response.status || 500;
+      if (retries > 0 && (Array.isArray(context.options.retryStatusCodes) ? context.options.retryStatusCodes.includes(responseCode) : retryStatusCodes.has(responseCode))) {
+        const retryDelay = typeof context.options.retryDelay === "function" ? context.options.retryDelay(context) : context.options.retryDelay || 0;
+        if (retryDelay > 0) {
+          await new Promise((resolve) => setTimeout(resolve, retryDelay));
+        }
+        return $fetchRaw(context.request, {
+          ...context.options,
+          retry: retries - 1
+        });
+      }
+    }
+    const error = createFetchError(context);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(error, $fetchRaw);
+    }
+    throw error;
+  }
+  const $fetchRaw = async function $fetchRaw2(_request, _options = {}) {
+    const context = {
+      request: _request,
+      options: resolveFetchOptions(
+        _request,
+        _options,
+        globalOptions.defaults,
+        Headers
+      ),
+      response: void 0,
+      error: void 0
+    };
+    if (context.options.method) {
+      context.options.method = context.options.method.toUpperCase();
+    }
+    if (context.options.onRequest) {
+      await callHooks(context, context.options.onRequest);
+    }
+    if (typeof context.request === "string") {
+      if (context.options.baseURL) {
+        context.request = ufo.withBase(context.request, context.options.baseURL);
+      }
+      if (context.options.query) {
+        context.request = ufo.withQuery(context.request, context.options.query);
+        delete context.options.query;
+      }
+      if ("query" in context.options) {
+        delete context.options.query;
+      }
+      if ("params" in context.options) {
+        delete context.options.params;
+      }
+    }
+    if (context.options.body && isPayloadMethod(context.options.method)) {
+      if (isJSONSerializable(context.options.body)) {
+        context.options.body = typeof context.options.body === "string" ? context.options.body : JSON.stringify(context.options.body);
+        context.options.headers = new Headers(context.options.headers || {});
+        if (!context.options.headers.has("content-type")) {
+          context.options.headers.set("content-type", "application/json");
+        }
+        if (!context.options.headers.has("accept")) {
+          context.options.headers.set("accept", "application/json");
+        }
+      } else if (
+        // ReadableStream Body
+        "pipeTo" in context.options.body && typeof context.options.body.pipeTo === "function" || // Node.js Stream Body
+        typeof context.options.body.pipe === "function"
+      ) {
+        if (!("duplex" in context.options)) {
+          context.options.duplex = "half";
+        }
+      }
+    }
+    let abortTimeout;
+    if (!context.options.signal && context.options.timeout) {
+      const controller = new AbortController();
+      abortTimeout = setTimeout(() => {
+        const error = new Error(
+          "[TimeoutError]: The operation was aborted due to timeout"
+        );
+        error.name = "TimeoutError";
+        error.code = 23;
+        controller.abort(error);
+      }, context.options.timeout);
+      context.options.signal = controller.signal;
+    }
+    try {
+      context.response = await fetch(
+        context.request,
+        context.options
+      );
+    } catch (error) {
+      context.error = error;
+      if (context.options.onRequestError) {
+        await callHooks(
+          context,
+          context.options.onRequestError
+        );
+      }
+      return await onError(context);
+    } finally {
+      if (abortTimeout) {
+        clearTimeout(abortTimeout);
+      }
+    }
+    const hasBody = (context.response.body || // https://github.com/unjs/ofetch/issues/324
+    // https://github.com/unjs/ofetch/issues/294
+    // https://github.com/JakeChampion/fetch/issues/1454
+    context.response._bodyInit) && !nullBodyResponses.has(context.response.status) && context.options.method !== "HEAD";
+    if (hasBody) {
+      const responseType = (context.options.parseResponse ? "json" : context.options.responseType) || detectResponseType(context.response.headers.get("content-type") || "");
+      switch (responseType) {
+        case "json": {
+          const data = await context.response.text();
+          const parseFunction = context.options.parseResponse || destr__default;
+          context.response._data = parseFunction(data);
+          break;
+        }
+        case "stream": {
+          context.response._data = context.response.body || context.response._bodyInit;
+          break;
+        }
+        default: {
+          context.response._data = await context.response[responseType]();
+        }
+      }
+    }
+    if (context.options.onResponse) {
+      await callHooks(
+        context,
+        context.options.onResponse
+      );
+    }
+    if (!context.options.ignoreResponseError && context.response.status >= 400 && context.response.status < 600) {
+      if (context.options.onResponseError) {
+        await callHooks(
+          context,
+          context.options.onResponseError
+        );
+      }
+      return await onError(context);
+    }
+    return context.response;
+  };
+  const $fetch = async function $fetch2(request, options) {
+    const r = await $fetchRaw(request, options);
+    return r._data;
+  };
+  $fetch.raw = $fetchRaw;
+  $fetch.native = (...args) => fetch(...args);
+  $fetch.create = (defaultOptions = {}, customGlobalOptions = {}) => createFetch({
+    ...globalOptions,
+    ...customGlobalOptions,
+    defaults: {
+      ...globalOptions.defaults,
+      ...customGlobalOptions.defaults,
+      ...defaultOptions
+    }
+  });
+  return $fetch;
+}
+
+exports.FetchError = FetchError;
+exports.createFetch = createFetch;
+exports.createFetchError = createFetchError;

node_modules/ofetch/node.d.ts

@@ -0,0 +1 @@
+export * from "./dist/node";

node_modules/ofetch/package.json

@@ -0,0 +1,96 @@
+{
+  "name": "ofetch",
+  "version": "1.4.1",
+  "description": "A better fetch API. Works on node, browser and workers.",
+  "repository": "unjs/ofetch",
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "browser": "./dist/index.mjs",
+      "bun": "./dist/index.mjs",
+      "deno": "./dist/index.mjs",
+      "edge-light": "./dist/index.mjs",
+      "edge-routine": "./dist/index.mjs",
+      "netlify": "./dist/index.mjs",
+      "react-native": "./dist/index.mjs",
+      "wintercg": "./dist/index.mjs",
+      "worker": "./dist/index.mjs",
+      "workerd": "./dist/index.mjs",
+      "node": {
+        "import": {
+          "types": "./dist/node.d.mts",
+          "default": "./dist/node.mjs"
+        },
+        "require": {
+          "types": "./dist/node.d.cts",
+          "default": "./dist/node.cjs"
+        }
+      },
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/node.d.cts",
+        "default": "./dist/node.cjs"
+      },
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    },
+    "./node": {
+      "import": {
+        "types": "./dist/node.d.mts",
+        "default": "./dist/node.mjs"
+      },
+      "require": {
+        "types": "./dist/node.d.cts",
+        "default": "./dist/node.cjs"
+      }
+    }
+  },
+  "main": "./dist/node.cjs",
+  "module": "./dist/index.mjs",
+  "react-native": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "node.d.ts"
+  ],
+  "scripts": {
+    "build": "unbuild",
+    "dev": "vitest",
+    "lint": "eslint . && prettier -c src test playground examples",
+    "lint:fix": "eslint --fix . && prettier -w src test playground examples",
+    "prepack": "pnpm build",
+    "play": "jiti playground/index.ts",
+    "release": "pnpm test && changelogen --release && npm publish && git push --follow-tags",
+    "test": "pnpm lint && vitest run --coverage"
+  },
+  "dependencies": {
+    "destr": "^2.0.3",
+    "node-fetch-native": "^1.6.4",
+    "ufo": "^1.5.4"
+  },
+  "devDependencies": {
+    "@types/node": "^22.7.5",
+    "@vitest/coverage-v8": "^2.1.2",
+    "changelogen": "^0.5.7",
+    "eslint": "^9.12.0",
+    "eslint-config-unjs": "^0.4.1",
+    "fetch-blob": "^4.0.0",
+    "formdata-polyfill": "^4.0.10",
+    "h3": "^1.13.0",
+    "jiti": "^2.3.3",
+    "listhen": "^1.9.0",
+    "prettier": "^3.3.3",
+    "std-env": "^3.7.0",
+    "typescript": "^5.6.2",
+    "unbuild": "^2.0.0",
+    "undici": "^6.19.8",
+    "vitest": "^2.1.2"
+  },
+  "packageManager": "pnpm@9.12.1"
+}