npm - void - Versions diffs - 0.10.12 → 0.20.0 - Mend

void 0.10.12 → 0.20.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (431) hide show

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

@@ -1,398 +0,0 @@
-# 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/pathslash/README.md DELETED Viewed

@@ -1,64 +0,0 @@
-# pathslash
-> `node:path`, platform-correct, with forward-slash output.
-`pathslash` is a tiny wrapper around `node:path` that always outputs forward slashes (`/`) while keeping the correct per-platform semantics. It never reimplements path logic. Every function delegates to `node:path` and only flips the separators in the result.
-## Why
-- **Forward slashes everywhere.** On Windows, the `win32` functions output `/` instead of `\`, which is what bundlers, route maps, and URLs expect.
-- **Correct semantics for free.** Drive letters, UNC paths, and case-insensitive `relative` behave exactly as in `node:path`, because they _are_ `node:path`.
-- **POSIX-safe.** On POSIX, a backslash is a valid filename character, so it is never rewritten there.
-- **A typed drop-in.** Same API and types as `node:path`.
-## Install
-```sh
-npm i pathslash
-```
-## Usage
-The default export and the top-level named exports follow the host platform, exactly like `node:path`:
-```ts
-import path, { join } from "pathslash";
-join("src", "a.ts"); // 'src/a.ts'
-path.sep; // '/'
-```
-To force a specific platform, use the `win32` and `posix` namespaces. They work on any host OS:
-```ts
-import { win32, posix } from "pathslash";
-win32.join("C:\\a", "b"); // 'C:/a/b'  (forward slashes)
-win32.normalize("C:\\a\\..\\b"); // 'C:/b'
-win32.relative("C:/Foo/Bar", "C:/foo/baz"); // '../baz'  (case-insensitive)
-posix.join("a", "b\\c"); // 'a/b\\c'  (backslash kept)
-```
-### `toSlash(path)`
-Safely normalizes separators to `/`. On Windows it converts `\` to `/`. On POSIX it returns the path unchanged, because a backslash is a valid filename character there and rewriting it would corrupt the path. Use it for paths that come from outside this package, such as `process.cwd()`:
-```ts
-import { toSlash } from "pathslash";
-toSlash("C:\\a\\b"); // 'C:/a/b' on Windows, unchanged on POSIX
-```
-## Notes
-- `win32.sep` is `"/"` instead of `"\\"`, and `win32.delimiter` stays `";"`.
-- `\\?\` (extended-length) paths stay verbatim. `toSlash` and every `win32.*` function leave them untouched, because a forward slash is a literal character there, not a separator.
-- `toNamespacedPath` always returns a native, backslash path, since `\\?\` paths are only valid with backslashes.
-- `matchesGlob` mirrors `node:path`. It exists only on Node versions that ship it (22.5+) and is `undefined` on older ones.
-- The types are a drop-in too: `import type { ParsedPath, FormatInputPathObject, PlatformPath } from "pathslash"`.
-- Everything else matches `node:path`, separators aside.
-## License
-[MIT](./LICENSE)

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

@@ -1,96 +0,0 @@
-# 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
-- [Fastest PostgreSQL client for Node.js](https://github.com/nigrosimone/postgres-benchmarks)
-- 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 [@brianc](https://bsky.app/profile/brianc.bsky.social) on bluesky if that's your thing for updates on node-postgres with nearly zero non node-postgres content. My old twitter/x account is no longer used.
-## 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/README.md DELETED Viewed

@@ -1,135 +0,0 @@
-# Wire Protocol Server for PGlite
-> [!TIP]
-> If you are looking for more versatile and feature-rich solution, check [`pg-gateway`](https://github.com/supabase-community/pg-gateway) from [Supabase](https://supabase.com/) instead.
-A spare-time attempt to understand Postgres Wire Protocol and expose a TCP server,
-that can be used to redirect all client requests to [PGlite](https://github.com/electric-sql/pglite) instance.
-This can be used to connect to a running instance via `pgsql` or in the future,
-run a https://postgrest.org/ on top of said `PGlite` instance and automatically create a temporary, in-memory API endpoints.
-- https://www.postgresql.org/docs/current/protocol.html
-- https://www.postgresql.org/docs/current/protocol-message-formats.html
-It intercepts `SSLRequest` and `StartupMessage` messages to fake authentication flow and redirects all remaining packets directly to `PGlite` instance.
-## Usage
-```sh
-npm install pglite-server
-```
-```ts
-import { PGlite } from "@electric-sql/pglite";
-import { createServer } from "pglite-server";
-const db = new PGlite();
-await db.waitReady;
-await db.exec(`
-  create table if not exists test (id serial primary key, name text);
-  insert into test (name) values ('foo'), ('bar'), ('baz');
-`);
-const PORT = 5432;
-const pgServer = createServer(db);
-pgServer.listen(PORT, () => {
-  console.log(`Server bound to port ${PORT}`);
-});
-```
-```
-$ psql -h localhost -p 5432 -U postgres
-postgres=> select * from test;
-postgres=> \q
-```
-or without `db.exec` used above
-```
-$ psql -h localhost -p 5432 -U postgres
-postgres=> create table if not exists test (id serial primary key, name text);
-postgres=> insert into test (name) values ('foo'), ('bar'), ('baz');
-postgres=> select * from test;
-postgres=> \q
-```
-### Using with `pg` client
-See `test/main.ts` for more detailed example, but here's a quick excerpt:
-```ts
-import { PGlite } from "@electric-sql/pglite";
-import { Client } from "pg";
-import { createServer } from "pglite-server";
-const PORT = 5432;
-const db = new PGlite();
-await db.waitReady;
-await db.exec(`
-  create table if not exists test (id serial primary key, name text);
-  insert into test (name) values ('foo'), ('bar'), ('baz');
-`);
-const pgServer = createServer(db);
-pgServer.listen(PORT, async () => {
-  const client = new Client({
-    host: "localhost",
-    port: PORT,
-    database: "postgres",
-    user: "postgres",
-  });
-  await client.connect();
-  const res = await client.query("select * from test");
-  console.log(res.rows);
-});
-```
-### Options
-If you want to see all debug output of the network communication, set `logLevel` to `Debug`:
-```ts
-import { createServer, LogLevel } from "pglite-server";
-const pgServer = createServer(db, {
-  logLevel: LogLevel.Debug,
-});
-pgServer.listen();
-```
-## Developing
-This repo uses https://bun.sh/ because I don't want to spend time fighting with Node and TypeScript tooling.
-Make sure that it's available before running tests, or write your own ts-loader config, ts-node, or whatever people use these days.
-```sh
-bun run test
-bun run build
-```
-## Debugging
-Debugging network traffic with `tshark` - https://zignar.net/2022/09/24/using-tshark-to-monitor-pg-traffic/
-```sh
-brew install wireshark
-```
-```sh
-tshark -i lo -f 'tcp port 5432' -d tcp.port==5432,pgsql -T fields -e pgsql.length -e pgsql.type -e pgsql.query
-```
-## Publishing
-```
-npm version <patch|minor|major>
-git push
-bun run build
-npm publish
-```