void 0.1.6 → 0.7.0

package/skills/void/docs/node_modules/void/node_modules/ofetch/README.md

@@ -0,0 +1,398 @@
+# ofetch
+
+<!-- automd:badges -->
+
+[![npm version](https://img.shields.io/npm/v/ofetch)](https://npmjs.com/package/ofetch)
+[![npm downloads](https://img.shields.io/npm/dm/ofetch)](https://npm.chart.dev/ofetch)
+
+<!-- /automd -->
+
+A better fetch API. Works on node, browser, and workers.
+
+> [!IMPORTANT]
+> You are on v2 (alpha) development branch. See [v1](https://github.com/unjs/ofetch/tree/v1) for v1 docs.
+
+<details>
+  <summary>Spoiler</summary>
+  <img src="https://media.giphy.com/media/Dn1QRA9hqMcoMz9zVZ/giphy.gif">
+</details>
+
+## 🚀 Quick Start
+
+Install:
+
+```bash
+npx nypm i ofetch
+```
+
+Import:
+
+```js
+import { ofetch } from "ofetch";
+```
+
+## ✔️ Parsing Response
+
+`ofetch` smartly parse JSON responses.
+
+```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 `JSON.parse`, or specify `blob`, `arrayBuffer`, `text` or `stream` to force parsing the body with the respective `FetchResponse` method.
+
+```js
+// 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" });
+
+// Get the stream version of the response
+await ofetch("/api/generate-image", { responseType: "stream" });
+```
+
+## ✔️ 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
+  retryStatusCodes: [404, 500], // response status codes to retry
+});
+```
+
+## ✔️ 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), you 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());
+```
+
+## 📡 SSE
+
+**Example:** Handle SSE response:
+
+```js
+const stream = await ofetch("/sse");
+const reader = stream.getReader();
+const decoder = new TextDecoder();
+while (true) {
+  const { done, value } = await reader.read();
+  if (done) break;
+  // Here is the chunked text of the SSE response.
+  const text = decoder.decode(value);
+}
+```
+
+## 🕵️ 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 YOUR OWN RISK!
+const unsecureAgent = new Agent({ connect: { rejectUnauthorized: false } });
+const unsecureFetch = ofetch.create({ dispatcher: unsecureAgent });
+
+const data = await unsecureFetch("https://www.squid-cache.org/");
+```
+
+### 💪 Augment `FetchOptions` interface
+
+You can augment the `FetchOptions` interface to add custom properties.
+
+```ts
+// Place this in any `.ts` or `.d.ts` file.
+// Ensure it's included in the project's tsconfig.json "files".
+declare module "ofetch" {
+  interface FetchOptions {
+    // Custom properties
+    requiresAuth?: boolean;
+  }
+}
+
+export {};
+```
+
+This lets you pass and use those properties with full type safety throughout `ofetch` calls.
+
+```ts
+const myFetch = ofetch.create({
+  onRequest(context) {
+    //      ^? { ..., options: {..., requiresAuth?: boolean }}
+    console.log(context.options.requiresAuth);
+  },
+});
+
+myFetch("/foo", { requiresAuth: true });
+```
+
+## License
+
+💛 Published under the [MIT](https://github.com/h3js/rou3/blob/main/LICENSE) license.

package/skills/void/docs/node_modules/void/node_modules/pathe/README.md

@@ -0,0 +1,73 @@
+# 🛣️ pathe
+
+> Universal filesystem path utils
+
+[![version][npm-v-src]][npm-v-href]
+[![downloads][npm-d-src]][npm-d-href]
+[![size][size-src]][size-href]
+
+## ❓ Why
+
+For [historical reasons](https://docs.microsoft.com/en-us/archive/blogs/larryosterman/why-is-the-dos-path-character), windows followed MS-DOS and used backslash for separating paths rather than slash used for macOS, Linux, and other Posix operating systems. Nowadays, [Windows](https://docs.microsoft.com/en-us/windows/win32/fileio/naming-a-file?redirectedfrom=MSDN) supports both Slash and Backslash for paths. [Node.js's built-in `path` module](https://nodejs.org/api/path.html) in the default operation of the path module varies based on the operating system on which a Node.js application is running. Specifically, when running on a Windows operating system, the path module will assume that Windows-style paths are being used. **This makes inconsistent code behavior between Windows and POSIX.**
+
+Compared to popular [upath](https://github.com/anodynos/upath), pathe provides **identical exports** of Node.js with normalization on **all operations** and is written in modern **ESM/TypeScript** and has **no dependency on Node.js**!
+
+This package is a drop-in replacement of the Node.js's [path module](https://nodejs.org/api/path.html) module and ensures paths are normalized with slash `/` and work in environments including Node.js.
+
+## 💿 Usage
+
+Install using npm or yarn:
+
+```bash
+# npm
+npm i pathe
+
+# yarn
+yarn add pathe
+
+# pnpm
+pnpm i pathe
+```
+
+Import:
+
+```js
+// ESM / Typescript
+import { resolve, matchesGlob } from "pathe";
+
+// CommonJS
+const { resolve, matchesGlob } = require("pathe");
+```
+
+Read more about path utils from [Node.js documentation](https://nodejs.org/api/path.html) and rest assured behavior is consistently like POSIX regardless of your input paths format and running platform (the only exception is `delimiter` constant export, it will be set to `;` on windows platform).
+
+### Extra utilities
+
+Pathe exports some extra utilities that do not exist in standard Node.js [path module](https://nodejs.org/api/path.html).
+In order to use them, you can import from `pathe/utils` subpath:
+
+```js
+import {
+  filename,
+  normalizeAliases,
+  resolveAlias,
+  reverseResolveAlias,
+} from "pathe/utils";
+```
+
+## License
+
+Made with 💛 Published under the [MIT](./LICENSE) license.
+
+Some code was used from the Node.js project. Glob supported is powered by [zeptomatch](https://github.com/fabiospampinato/zeptomatch).
+
+<!-- Refs -->
+
+[npm-v-src]: https://img.shields.io/npm/v/pathe?style=flat-square
+[npm-v-href]: https://npmjs.com/package/pathe
+[npm-d-src]: https://img.shields.io/npm/dm/pathe?style=flat-square
+[npm-d-href]: https://npmjs.com/package/pathe
+[github-actions-src]: https://img.shields.io/github/workflow/status/unjs/pathe/ci/main?style=flat-square
+[github-actions-href]: https://github.com/unjs/pathe/actions?query=workflow%3Aci
+[size-src]: https://packagephobia.now.sh/badge?p=pathe
+[size-href]: https://packagephobia.now.sh/result?p=pathe

package/skills/void/docs/node_modules/void/node_modules/pg/README.md

@@ -0,0 +1,95 @@
+# node-postgres
+
+[![Build Status](https://secure.travis-ci.org/brianc/node-postgres.svg?branch=master)](http://travis-ci.org/brianc/node-postgres)
+<span class="badge-npmversion"><a href="https://npmjs.org/package/pg" title="View this project on NPM"><img src="https://img.shields.io/npm/v/pg.svg" alt="NPM version" /></a></span>
+<span class="badge-npmdownloads"><a href="https://npmjs.org/package/pg" title="View this project on NPM"><img src="https://img.shields.io/npm/dm/pg.svg" alt="NPM downloads" /></a></span>
+
+Non-blocking PostgreSQL client for Node.js. Pure JavaScript and optional native libpq bindings.
+
+## Install
+
+```sh
+$ npm install pg
+```
+
+---
+
+## :star: [Documentation](https://node-postgres.com) :star:
+
+### Features
+
+- Pure JavaScript client and native libpq bindings share _the same API_
+- Connection pooling
+- Extensible JS ↔ PostgreSQL data-type coercion
+- Supported PostgreSQL features
+  - Parameterized queries
+  - Named statements with query plan caching
+  - Async notifications with `LISTEN/NOTIFY`
+  - Bulk import & export with `COPY TO/COPY FROM`
+
+### Extras
+
+node-postgres is by design pretty light on abstractions. These are some handy modules we've been using over the years to complete the picture.
+The entire list can be found on our [wiki](https://github.com/brianc/node-postgres/wiki/Extras).
+
+## Support
+
+node-postgres is free software. If you encounter a bug with the library please open an issue on the [GitHub repo](https://github.com/brianc/node-postgres). If you have questions unanswered by the documentation please open an issue pointing out how the documentation was unclear & I will do my best to make it better!
+
+When you open an issue please provide:
+
+- version of Node
+- version of Postgres
+- smallest possible snippet of code to reproduce the problem
+
+You can also follow me [@briancarlson](https://twitter.com/briancarlson) if that's your thing. I try to always announce noteworthy changes & developments with node-postgres on Twitter.
+
+## Sponsorship :two_hearts:
+
+node-postgres's continued development has been made possible in part by generous financial support from [the community](https://github.com/brianc/node-postgres/blob/master/SPONSORS.md).
+
+If you or your company are benefiting from node-postgres and would like to help keep the project financially sustainable [please consider supporting](https://github.com/sponsors/brianc) its development.
+
+### Featured sponsor
+
+Special thanks to [medplum](https://medplum.com) for their generous and thoughtful support of node-postgres!
+
+![medplum](https://raw.githubusercontent.com/medplum/medplum-logo/refs/heads/main/medplum-logo.png)
+
+## Contributing
+
+**:heart: contributions!**
+
+I will **happily** accept your pull request if it:
+
+- **has tests**
+- looks reasonable
+- does not break backwards compatibility
+
+If your change involves breaking backwards compatibility please please point that out in the pull request & we can discuss & plan when and how to release it and what type of documentation or communicate it will require.
+
+## Troubleshooting and FAQ
+
+The causes and solutions to common errors can be found among the [Frequently Asked Questions (FAQ)](https://github.com/brianc/node-postgres/wiki/FAQ)
+
+## License
+
+Copyright (c) 2010-2020 Brian Carlson (brian.m.carlson@gmail.com)
+
+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.

package/skills/void/docs/node_modules/void/node_modules/pglite-server/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Kamil Ogórek
+
+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.