Exodai/Arbejd.com-react
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial React project

Browse Source
This commit is contained in:
Johan
2026-03-23 07:49:45 +01:00
parent 8d33465f51
commit e204032b56
1353 changed files with 23853 additions and 50282 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
node_modules/@types/node/README.md generated vendored
View File

@@ -8,7 +8,7 @@ This package contains type definitions for node (https://nodejs.org/).
Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node/v24.
### Additional Details
* Last updated: Fri, 06 Mar 2026 05:19:15 GMT
* Last updated: Tue, 10 Feb 2026 14:48:58 GMT
* Dependencies: [undici-types](https://npmjs.com/package/undici-types)
# Credits

12
node_modules/@types/node/child_process.d.ts generated vendored
View File

@@ -5,7 +5,6 @@
*
* ```js
* import { spawn } from 'node:child_process';
* import { once } from 'node:events';
* const ls = spawn('ls', ['-lh', '/usr']);
*
* ls.stdout.on('data', (data) => {
@@ -16,8 +15,9 @@
* console.error(`stderr: ${data}`);
* });
*
* const [code] = await once(ls, 'close');
* console.log(`child process exited with code ${code}`);
* ls.on('close', (code) => {
* console.log(`child process exited with code ${code}`);
* });
* ```
*
* By default, pipes for `stdin`, `stdout`, and `stderr` are established between
@@ -719,7 +719,6 @@ declare module "child_process" {
*
* ```js
* import { spawn } from 'node:child_process';
* import { once } from 'node:events';
* const ls = spawn('ls', ['-lh', '/usr']);
*
* ls.stdout.on('data', (data) => {
@@ -730,8 +729,9 @@ declare module "child_process" {
* console.error(`stderr: ${data}`);
* });
*
* const [code] = await once(ls, 'close');
* console.log(`child process exited with code ${code}`);
* ls.on('close', (code) => {
* console.log(`child process exited with code ${code}`);
* });
* ```
*
* Example: A very elaborate way to run `ps ax | grep ssh`

16
node_modules/@types/node/crypto.d.ts generated vendored
View File

@@ -2709,12 +2709,12 @@ declare module "crypto" {
privateKey: T2;
}
/**
* Generates a new asymmetric key pair of the given `type`.
* See the supported [asymmetric key types](https://nodejs.org/docs/latest-v24.x/api/crypto.html#asymmetric-key-types).
* Generates a new asymmetric key pair of the given `type`. RSA, RSA-PSS, DSA, EC,
* Ed25519, Ed448, X25519, X448, DH, and ML-DSA are currently supported.
*
* If a `publicKeyEncoding` or `privateKeyEncoding` was specified, this function
* behaves as if {@link KeyObject.export `keyObject.export()`} had been called on its result. Otherwise,
* the respective part of the key is returned as a {@link KeyObject `KeyObject`}.
* behaves as if `keyObject.export()` had been called on its result. Otherwise,
* the respective part of the key is returned as a `KeyObject`.
*
* When encoding public keys, it is recommended to use `'spki'`. When encoding
* private keys, it is recommended to use `'pkcs8'` with a strong passphrase,
@@ -3007,12 +3007,12 @@ declare module "crypto" {
options?: SLHDSAKeyPairKeyObjectOptions,
): KeyPairKeyObjectResult;
/**
* Generates a new asymmetric key pair of the given `type`.
* See the supported [asymmetric key types](https://nodejs.org/docs/latest-v24.x/api/crypto.html#asymmetric-key-types).
* Generates a new asymmetric key pair of the given `type`. RSA, RSA-PSS, DSA, EC,
* Ed25519, Ed448, X25519, X448, and DH are currently supported.
*
* If a `publicKeyEncoding` or `privateKeyEncoding` was specified, this function
* behaves as if {@link KeyObject.export `keyObject.export()`} had been called on its result. Otherwise,
* the respective part of the key is returned as a {@link KeyObject `KeyObject`}.
* behaves as if `keyObject.export()` had been called on its result. Otherwise,
* the respective part of the key is returned as a `KeyObject`.
*
* It is recommended to encode public keys as `'spki'` and private keys as `'pkcs8'` with encryption for long-term storage:
*

42
node_modules/@types/node/http.d.ts generated vendored
View File

@@ -357,14 +357,6 @@ declare module "http" {
* @since v18.17.0, v20.2.0
*/
rejectNonStandardBodyWrites?: boolean | undefined;
/**
* If set to `true`, requests without `Content-Length` or `Transfer-Encoding` headers (indicating no body)
* will be initialized with an already-ended body stream, so they will never emit any stream events
* (like `'data'` or `'end'`). You can use `req.readableEnded` to detect this case.
* @default false
* @since v24.12.0
*/
optimizeEmptyRequests?: boolean | undefined;
}
type RequestListener<
Request extends typeof IncomingMessage = typeof IncomingMessage,
@@ -947,7 +939,7 @@ declare module "http" {
* been transmitted are equal or not.
*
* Attempting to set a header field name or value that contains invalid characters
* will result in a `Error` being thrown.
* will result in a \[`Error`\]\[\] being thrown.
* @since v0.1.30
*/
writeHead(
@@ -1028,7 +1020,6 @@ declare module "http" {
*
* ```js
* import http from 'node:http';
* const agent = new http.Agent({ keepAlive: true });
*
* // Server has a 5 seconds keep-alive timeout by default
* http
@@ -1670,31 +1661,20 @@ declare module "http" {
/**
* Produces a socket/stream to be used for HTTP requests.
*
* By default, this function behaves identically to `net.createConnection()`, synchronously
* returning the created socket. The optional `callback` parameter in the signature is not
* used by this default implementation.
* By default, this function is the same as `net.createConnection()`. However,
* custom agents may override this method in case greater flexibility is desired.
*
* However, custom agents may override this method to provide greater flexibility,
* for example, to create sockets asynchronously. When overriding `createConnection`:
* A socket/stream can be supplied in one of two ways: by returning the
* socket/stream from this function, or by passing the socket/stream to `callback`.
*
* 1. **Synchronous socket creation**: The overriding method can return the socket/stream directly.
* 2. **Asynchronous socket creation**: The overriding method can accept the `callback` and pass
* the created socket/stream to it (e.g., `callback(null, newSocket)`). If an error occurs during
* socket creation, it should be passed as the first argument to the `callback` (e.g., `callback(err)`).
* This method is guaranteed to return an instance of the `net.Socket` class,
* a subclass of `stream.Duplex`, unless the user specifies a socket
* type other than `net.Socket`.
*
* The agent will call the provided `createConnection` function with `options` and this internal
* `callback`. The `callback` provided by the agent has a signature of `(err, stream)`.
* `callback` has a signature of `(err, stream)`.
* @since v0.11.4
* @param options Options containing connection details. Check `net.createConnection()`
* for the format of the options. For custom agents, this object is passed
* to the custom `createConnection` function.
* @param callback (Optional, primarily for custom agents) A function to be called by a custom
* `createConnection` implementation when the socket is created, especially for
* asynchronous operations.
* @returns `stream.Duplex` The created socket. This is returned by the default implementation
* or by a custom synchronous `createConnection` implementation. If a
* custom `createConnection` uses the `callback` for asynchronous operation,
* this return value might not be the primary way to obtain the socket.
* @param options Options containing connection details. Check `createConnection` for the format of the options
* @param callback Callback function that receives the created socket
*/
createConnection(
options: ClientRequestArgs,

6
node_modules/@types/node/https.d.ts generated vendored
View File

@@ -25,12 +25,6 @@ declare module "https" {
}
/**
* An `Agent` object for HTTPS similar to `http.Agent`. See {@link request} for more information.
*
* Like `http.Agent`, the `createConnection(options[, callback])` method can be overridden to customize
* how TLS connections are established.
*
* > See [`agent.createConnection()`](https://nodejs.org/docs/latest-v24.x/api/http.html#agentcreateconnectionoptions-callback)
* for details on overriding this method, including asynchronous socket creation with a callback.
* @since v0.4.5
*/
class Agent extends http.Agent {

15
node_modules/@types/node/inspector.generated.d.ts generated vendored
View File

@@ -1791,18 +1791,6 @@ declare module "inspector" {
*/
headers: Headers;
}
interface EnableParameterType {
/**
* Buffer size in bytes to use when preserving network payloads (XHRs, etc).
* @experimental
*/
maxTotalBufferSize?: number | undefined;
/**
* Per-resource buffer size in bytes to use when preserving network payloads (XHRs, etc).
* @experimental
*/
maxResourceBufferSize?: number | undefined;
}
interface GetRequestPostDataParameterType {
/**
* Identifier of the network request to get content for.
@@ -2391,7 +2379,6 @@ declare module "inspector" {
/**
* Enables network tracking, network events will now be delivered to the client.
*/
post(method: "Network.enable", params?: Network.EnableParameterType, callback?: (err: Error | null) => void): void;
post(method: "Network.enable", callback?: (err: Error | null) => void): void;
/**
* Returns post data sent with the request. Returns an error when no data was sent with the request.
@@ -3490,7 +3477,7 @@ declare module "inspector/promises" {
/**
* Enables network tracking, network events will now be delivered to the client.
*/
post(method: "Network.enable", params?: Network.EnableParameterType): Promise<void>;
post(method: "Network.enable"): Promise<void>;
/**
* Returns post data sent with the request. Returns an error when no data was sent with the request.
*/

43
node_modules/@types/node/module.d.ts generated vendored
View File

@@ -80,48 +80,37 @@ declare module "module" {
*/
directory?: string;
}
interface EnableCompileCacheOptions {
/**
* Optional. Directory to store the compile cache. If not specified, the directory specified by
* the [`NODE_COMPILE_CACHE=dir`](https://nodejs.org/docs/latest-v24.x/api/cli.html#node_compile_cachedir)
* environment variable will be used if it's set, or `path.join(os.tmpdir(), 'node-compile-cache')` otherwise.
* @since v24.12.0
*/
directory?: string | undefined;
/**
* Optional. If `true`, enables portable compile cache so that the cache can be reused even if the project directory
* is moved. This is a best-effort feature. If not specified, it will depend on whether the environment variable
* [NODE_COMPILE_CACHE_PORTABLE=1](https://nodejs.org/docs/latest-v24.x/api/cli.html#node_compile_cache_portable1) is set.
* @since v24.12.0
*/
portable?: boolean | undefined;
}
/**
* Enable [module compile cache](https://nodejs.org/docs/latest-v24.x/api/module.html#module-compile-cache)
* in the current Node.js instance.
*
* For general use cases, it's recommended to call `module.enableCompileCache()` without specifying the
* `options.directory`, so that the directory can be overridden by the `NODE_COMPILE_CACHE` environment
* If `cacheDir` is not specified, Node.js will either use the directory specified by the
* `NODE_COMPILE_CACHE=dir` environment variable if it's set, or use
* `path.join(os.tmpdir(), 'node-compile-cache')` otherwise. For general use cases, it's
* recommended to call `module.enableCompileCache()` without specifying the `cacheDir`,
* so that the directory can be overridden by the `NODE_COMPILE_CACHE` environment
* variable when necessary.
*
* Since compile cache is supposed to be a optimization that is not mission critical, this method is
* designed to not throw any exception when the compile cache cannot be enabled. Instead, it will return
* an object containing an error message in the `message` field to aid debugging. If compile cache is
* enabled successfully, the `directory` field in the returned object contains the path to the directory
* where the compile cache is stored. The `status` field in the returned object would be one of the
* `module.constants.compileCacheStatus` values to indicate the result of the attempt to enable the
* Since compile cache is supposed to be a quiet optimization that is not required for the
* application to be functional, this method is designed to not throw any exception when the
* compile cache cannot be enabled. Instead, it will return an object containing an error
* message in the `message` field to aid debugging.
* If compile cache is enabled successfully, the `directory` field in the returned object
* contains the path to the directory where the compile cache is stored. The `status`
* field in the returned object would be one of the `module.constants.compileCacheStatus`
* values to indicate the result of the attempt to enable the
* [module compile cache](https://nodejs.org/docs/latest-v24.x/api/module.html#module-compile-cache).
*
* This method only affects the current Node.js instance. To enable it in child worker threads,
* either call this method in child worker threads too, or set the
* `process.env.NODE_COMPILE_CACHE` value to compile cache directory so the behavior can
* be inherited into the child workers. The directory can be obtained either from the
* `directory` field returned by this method, or with {@link getCompileCacheDir `module.getCompileCacheDir()`}.
* `directory` field returned by this method, or with {@link getCompileCacheDir}.
* @since v22.8.0
* @param options Optional. If a string is passed, it is considered to be `options.directory`.
* @param cacheDir Optional path to specify the directory where the compile cache
* will be stored/retrieved.
*/
function enableCompileCache(options?: string | EnableCompileCacheOptions): EnableCompileCacheResult;
function enableCompileCache(cacheDir?: string): EnableCompileCacheResult;
/**
* Flush the [module compile cache](https://nodejs.org/docs/latest-v24.x/api/module.html#module-compile-cache)
* accumulated from modules already loaded

4
node_modules/@types/node/package.json generated vendored
View File

@@ -1,6 +1,6 @@
{
"name": "@types/node",
"version": "24.12.0",
"version": "24.10.13",
"description": "TypeScript definitions for node",
"homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
"license": "MIT",
@@ -150,6 +150,6 @@
"undici-types": "~7.16.0"
},
"peerDependencies": {},
"typesPublisherContentHash": "2bd5c87e6ae2c44201cb3aab9e54edcee1ed9555c740d1b7788d5f9e9defded9",
"typesPublisherContentHash": "2ec3065bf306401d19db2ee65619ca53b48d5461db1133c7eeb53d407b8dcbc8",
"typeScriptVersion": "5.2"
}

190
node_modules/@types/node/perf_hooks.d.ts generated vendored
View File

@@ -200,6 +200,14 @@ declare module "perf_hooks" {
active: number;
utilization: number;
}
/**
* @param utilization1 The result of a previous call to `eventLoopUtilization()`.
* @param utilization2 The result of a previous call to `eventLoopUtilization()` prior to `utilization1`.
*/
type EventLoopUtilityFunction = (
utilization1?: EventLoopUtilization,
utilization2?: EventLoopUtilization,
) => EventLoopUtilization;
interface MarkOptions {
/**
* Additional optional detail to include with the mark.
@@ -256,19 +264,11 @@ declare module "perf_hooks" {
*/
clearResourceTimings(name?: string): void;
/**
* This is an alias of `perf_hooks.eventLoopUtilization()`.
*
* _This property is an extension by Node.js. It is not available in Web browsers._
* @since v14.10.0, v12.19.0
* @param utilization1 The result of a previous call to
* `eventLoopUtilization()`.
* @param utilization2 The result of a previous call to
* `eventLoopUtilization()` prior to `utilization1`.
* eventLoopUtilization is similar to CPU utilization except that it is calculated using high precision wall-clock time.
* It represents the percentage of time the event loop has spent outside the event loop's event provider (e.g. epoll_wait).
* No other CPU idle time is taken into consideration.
*/
eventLoopUtilization(
utilization1?: EventLoopUtilization,
utilization2?: EventLoopUtilization,
): EventLoopUtilization;
eventLoopUtilization: EventLoopUtilityFunction;
/**
* Returns a list of `PerformanceEntry` objects in chronological order with respect to `performanceEntry.startTime`.
* If you are only interested in performance entries of certain types or that have certain names, see
@@ -371,12 +371,41 @@ declare module "perf_hooks" {
*/
readonly timeOrigin: number;
/**
* This is an alias of `perf_hooks.timerify()`.
*
* _This property is an extension by Node.js. It is not available in Web browsers._
* @since v8.5.0
*
* Wraps a function within a new function that measures the running time of the wrapped function.
* A `PerformanceObserver` must be subscribed to the `'function'` event type in order for the timing details to be accessed.
*
* ```js
* import {
* performance,
* PerformanceObserver,
* } from 'node:perf_hooks';
*
* function someFunction() {
* console.log('hello world');
* }
*
* const wrapped = performance.timerify(someFunction);
*
* const obs = new PerformanceObserver((list) => {
* console.log(list.getEntries()[0].duration);
*
* performance.clearMarks();
* performance.clearMeasures();
* obs.disconnect();
* });
* obs.observe({ entryTypes: ['function'] });
*
* // A performance timeline entry will be created
* wrapped();
* ```
*
* If the wrapped function returns a promise, a finally handler will be attached to the promise and the duration will be reported
* once the finally handler is invoked.
* @param fn
*/
timerify<T extends (...args: any[]) => any>(fn: T, options?: TimerifyOptions): T;
timerify<T extends (...params: any[]) => any>(fn: T, options?: TimerifyOptions): T;
/**
* An object which is JSON representation of the performance object. It is similar to
* [`window.performance.toJSON`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/toJSON) in browsers.
@@ -815,83 +844,6 @@ declare module "perf_hooks" {
*/
add(other: RecordableHistogram): void;
}
interface CreateHistogramOptions {
/**
* The lowest discernible value. Must be an integer value greater than 0.
* @default 1
*/
lowest?: number | bigint | undefined;
/**
* The highest recordable value. Must be an integer value that is equal to
* or greater than two times `lowest`.
* @default Number.MAX_SAFE_INTEGER
*/
highest?: number | bigint | undefined;
/**
* The number of accuracy digits. Must be a number between `1` and `5`.
* @default 3
*/
figures?: number | undefined;
}
/**
* Returns a {@link RecordableHistogram `RecordableHistogram`}.
* @since v15.9.0, v14.18.0
*/
function createHistogram(options?: CreateHistogramOptions): RecordableHistogram;
/**
* The `eventLoopUtilization()` function returns an object that contains the
* cumulative duration of time the event loop has been both idle and active as a
* high resolution milliseconds timer. The `utilization` value is the calculated
* Event Loop Utilization (ELU).
*
* If bootstrapping has not yet finished on the main thread the properties have
* the value of `0`. The ELU is immediately available on
* [Worker threads](https://nodejs.org/docs/latest-v24.x/api/worker_threads.html#worker-threads)
* since bootstrap happens within the event loop.
*
* Both `utilization1` and `utilization2` are optional parameters.
*
* If `utilization1` is passed, then the delta between the current call's `active`
* and `idle` times, as well as the corresponding `utilization` value are
* calculated and returned (similar to `process.hrtime()`).
*
* If `utilization1` and `utilization2` are both passed, then the delta is
* calculated between the two arguments. This is a convenience option because,
* unlike `process.hrtime()`, calculating the ELU is more complex than a
* single subtraction.
*
* ELU is similar to CPU utilization, except that it only measures event loop
* statistics and not CPU usage. It represents the percentage of time the event
* loop has spent outside the event loop's event provider (e.g. `epoll_wait`).
* No other CPU idle time is taken into consideration. The following is an example
* of how a mostly idle process will have a high ELU.
*
* ```js
* import { eventLoopUtilization } from 'node:perf_hooks';
* import { spawnSync } from 'node:child_process';
*
* setImmediate(() => {
* const elu = eventLoopUtilization();
* spawnSync('sleep', ['5']);
* console.log(eventLoopUtilization(elu).utilization);
* });
* ```
*
* Although the CPU is mostly idle while running this script, the value of `utilization`
* is `1`. This is because the call to `child_process.spawnSync()` blocks the event loop
* from proceeding.
*
* Passing in a user-defined object instead of the result of a previous call to
* `eventLoopUtilization()` will lead to undefined behavior. The return values are not
* guaranteed to reflect any correct state of the event loop.
* @since v24.12.0
* @param utilization1 The result of a previous call to `eventLoopUtilization()`.
* @param utilization2 The result of a previous call to `eventLoopUtilization()` prior to `utilization1`.
*/
function eventLoopUtilization(
utilization1?: EventLoopUtilization,
utilization2?: EventLoopUtilization,
): EventLoopUtilization;
/**
* _This property is an extension by Node.js. It is not available in Web browsers._
*
@@ -921,40 +873,28 @@ declare module "perf_hooks" {
* @since v11.10.0
*/
function monitorEventLoopDelay(options?: EventLoopMonitorOptions): IntervalHistogram;
interface CreateHistogramOptions {
/**
* The minimum recordable value. Must be an integer value greater than 0.
* @default 1
*/
lowest?: number | bigint | undefined;
/**
* The maximum recordable value. Must be an integer value greater than min.
* @default Number.MAX_SAFE_INTEGER
*/
highest?: number | bigint | undefined;
/**
* The number of accuracy digits. Must be a number between 1 and 5.
* @default 3
*/
figures?: number | undefined;
}
/**
* _This property is an extension by Node.js. It is not available in Web browsers._
*
* Wraps a function within a new function that measures the running time of the
* wrapped function. A `PerformanceObserver` must be subscribed to the `'function'`
* event type in order for the timing details to be accessed.
*
* ```js
* import { timerify, performance, PerformanceObserver } from 'node:perf_hooks';
*
* function someFunction() {
* console.log('hello world');
* }
*
* const wrapped = timerify(someFunction);
*
* const obs = new PerformanceObserver((list) => {
* console.log(list.getEntries()[0].duration);
*
* performance.clearMarks();
* performance.clearMeasures();
* obs.disconnect();
* });
* obs.observe({ entryTypes: ['function'] });
*
* // A performance timeline entry will be created
* wrapped();
* ```
*
* If the wrapped function returns a promise, a finally handler will be attached
* to the promise and the duration will be reported once the finally handler is invoked.
* @since v24.12.0
* Returns a `RecordableHistogram`.
* @since v15.9.0, v14.18.0
*/
function timerify<T extends (...params: any[]) => any>(fn: T, options?: TimerifyOptions): T;
function createHistogram(options?: CreateHistogramOptions): RecordableHistogram;
import {
performance as _performance,
PerformanceEntry as _PerformanceEntry,

9
node_modules/@types/node/process.d.ts generated vendored
View File

@@ -235,7 +235,7 @@ declare module "process" {
/**
* A value that is `"strip"` by default,
* `"transform"` if Node.js is run with `--experimental-transform-types`, and `false` if
* Node.js is run with `--no-strip-types`.
* Node.js is run with `--no-experimental-strip-types`.
* @since v22.10.0
*/
readonly typescript: "strip" | "transform" | false;
@@ -344,7 +344,12 @@ declare module "process" {
isTTY?: true | undefined;
}
// Alias for compatibility
interface ProcessEnv extends Dict<string> {}
interface ProcessEnv extends Dict<string> {
/**
* Can be used to change the default timezone at runtime
*/
TZ?: string | undefined;
}
interface HRTime {
/**
* This is the legacy version of {@link process.hrtime.bigint()}

41
node_modules/@types/node/sqlite.d.ts generated vendored
View File

@@ -6,7 +6,12 @@
* import sqlite from 'node:sqlite';
* ```
*
* This module is only available under the `node:` scheme.
* This module is only available under the `node:` scheme. The following will not
* work:
*
* ```js
* import sqlite from 'sqlite';
* ```
*
* The following example shows the basic usage of the `node:sqlite` module to open
* an in-memory database, write data to the database, and then read the data back.
@@ -118,14 +123,6 @@ declare module "node:sqlite" {
* @default false
*/
allowUnknownNamedParameters?: boolean | undefined;
/**
* If `true`, enables the defensive flag. When the defensive flag is enabled,
* language features that allow ordinary SQL to deliberately corrupt the database
* file are disabled. The defensive flag can also be set using `enableDefensive()`.
* @since v24.12.0
* @default true
*/
defensive?: boolean | undefined;
}
interface CreateSessionOptions {
/**
@@ -297,16 +294,6 @@ declare module "node:sqlite" {
* @param allow Whether to allow loading extensions.
*/
enableLoadExtension(allow: boolean): void;
/**
* Enables or disables the defensive flag. When the defensive flag is active,
* language features that allow ordinary SQL to deliberately corrupt the
* database file are disabled.
* See [`SQLITE_DBCONFIG_DEFENSIVE`](https://www.sqlite.org/c3ref/c_dbconfig_defensive.html#sqlitedbconfigdefensive)
* in the SQLite documentation for details.
* @since v24.12.0
* @param active Whether to set the defensive flag.
*/
enableDefensive(active: boolean): void;
/**
* This method is a wrapper around [`sqlite3_db_filename()`](https://sqlite.org/c3ref/db_filename.html)
* @since v24.0.0
@@ -426,7 +413,7 @@ declare module "node:sqlite" {
*/
prepare(sql: string): StatementSync;
/**
* Creates a new {@link SQLTagStore `SQLTagStore`}, which is an LRU (Least Recently Used) cache for
* Creates a new `SQLTagStore`, which is an LRU (Least Recently Used) cache for
* storing prepared statements. This allows for the efficient reuse of prepared
* statements by tagging them with a unique identifier.
*
@@ -440,7 +427,7 @@ declare module "node:sqlite" {
* import { DatabaseSync } from 'node:sqlite';
*
* const db = new DatabaseSync(':memory:');
* const sql = db.createTagStore();
* const sql = db.createSQLTagStore();
*
* db.exec('CREATE TABLE users (id INT, name TEXT)');
*
@@ -463,7 +450,6 @@ declare module "node:sqlite" {
* // ]
* ```
* @since v24.9.0
* @param maxSize The maximum number of prepared statements to cache. **Default**: `1000`.
* @returns A new SQL tag store for caching prepared statements.
*/
createTagStore(maxSize?: number): SQLTagStore;
@@ -482,8 +468,6 @@ declare module "node:sqlite" {
* [`sqlite3changeset_apply()`](https://www.sqlite.org/session/sqlite3changeset_apply.html).
*
* ```js
* import { DatabaseSync } from 'node:sqlite';
*
* const sourceDb = new DatabaseSync(':memory:');
* const targetDb = new DatabaseSync(':memory:');
*
@@ -541,24 +525,19 @@ declare module "node:sqlite" {
* [`sqlite3session_delete()`](https://www.sqlite.org/session/sqlite3session_delete.html).
*/
close(): void;
/**
* Closes the session. If the session is already closed, does nothing.
* @since v24.9.0
*/
[Symbol.dispose](): void;
}
/**
* This class represents a single LRU (Least Recently Used) cache for storing
* prepared statements.
*
* Instances of this class are created via the database.createTagStore() method,
* Instances of this class are created via the database.createSQLTagStore() method,
* not by using a constructor. The store caches prepared statements based on the
* provided SQL query string. When the same query is seen again, the store
* retrieves the cached statement and safely applies the new values through
* parameter binding, thereby preventing attacks like SQL injection.
*
* The cache has a maxSize that defaults to 1000 statements, but a custom size can
* be provided (e.g., database.createTagStore(100)). All APIs exposed by this
* be provided (e.g., database.createSQLTagStore(100)). All APIs exposed by this
* class execute synchronously.
* @since v24.9.0
*/

14
node_modules/@types/node/tls.d.ts generated vendored
View File

@@ -15,31 +15,31 @@ declare module "tls" {
import * as stream from "stream";
const CLIENT_RENEG_LIMIT: number;
const CLIENT_RENEG_WINDOW: number;
interface Certificate extends NodeJS.Dict<string | string[]> {
interface Certificate {
/**
* Country code.
*/
C?: string | string[];
C: string;
/**
* Street.
*/
ST?: string | string[];
ST: string;
/**
* Locality.
*/
L?: string | string[];
L: string;
/**
* Organization.
*/
O?: string | string[];
O: string;
/**
* Organizational unit.
*/
OU?: string | string[];
OU: string;
/**
* Common name.
*/
CN?: string | string[];
CN: string;
}
interface PeerCertificate {
/**

4
node_modules/@types/node/url.d.ts generated vendored
View File

@@ -80,7 +80,7 @@ declare module "url" {
* function getURL(req) {
* const proto = req.headers['x-forwarded-proto'] || 'https';
* const host = req.headers['x-forwarded-host'] || req.headers.host || 'example.com';
* return new URL(`${proto}://${host}${req.url || '/'}`);
* return new URL(req.url || '/', `${proto}://${host}`);
* }
* ```
*
@@ -90,7 +90,7 @@ declare module "url" {
*
* ```js
* function getURL(req) {
* return new URL(`https://example.com${req.url || '/'}`);
* return new URL(req.url || '/', 'https://example.com');
* }
* ```
* @since v0.1.25

10
node_modules/@types/node/util.d.ts generated vendored
View File

@@ -792,14 +792,6 @@ declare module "util" {
*/
export function debuglog(section: string, callback?: (fn: DebugLoggerFunction) => void): DebugLogger;
export { debuglog as debug };
export interface DeprecateOptions {
/**
* When false do not change the prototype of object while emitting the deprecation warning.
* @since v24.12.0
* @default true
*/
modifyPrototype?: boolean | undefined;
}
/**
* The `util.deprecate()` method wraps `fn` (which may be a function or class) in
* such a way that it is marked as deprecated.
@@ -860,7 +852,7 @@ declare module "util" {
* @param code A deprecation code. See the `list of deprecated APIs` for a list of codes.
* @return The deprecated function wrapped to emit a warning.
*/
export function deprecate<T extends Function>(fn: T, msg: string, code?: string, options?: DeprecateOptions): T;
export function deprecate<T extends Function>(fn: T, msg: string, code?: string): T;
export interface IsDeepStrictEqualOptions {
/**
* If `true`, prototype and constructor

26
node_modules/@types/node/v8.d.ts generated vendored
View File

@@ -401,21 +401,6 @@ declare module "v8" {
* @since v12.8.0
*/
function getHeapCodeStatistics(): HeapCodeStatistics;
/**
* @since v24.12.0
*/
interface SyncCPUProfileHandle {
/**
* Stopping collecting the profile and return the profile data.
* @since v24.12.0
*/
stop(): string;
/**
* Stopping collecting the profile and the profile will be discarded.
* @since v24.12.0
*/
[Symbol.dispose](): void;
}
/**
* @since v24.8.0
*/
@@ -481,17 +466,6 @@ declare module "v8" {
* @since v23.10.0, v22.15.0
*/
function isStringOneByteRepresentation(content: string): boolean;
/**
* Starting a CPU profile then return a `SyncCPUProfileHandle` object. This API supports `using` syntax.
*
* ```js
* const handle = v8.startCpuProfile();
* const profile = handle.stop();
* console.log(profile);
* ```
* @since v24.12.0
*/
function startCpuProfile(): SyncCPUProfileHandle;
/**
* @since v8.0.0
*/

39
node_modules/@types/node/vm.d.ts generated vendored
View File

@@ -748,8 +748,8 @@ declare module "vm" {
* // The "secret" variable refers to the global variable we added to
* // "contextifiedObject" when creating the context.
* export default secret;
* `, { context: module.context });
* moduleMap.set(specifier, requestedModule);
* `, { context: referencingModule.context });
* moduleMap.set(specifier, linkedModule);
* // Resolve the dependencies of the new module as well.
* resolveAndLinkDependencies(requestedModule);
* }
@@ -819,34 +819,19 @@ declare module "vm" {
*/
status: ModuleStatus;
/**
* Evaluate the module and its depenendencies. Corresponds to the [Evaluate() concrete method](https://tc39.es/ecma262/#sec-moduleevaluation)
* field of [Cyclic Module Record](https://tc39.es/ecma262/#sec-cyclic-module-records)s in the ECMAScript specification.
* Evaluate the module.
*
* If the module is a `vm.SourceTextModule`, `evaluate()` must be called after the module has been instantiated;
* otherwise `evaluate()` will return a rejected promise.
* This must be called after the module has been linked; otherwise it will reject.
* It could be called also when the module has already been evaluated, in which
* case it will either do nothing if the initial evaluation ended in success
* (`module.status` is `'evaluated'`) or it will re-throw the exception that the
* initial evaluation resulted in (`module.status` is `'errored'`).
*
* For a `vm.SourceTextModule`, the promise returned by `evaluate()` may be fulfilled either synchronously or asynchronously:
* 1. If the `vm.SourceTextModule` has no top-level `await` in itself or any of its dependencies, the promise will be
* fulfilled synchronously after the module and all its dependencies have been evaluated.
* 1. If the evaluation succeeds, the promise will be _synchronously_ resolved to `undefined`.
* 2. If the evaluation results in an exception, the promise will be _synchronously_ rejected with the exception that causes the evaluation to fail, which is the same as `module.error`.
* 2. If the `vm.SourceTextModule` has top-level `await` in itself or any of its dependencies, the promise will be fulfilled asynchronously after the module and all its dependencies have been evaluated.
* 1. If the evaluation succeeds, the promise will be _asynchronously_ resolved to `undefined`.
* 2. If the evaluation results in an exception, the promise will be _asynchronously_ rejected with the exception that causes the evaluation to fail.
* This method cannot be called while the module is being evaluated
* (`module.status` is `'evaluating'`).
*
* If the module is a `vm.SyntheticModule`, `evaluate()` always returns a promise that fulfills synchronously,
* see the specification of [Evaluate() of a Synthetic Module Record](https://tc39.es/ecma262/#sec-smr-Evaluate):
* 1. If the `evaluateCallback` passed to its constructor throws an exception synchronously, `evaluate()` returns a promise that will be synchronously rejected with that exception.
* 2. If the `evaluateCallback` does not throw an exception, `evaluate()` returns a promise that will be synchronously resolved to `undefined`.
*
* The `evaluateCallback` of a `vm.SyntheticModule` is executed synchronously within the `evaluate()` call, and its return value is discarded. This means if `evaluateCallback` is an asynchronous function, the promise
* returned by `evaluate()` will not reflect its asynchronous behavior, and any rejections from an asynchronous `evaluateCallback` will be lost.
*
* evaluate() could also be called again after the module has already been evaluated, in which case:
* 1. If the initial evaluation ended in success (`module.status` is `'evaluated'`), it will do nothing and return a promise that resolves to `undefined`.
* 2. If the initial evaluation resulted in an exception (`module.status` is `'errored'`), it will re-reject the exception that the initial evaluation resulted in.
*
* This method cannot be called while the module is being evaluated (`module.status` is `'evaluating'`).
* Corresponds to the [Evaluate() concrete method](https://tc39.es/ecma262/#sec-moduleevaluation) field of [Cyclic Module Record](https://tc39.es/ecma262/#sec-cyclic-module-records) s in the
* ECMAScript specification.
* @return Fulfills with `undefined` upon success.
*/
evaluate(options?: ModuleEvaluateOptions): Promise<void>;

36
node_modules/@types/node/worker_threads.d.ts generated vendored
View File

@@ -3,7 +3,7 @@
* JavaScript in parallel. To access it:
*
* ```js
* import worker_threads from 'node:worker_threads';
* import worker from 'node:worker_threads';
* ```
*
* Workers (threads) are useful for performing CPU-intensive JavaScript operations.
@@ -57,8 +57,8 @@
declare module "worker_threads" {
import { Context } from "node:vm";
import { EventEmitter, NodeEventTarget } from "node:events";
import { EventLoopUtilityFunction } from "node:perf_hooks";
import { FileHandle } from "node:fs/promises";
import { Performance } from "node:perf_hooks";
import { Readable, Writable } from "node:stream";
import { ReadableStream, TransformStream, WritableStream } from "node:stream/web";
import { URL } from "node:url";
@@ -91,7 +91,9 @@ declare module "worker_threads" {
readonly port1: MessagePort;
readonly port2: MessagePort;
}
interface WorkerPerformance extends Pick<Performance, "eventLoopUtilization"> {}
interface WorkerPerformance {
eventLoopUtilization: EventLoopUtilityFunction;
}
type Transferable =
| ArrayBuffer
| MessagePort
@@ -408,7 +410,7 @@ declare module "worker_threads" {
readonly resourceLimits?: ResourceLimits | undefined;
/**
* An object that can be used to query performance information from a worker
* instance.
* instance. Similar to `perf_hooks.performance`.
* @since v15.1.0, v14.17.0, v12.22.0
*/
readonly performance: WorkerPerformance;
@@ -444,8 +446,8 @@ declare module "worker_threads" {
*/
terminate(): Promise<number>;
/**
* This method returns a `Promise` that will resolve to an object identical to {@link process.threadCpuUsage()},
* or reject with an [`ERR_WORKER_NOT_RUNNING`](https://nodejs.org/docs/latest-v24.x/api/errors.html#err_worker_not_running) error if the worker is no longer running.
* This method returns a `Promise` that will resolve to an object identical to `process.threadCpuUsage()`,
* or reject with an `ERR_WORKER_NOT_RUNNING` error if the worker is no longer running.
* This methods allows the statistics to be observed from outside the actual thread.
* @since v24.6.0
*/
@@ -554,49 +556,49 @@ declare module "worker_threads" {
* @since v24.2.0
*/
[Symbol.asyncDispose](): Promise<void>;
addListener(event: "error", listener: (err: any) => void): this;
addListener(event: "error", listener: (err: Error) => void): this;
addListener(event: "exit", listener: (exitCode: number) => void): this;
addListener(event: "message", listener: (value: any) => void): this;
addListener(event: "messageerror", listener: (error: Error) => void): this;
addListener(event: "online", listener: () => void): this;
addListener(event: string | symbol, listener: (...args: any[]) => void): this;
emit(event: "error", err: any): boolean;
emit(event: "error", err: Error): boolean;
emit(event: "exit", exitCode: number): boolean;
emit(event: "message", value: any): boolean;
emit(event: "messageerror", error: Error): boolean;
emit(event: "online"): boolean;
emit(event: string | symbol, ...args: any[]): boolean;
on(event: "error", listener: (err: any) => void): this;
on(event: "error", listener: (err: Error) => void): this;
on(event: "exit", listener: (exitCode: number) => void): this;
on(event: "message", listener: (value: any) => void): this;
on(event: "messageerror", listener: (error: Error) => void): this;
on(event: "online", listener: () => void): this;
on(event: string | symbol, listener: (...args: any[]) => void): this;
once(event: "error", listener: (err: any) => void): this;
once(event: "error", listener: (err: Error) => void): this;
once(event: "exit", listener: (exitCode: number) => void): this;
once(event: "message", listener: (value: any) => void): this;
once(event: "messageerror", listener: (error: Error) => void): this;
once(event: "online", listener: () => void): this;
once(event: string | symbol, listener: (...args: any[]) => void): this;
prependListener(event: "error", listener: (err: any) => void): this;
prependListener(event: "error", listener: (err: Error) => void): this;
prependListener(event: "exit", listener: (exitCode: number) => void): this;
prependListener(event: "message", listener: (value: any) => void): this;
prependListener(event: "messageerror", listener: (error: Error) => void): this;
prependListener(event: "online", listener: () => void): this;
prependListener(event: string | symbol, listener: (...args: any[]) => void): this;
prependOnceListener(event: "error", listener: (err: any) => void): this;
prependOnceListener(event: "error", listener: (err: Error) => void): this;
prependOnceListener(event: "exit", listener: (exitCode: number) => void): this;
prependOnceListener(event: "message", listener: (value: any) => void): this;
prependOnceListener(event: "messageerror", listener: (error: Error) => void): this;
prependOnceListener(event: "online", listener: () => void): this;
prependOnceListener(event: string | symbol, listener: (...args: any[]) => void): this;
removeListener(event: "error", listener: (err: any) => void): this;
removeListener(event: "error", listener: (err: Error) => void): this;
removeListener(event: "exit", listener: (exitCode: number) => void): this;
removeListener(event: "message", listener: (value: any) => void): this;
removeListener(event: "messageerror", listener: (error: Error) => void): this;
removeListener(event: "online", listener: () => void): this;
removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
off(event: "error", listener: (err: any) => void): this;
off(event: "error", listener: (err: Error) => void): this;
off(event: "exit", listener: (exitCode: number) => void): this;
off(event: "message", listener: (value: any) => void): this;
off(event: "messageerror", listener: (error: Error) => void): this;
@@ -689,7 +691,7 @@ declare module "worker_threads" {
var locks: LockManager;
/**
* Mark an object as not transferable. If `object` occurs in the transfer list of
* a {@link MessagePort.postMessage port.postMessage()} call, it is ignored.
* a `port.postMessage()` call, it is ignored.
*
* In particular, this makes sense for objects that can be cloned, rather than
* transferred, and which are used by other objects on the sending side.
@@ -811,13 +813,13 @@ declare module "worker_threads" {
*
* if (isMainThread) {
* setEnvironmentData('Hello', 'World!');
* const worker = new Worker(new URL(import.meta.url));
* const worker = new Worker(__filename);
* } else {
* console.log(getEnvironmentData('Hello')); // Prints 'World!'.
* }
* ```
* @since v15.12.0, v14.18.0
* @param key Any arbitrary, cloneable JavaScript value that can be used as a {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map Map} key.
* @param key Any arbitrary, cloneable JavaScript value that can be used as a {Map} key.
*/
function getEnvironmentData(key: Serializable): Serializable;
/**

72
node_modules/@types/node/zlib.d.ts generated vendored
View File

@@ -108,14 +108,10 @@ declare module "zlib" {
*/
chunkSize?: number | undefined;
windowBits?: number | undefined;
/** compression only */
level?: number | undefined;
/** compression only */
memLevel?: number | undefined;
/** compression only */
strategy?: number | undefined;
/** deflate/inflate only, empty dictionary by default */
dictionary?: NodeJS.ArrayBufferView | ArrayBuffer | undefined;
level?: number | undefined; // compression only
memLevel?: number | undefined; // compression only
strategy?: number | undefined; // compression only
dictionary?: NodeJS.ArrayBufferView | ArrayBuffer | undefined; // deflate/inflate only, empty dictionary by default
/**
* If `true`, returns an object with `buffer` and `engine`.
*/
@@ -205,84 +201,24 @@ declare module "zlib" {
interface ZlibReset {
reset(): void;
}
/**
* @since v10.16.0
*/
class BrotliCompress extends stream.Transform {
constructor(options?: BrotliOptions);
}
interface BrotliCompress extends stream.Transform, Zlib {}
/**
* @since v10.16.0
*/
class BrotliDecompress extends stream.Transform {
constructor(options?: BrotliOptions);
}
interface BrotliDecompress extends stream.Transform, Zlib {}
/**
* @since v0.5.8
*/
class Gzip extends stream.Transform {
constructor(options?: ZlibOptions);
}
interface Gzip extends stream.Transform, Zlib {}
/**
* @since v0.5.8
*/
class Gunzip extends stream.Transform {
constructor(options?: ZlibOptions);
}
interface Gunzip extends stream.Transform, Zlib {}
/**
* @since v0.5.8
*/
class Deflate extends stream.Transform {
constructor(options?: ZlibOptions);
}
interface Deflate extends stream.Transform, Zlib, ZlibReset, ZlibParams {}
/**
* @since v0.5.8
*/
class Inflate extends stream.Transform {
constructor(options?: ZlibOptions);
}
interface Inflate extends stream.Transform, Zlib, ZlibReset {}
/**
* @since v0.5.8
*/
class DeflateRaw extends stream.Transform {
constructor(options?: ZlibOptions);
}
interface DeflateRaw extends stream.Transform, Zlib, ZlibReset, ZlibParams {}
/**
* @since v0.5.8
*/
class InflateRaw extends stream.Transform {
constructor(options?: ZlibOptions);
}
interface InflateRaw extends stream.Transform, Zlib, ZlibReset {}
/**
* @since v0.5.8
*/
class Unzip extends stream.Transform {
constructor(options?: ZlibOptions);
}
interface Unzip extends stream.Transform, Zlib {}
/**
* @since v22.15.0
* @experimental
*/
class ZstdCompress extends stream.Transform {
constructor(options?: ZstdOptions);
}
interface ZstdCompress extends stream.Transform, Zlib {}
/**
* @since v22.15.0
* @experimental
*/
class ZstdDecompress extends stream.Transform {
constructor(options?: ZstdOptions);
}
interface ZstdDecompress extends stream.Transform, Zlib {}
/**
* Computes a 32-bit [Cyclic Redundancy Check](https://en.wikipedia.org/wiki/Cyclic_redundancy_check) checksum of `data`.

2
node_modules/@types/react/README.md generated vendored
View File

@@ -8,7 +8,7 @@ This package contains type definitions for react (https://react.dev/).
Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/react.
### Additional Details
* Last updated: Wed, 11 Feb 2026 11:44:57 GMT
* Last updated: Thu, 05 Feb 2026 10:12:25 GMT
* Dependencies: [csstype](https://npmjs.com/package/csstype)
# Credits

7
node_modules/@types/react/experimental.d.ts generated vendored
View File

@@ -174,11 +174,4 @@ declare module "." {
interface DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_MEDIA_SRC_TYPES {
srcObject: Blob | MediaSource | MediaStream;
}
// @enableOptimisticKey
export const optimisticKey: unique symbol;
interface DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_KEY_TYPES {
optimisticKey: typeof optimisticKey;
}
}

10
node_modules/@types/react/index.d.ts generated vendored
View File

@@ -226,20 +226,12 @@ declare namespace React {
type ComponentState = any;
interface DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_KEY_TYPES {}
/**
* A value which uniquely identifies a node among items in an array.
*
* @see {@link https://react.dev/learn/rendering-lists#keeping-list-items-in-order-with-key React Docs}
*/
type Key =
| string
| number
| bigint
| DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_KEY_TYPES[
keyof DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_KEY_TYPES
];
type Key = string | number | bigint;
/**
* @internal The props any component can receive.

4
node_modules/@types/react/package.json generated vendored
View File

@@ -1,6 +1,6 @@
{
"name": "@types/react",
"version": "19.2.14",
"version": "19.2.13",
"description": "TypeScript definitions for react",
"homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/react",
"license": "MIT",
@@ -205,6 +205,6 @@
"csstype": "^3.2.2"
},
"peerDependencies": {},
"typesPublisherContentHash": "daae8d23e06b3d45da3803abb3f0bad661cffb4c40282d6886d8dfde7d5eea01",
"typesPublisherContentHash": "20f3b89e619c9f614e881f4a928351ed1d1a9c228d36dccb133288229bc0aff6",
"typeScriptVersion": "5.2"
}

7
node_modules/@types/react/ts5.0/experimental.d.ts generated vendored
View File

@@ -174,11 +174,4 @@ declare module "." {
interface DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_MEDIA_SRC_TYPES {
srcObject: Blob | MediaSource | MediaStream;
}
// @enableOptimisticKey
export const optimisticKey: unique symbol;
interface DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_KEY_TYPES {
optimisticKey: typeof optimisticKey;
}
}

10
node_modules/@types/react/ts5.0/index.d.ts generated vendored
View File

@@ -226,20 +226,12 @@ declare namespace React {
type ComponentState = any;
interface DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_KEY_TYPES {}
/**
* A value which uniquely identifies a node among items in an array.
*
* @see {@link https://react.dev/learn/rendering-lists#keeping-list-items-in-order-with-key React Docs}
*/
type Key =
| string
| number
| bigint
| DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_KEY_TYPES[
keyof DO_NOT_USE_OR_YOU_WILL_BE_FIRED_EXPERIMENTAL_KEY_TYPES
];
type Key = string | number | bigint;
/**
* @internal The props any component can receive.