build to asar, attempt to fix race condition
parent
24dd497fda
commit
b986c20a62
Binary file not shown.
@ -0,0 +1,17 @@
|
||||
#!/bin/sh
|
||||
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
|
||||
|
||||
case `uname` in
|
||||
*CYGWIN*) basedir=`cygpath -w "$basedir"`;;
|
||||
esac
|
||||
|
||||
if [ -z "$NODE_PATH" ]; then
|
||||
export NODE_PATH="/home/ruthenic/Coding/Javascript/demoncord/demoncord-kernel-package/node_modules/.pnpm/node_modules"
|
||||
else
|
||||
export NODE_PATH="$NODE_PATH:/home/ruthenic/Coding/Javascript/demoncord/demoncord-kernel-package/node_modules/.pnpm/node_modules"
|
||||
fi
|
||||
if [ -x "$basedir/node" ]; then
|
||||
exec "$basedir/node" "$basedir/../asar/bin/asar.js" "$@"
|
||||
else
|
||||
exec node "$basedir/../asar/bin/asar.js" "$@"
|
||||
fi
|
@ -0,0 +1,53 @@
|
||||
hoistPattern:
|
||||
- '*'
|
||||
hoistedDependencies:
|
||||
/@types/glob/7.2.0:
|
||||
'@types/glob': private
|
||||
/@types/minimatch/5.1.0:
|
||||
'@types/minimatch': private
|
||||
/@types/node/18.7.13:
|
||||
'@types/node': private
|
||||
/balanced-match/1.0.2:
|
||||
balanced-match: private
|
||||
/brace-expansion/1.1.11:
|
||||
brace-expansion: private
|
||||
/chromium-pickle-js/0.2.0:
|
||||
chromium-pickle-js: private
|
||||
/commander/5.1.0:
|
||||
commander: private
|
||||
/concat-map/0.0.1:
|
||||
concat-map: private
|
||||
/fs.realpath/1.0.0:
|
||||
fs.realpath: private
|
||||
/glob/7.2.3:
|
||||
glob: private
|
||||
/inflight/1.0.6:
|
||||
inflight: private
|
||||
/inherits/2.0.4:
|
||||
inherits: private
|
||||
/minimatch/3.1.2:
|
||||
minimatch: private
|
||||
/once/1.4.0:
|
||||
once: private
|
||||
/path-is-absolute/1.0.1:
|
||||
path-is-absolute: private
|
||||
/wrappy/1.0.2:
|
||||
wrappy: private
|
||||
included:
|
||||
dependencies: true
|
||||
devDependencies: true
|
||||
optionalDependencies: true
|
||||
injectedDeps: {}
|
||||
layoutVersion: 5
|
||||
nodeLinker: isolated
|
||||
packageManager: pnpm@7.4.1
|
||||
pendingBuilds: []
|
||||
prunedAt: Sun, 28 Aug 2022 23:13:52 GMT
|
||||
publicHoistPattern:
|
||||
- '*eslint*'
|
||||
- '*prettier*'
|
||||
registries:
|
||||
default: https://registry.npmjs.org/
|
||||
skipped: []
|
||||
storeDir: /home/ruthenic/.local/share/pnpm/store/v3
|
||||
virtualStoreDir: .pnpm
|
@ -0,0 +1,21 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) Microsoft Corporation.
|
||||
|
||||
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
|
@ -0,0 +1,16 @@
|
||||
# Installation
|
||||
> `npm install --save @types/glob`
|
||||
|
||||
# Summary
|
||||
This package contains type definitions for Glob (https://github.com/isaacs/node-glob).
|
||||
|
||||
# Details
|
||||
Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/glob.
|
||||
|
||||
### Additional Details
|
||||
* Last updated: Tue, 19 Oct 2021 22:01:22 GMT
|
||||
* Dependencies: [@types/minimatch](https://npmjs.com/package/@types/minimatch), [@types/node](https://npmjs.com/package/@types/node)
|
||||
* Global values: none
|
||||
|
||||
# Credits
|
||||
These definitions were written by [vvakame](https://github.com/vvakame), [voy](https://github.com/voy), [Klaus Meinhardt](https://github.com/ajafff), and [Piotr Błażejewicz](https://github.com/peterblazejewicz).
|
@ -0,0 +1,91 @@
|
||||
// Type definitions for Glob 7.2
|
||||
// Project: https://github.com/isaacs/node-glob
|
||||
// Definitions by: vvakame <https://github.com/vvakame>
|
||||
// voy <https://github.com/voy>
|
||||
// Klaus Meinhardt <https://github.com/ajafff>
|
||||
// Piotr Błażejewicz <https://github.com/peterblazejewicz>
|
||||
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
|
||||
|
||||
/// <reference types="node" />
|
||||
|
||||
import events = require("events");
|
||||
import minimatch = require("minimatch");
|
||||
import fs = require("fs");
|
||||
|
||||
declare function G(pattern: string, cb: (err: Error | null, matches: string[]) => void): G.IGlob;
|
||||
declare function G(pattern: string, options: G.IOptions, cb: (err: Error | null, matches: string[]) => void): G.IGlob;
|
||||
|
||||
declare namespace G {
|
||||
function __promisify__(pattern: string, options?: IOptions): Promise<string[]>;
|
||||
|
||||
function sync(pattern: string, options?: IOptions): string[];
|
||||
|
||||
function hasMagic(pattern: string, options?: IOptions): boolean;
|
||||
|
||||
let glob: typeof G;
|
||||
let Glob: IGlobStatic;
|
||||
let GlobSync: IGlobSyncStatic;
|
||||
|
||||
interface IOptions extends minimatch.IOptions {
|
||||
cwd?: string | undefined;
|
||||
root?: string | undefined;
|
||||
dot?: boolean | undefined;
|
||||
nomount?: boolean | undefined;
|
||||
mark?: boolean | undefined;
|
||||
nosort?: boolean | undefined;
|
||||
stat?: boolean | undefined;
|
||||
silent?: boolean | undefined;
|
||||
strict?: boolean | undefined;
|
||||
cache?: { [path: string]: boolean | 'DIR' | 'FILE' | ReadonlyArray<string> } | undefined;
|
||||
statCache?: { [path: string]: false | { isDirectory(): boolean} | undefined } | undefined;
|
||||
symlinks?: { [path: string]: boolean | undefined } | undefined;
|
||||
realpathCache?: { [path: string]: string } | undefined;
|
||||
sync?: boolean | undefined;
|
||||
nounique?: boolean | undefined;
|
||||
nonull?: boolean | undefined;
|
||||
debug?: boolean | undefined;
|
||||
nobrace?: boolean | undefined;
|
||||
noglobstar?: boolean | undefined;
|
||||
noext?: boolean | undefined;
|
||||
nocase?: boolean | undefined;
|
||||
matchBase?: any;
|
||||
nodir?: boolean | undefined;
|
||||
ignore?: string | ReadonlyArray<string> | undefined;
|
||||
follow?: boolean | undefined;
|
||||
realpath?: boolean | undefined;
|
||||
nonegate?: boolean | undefined;
|
||||
nocomment?: boolean | undefined;
|
||||
absolute?: boolean | undefined;
|
||||
fs?: typeof fs;
|
||||
}
|
||||
|
||||
interface IGlobStatic extends events.EventEmitter {
|
||||
new (pattern: string, cb?: (err: Error | null, matches: string[]) => void): IGlob;
|
||||
new (pattern: string, options: IOptions, cb?: (err: Error | null, matches: string[]) => void): IGlob;
|
||||
prototype: IGlob;
|
||||
}
|
||||
|
||||
interface IGlobSyncStatic {
|
||||
new (pattern: string, options?: IOptions): IGlobBase;
|
||||
prototype: IGlobBase;
|
||||
}
|
||||
|
||||
interface IGlobBase {
|
||||
minimatch: minimatch.IMinimatch;
|
||||
options: IOptions;
|
||||
aborted: boolean;
|
||||
cache: { [path: string]: boolean | 'DIR' | 'FILE' | ReadonlyArray<string> };
|
||||
statCache: { [path: string]: false | { isDirectory(): boolean; } | undefined };
|
||||
symlinks: { [path: string]: boolean | undefined };
|
||||
realpathCache: { [path: string]: string };
|
||||
found: string[];
|
||||
}
|
||||
|
||||
interface IGlob extends IGlobBase, events.EventEmitter {
|
||||
pause(): void;
|
||||
resume(): void;
|
||||
abort(): void;
|
||||
}
|
||||
}
|
||||
|
||||
export = G;
|
@ -0,0 +1,43 @@
|
||||
{
|
||||
"name": "@types/glob",
|
||||
"version": "7.2.0",
|
||||
"description": "TypeScript definitions for Glob",
|
||||
"homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/glob",
|
||||
"license": "MIT",
|
||||
"contributors": [
|
||||
{
|
||||
"name": "vvakame",
|
||||
"url": "https://github.com/vvakame",
|
||||
"githubUsername": "vvakame"
|
||||
},
|
||||
{
|
||||
"name": "voy",
|
||||
"url": "https://github.com/voy",
|
||||
"githubUsername": "voy"
|
||||
},
|
||||
{
|
||||
"name": "Klaus Meinhardt",
|
||||
"url": "https://github.com/ajafff",
|
||||
"githubUsername": "ajafff"
|
||||
},
|
||||
{
|
||||
"name": "Piotr Błażejewicz",
|
||||
"url": "https://github.com/peterblazejewicz",
|
||||
"githubUsername": "peterblazejewicz"
|
||||
}
|
||||
],
|
||||
"main": "",
|
||||
"types": "index.d.ts",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
|
||||
"directory": "types/glob"
|
||||
},
|
||||
"scripts": {},
|
||||
"dependencies": {
|
||||
"@types/minimatch": "*",
|
||||
"@types/node": "*"
|
||||
},
|
||||
"typesPublisherContentHash": "436848b740c6ebcf1bfea5b5542b494eb73ed390b43a18c3dffa26ce9bad0aa8",
|
||||
"typeScriptVersion": "3.7"
|
||||
}
|
@ -0,0 +1 @@
|
||||
../../../@types+minimatch@5.1.0/node_modules/@types/minimatch
|
@ -0,0 +1 @@
|
||||
../../../@types+node@18.7.13/node_modules/@types/node
|
21
node_modules/.pnpm/@types+minimatch@5.1.0/node_modules/@types/minimatch/LICENSE
generated
vendored
21
node_modules/.pnpm/@types+minimatch@5.1.0/node_modules/@types/minimatch/LICENSE
generated
vendored
@ -0,0 +1,21 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) Microsoft Corporation.
|
||||
|
||||
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
|
16
node_modules/.pnpm/@types+minimatch@5.1.0/node_modules/@types/minimatch/README.md
generated
vendored
16
node_modules/.pnpm/@types+minimatch@5.1.0/node_modules/@types/minimatch/README.md
generated
vendored
@ -0,0 +1,16 @@
|
||||
# Installation
|
||||
> `npm install --save @types/minimatch`
|
||||
|
||||
# Summary
|
||||
This package contains type definitions for minimatch (https://github.com/isaacs/minimatch).
|
||||
|
||||
# Details
|
||||
Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/minimatch.
|
||||
|
||||
### Additional Details
|
||||
* Last updated: Wed, 24 Aug 2022 08:32:18 GMT
|
||||
* Dependencies: none
|
||||
* Global values: none
|
||||
|
||||
# Credits
|
||||
These definitions were written by [vvakame](https://github.com/vvakame), [Shant Marouti](https://github.com/shantmarouti), and [BendingBender](https://github.com/BendingBender).
|
300
node_modules/.pnpm/@types+minimatch@5.1.0/node_modules/@types/minimatch/index.d.ts
generated
vendored
300
node_modules/.pnpm/@types+minimatch@5.1.0/node_modules/@types/minimatch/index.d.ts
generated
vendored
@ -0,0 +1,300 @@
|
||||
// Type definitions for minimatch 5.1
|
||||
// Project: https://github.com/isaacs/minimatch
|
||||
// Definitions by: vvakame <https://github.com/vvakame>
|
||||
// Shant Marouti <https://github.com/shantmarouti>
|
||||
// BendingBender <https://github.com/BendingBender>
|
||||
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
|
||||
|
||||
/**
|
||||
* Tests a path against the pattern using the options.
|
||||
*
|
||||
* @example
|
||||
* import minimatch = require("minimatch");
|
||||
*
|
||||
* const isJS = minimatch(file, "*.js", { matchBase: true });
|
||||
*/
|
||||
declare function minimatch(target: string, pattern: string, options?: minimatch.IOptions): boolean;
|
||||
|
||||
declare namespace minimatch {
|
||||
/**
|
||||
* Match against the list of files, in the style of fnmatch or glob.
|
||||
* If nothing is matched, and options.nonull is set,
|
||||
* then return a list containing the pattern itself.
|
||||
*
|
||||
* @example
|
||||
* import minimatch = require("minimatch");
|
||||
*
|
||||
* const javascripts = minimatch.match(fileList, "*.js", {matchBase: true});
|
||||
*/
|
||||
function match(list: readonly string[], pattern: string, options?: IOptions): string[];
|
||||
|
||||
/**
|
||||
* @return A function that tests its supplied argument, suitable for use with `Array.filter`.
|
||||
*
|
||||
* @example
|
||||
* import minimatch = require("minimatch");
|
||||
*
|
||||
* const javascripts = fileList.filter(minimatch.filter("*.js", {matchBase: true}));
|
||||
*/
|
||||
function filter(
|
||||
pattern: string,
|
||||
options?: IOptions,
|
||||
): (element: string, indexed: number, array: readonly string[]) => boolean;
|
||||
|
||||
/**
|
||||
* Make a regular expression object from the pattern.
|
||||
*/
|
||||
function makeRe(pattern: string, options?: IOptions): RegExp | false;
|
||||
|
||||
function defaults(defaultOptions: IOptions): typeof minimatch;
|
||||
|
||||
function braceExpand(pattern: string, options?: IOptions): string[];
|
||||
|
||||
const sep: string;
|
||||
const GLOBSTAR: unique symbol;
|
||||
|
||||
interface IOptions {
|
||||
/**
|
||||
* Dump a ton of stuff to stderr.
|
||||
*
|
||||
* @default false
|
||||
*/
|
||||
debug?: boolean | undefined;
|
||||
|
||||
/**
|
||||
* Do not expand `{a,b}` and `{1..3}` brace sets.
|
||||
*
|
||||
* @default false
|
||||
*/
|
||||
nobrace?: boolean | undefined;
|
||||
|
||||
/**
|
||||
* Disable `**` matching against multiple folder names.
|
||||
*
|
||||
* @default false
|
||||
*/
|
||||
noglobstar?: boolean | undefined;
|
||||
|
||||
/**
|
||||
* Allow patterns to match filenames starting with a period,
|
||||
* even if the pattern does not explicitly have a period in that spot.
|
||||
*
|
||||
* Note that by default, `'a/**' + '/b'` will **not** match `a/.d/b`, unless `dot` is set.
|
||||
*
|
||||
* @default false
|
||||
*/
|
||||
dot?: boolean | undefined;
|
||||
|
||||
/**
|
||||
* Disable "extglob" style patterns like `+(a|b)`.
|
||||
*
|
||||
* @default false
|
||||
*/
|
||||
noext?: boolean | undefined;
|
||||
|
||||
/**
|
||||
* Perform a case-insensitive match.
|
||||
*
|
||||
* @default false
|
||||
*/
|
||||
nocase?: boolean | undefined;
|
||||
|
||||
/**
|
||||
* When a match is not found by `minimatch.match`,
|
||||
* return a list containing the pattern itself if this option is set.
|
||||
* Otherwise, an empty list is returned if there are no matches.
|
||||
*
|
||||
* @default false
|
||||
*/
|
||||
nonull?: boolean | undefined;
|
||||
|
||||
/**
|
||||
* If set, then patterns without slashes will be matched
|
||||
* against the basename of the path if it contains slashes. For example,
|
||||
* `a?b` would match the path `/xyz/123/acb`, but not `/xyz/acb/123`.
|
||||
*
|
||||
* @default false
|
||||
*/
|
||||
matchBase?: boolean | undefined;
|
||||
|
||||
/**
|
||||
* Suppress the behavior of treating `#` at the start of a pattern as a comment.
|
||||
*
|
||||
* @default false
|
||||
*/
|
||||
nocomment?: boolean | undefined;
|
||||
|
||||
/**
|
||||
* Suppress the behavior of treating a leading `!` character as negation.
|
||||
*
|
||||
* @default false
|
||||
*/
|
||||
nonegate?: boolean | undefined;
|
||||
|
||||
/**
|
||||
* Returns from negate expressions the same as if they were not negated.
|
||||
* (Ie, true on a hit, false on a miss.)
|
||||
*
|
||||
* @default false
|
||||
*/
|
||||
flipNegate?: boolean | undefined;
|
||||
|
||||
/**
|
||||
* Compare a partial path to a pattern. As long as the parts of the path that
|
||||
* are present are not contradicted by the pattern, it will be treated as a
|
||||
* match. This is useful in applications where you're walking through a
|
||||
* folder structure, and don't yet have the full path, but want to ensure that
|
||||
* you do not walk down paths that can never be a match.
|
||||
*
|
||||
* @default false
|
||||
*
|
||||
* @example
|
||||
* import minimatch = require("minimatch");
|
||||
*
|
||||
* minimatch('/a/b', '/a/*' + '/c/d', { partial: true }) // true, might be /a/b/c/d
|
||||
* minimatch('/a/b', '/**' + '/d', { partial: true }) // true, might be /a/b/.../d
|
||||
* minimatch('/x/y/z', '/a/**' + '/z', { partial: true }) // false, because x !== a
|
||||
*/
|
||||
partial?: boolean;
|
||||
|
||||
/**
|
||||
* Use `\\` as a path separator _only_, and _never_ as an escape
|
||||
* character. If set, all `\\` characters are replaced with `/` in
|
||||
* the pattern. Note that this makes it **impossible** to match
|
||||
* against paths containing literal glob pattern characters, but
|
||||
* allows matching with patterns constructed using `path.join()` and
|
||||
* `path.resolve()` on Windows platforms, mimicking the (buggy!)
|
||||
* behavior of earlier versions on Windows. Please use with
|
||||
* caution, and be mindful of the caveat about Windows paths
|
||||
*
|
||||
* For legacy reasons, this is also set if
|
||||
* `options.allowWindowsEscape` is set to the exact value `false`.
|
||||
*
|
||||
* @default false
|
||||
*/
|
||||
windowsPathsNoEscape?: boolean;
|
||||
}
|
||||
|
||||
/**
|
||||
* @deprecated Keep legacy interface to prevent unnecessary breakage.
|
||||
*/
|
||||
type IMinimatchStatic = typeof Minimatch;
|
||||
/**
|
||||
* @deprecated Keep legacy interface to prevent unnecessary breakage.
|
||||
*/
|
||||
type IMinimatch = Minimatch;
|
||||
|
||||
/**
|
||||
* Create a minimatch object by instantiating the `minimatch.Minimatch` class.
|
||||
*
|
||||
* @example
|
||||
* import { Minimatch } from "minimatch";
|
||||
*
|
||||
* const mm = new Minimatch(pattern, options);
|
||||
*/
|
||||
class Minimatch {
|
||||
constructor(pattern: string, options?: IOptions);
|
||||
|
||||
static defaults(defaultOptions: IOptions): typeof Minimatch;
|
||||
|
||||
/**
|
||||
* The original pattern the minimatch object represents.
|
||||
*/
|
||||
pattern: string;
|
||||
|
||||
/**
|
||||
* The options supplied to the constructor.
|
||||
*/
|
||||
options: IOptions;
|
||||
|
||||
/**
|
||||
* A 2-dimensional array of regexp or string expressions. Each row in the array corresponds
|
||||
* to a brace-expanded pattern. Each item in the row corresponds to a single path-part. For
|
||||
* example, the pattern `{a,b/c}/d` would expand to a set of patterns like:
|
||||
*
|
||||
* ```
|
||||
* [ [ a, d ]
|
||||
* , [ b, c, d ] ]
|
||||
* ```
|
||||
*
|
||||
* If a portion of the pattern doesn't have any "magic" in it (that is, it's something like `"foo"``
|
||||
* rather than `fo*o?`), then it will be left as a string rather than converted to a regular expression.
|
||||
*/
|
||||
set: Array<Array<RegExp | string>>;
|
||||
|
||||
/**
|
||||
* Created by the `makeRe` method. A single regular expression expressing the entire pattern. This is
|
||||
* useful in cases where you wish to use the pattern somewhat like `fnmatch(3)` with `FNM_PATH` enabled.
|
||||
*/
|
||||
regexp: RegExp | false | null;
|
||||
|
||||
/**
|
||||
* True if the pattern is negated.
|
||||
*/
|
||||
negate: boolean;
|
||||
|
||||
/**
|
||||
* True if the pattern is a comment.
|
||||
*/
|
||||
comment: boolean;
|
||||
|
||||
/**
|
||||
* True if the pattern is `""`.
|
||||
*/
|
||||
empty: boolean;
|
||||
|
||||
/**
|
||||
* True if windows path delimiters shouldn't be interpreted as escape characters.
|
||||
*/
|
||||
windowsPathsNoEscape: boolean;
|
||||
|
||||
/**
|
||||
* True if partial paths should be compared to a pattern.
|
||||
*/
|
||||
partial: boolean;
|
||||
|
||||
/**
|
||||
* Generate the `regexp` member if necessary, and return it. Will return `false` if the pattern is invalid.
|
||||
*/
|
||||
makeRe(): RegExp | false;
|
||||
|
||||
/**
|
||||
* @return `true` if the filename matches the pattern, or `false` otherwise.
|
||||
*/
|
||||
match(fname: string, partial?: boolean): boolean;
|
||||
|
||||
/**
|
||||
* Take a `/`-split filename, and match it against a single row in the `regExpSet`.
|
||||
* This method is mainly for internal use, but is exposed so that it can be used
|
||||
* by a glob-walker that needs to avoid excessive filesystem calls.
|
||||
*/
|
||||
matchOne(file: string, pattern: readonly string[], partial: boolean): boolean;
|
||||
|
||||
/**
|
||||
* @deprecated. For internal use.
|
||||
*/
|
||||
debug(): void;
|
||||
|
||||
/**
|
||||
* @deprecated. For internal use.
|
||||
*/
|
||||
make(): void;
|
||||
|
||||
/**
|
||||
* @deprecated. For internal use.
|
||||
*/
|
||||
parseNegate(): void;
|
||||
|
||||
/**
|
||||
* @deprecated. For internal use.
|
||||
*/
|
||||
braceExpand(): string[];
|
||||
|
||||
/**
|
||||
* @deprecated. For internal use.
|
||||
*/
|
||||
parse(pattern: string, isSub?: boolean): string | false | [string, boolean] | RegExp | typeof GLOBSTAR;
|
||||
}
|
||||
}
|
||||
|
||||
export = minimatch;
|
35
node_modules/.pnpm/@types+minimatch@5.1.0/node_modules/@types/minimatch/package.json
generated
vendored
35
node_modules/.pnpm/@types+minimatch@5.1.0/node_modules/@types/minimatch/package.json
generated
vendored
@ -0,0 +1,35 @@
|
||||
{
|
||||
"name": "@types/minimatch",
|
||||
"version": "5.1.0",
|
||||
"description": "TypeScript definitions for minimatch",
|
||||
"homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/minimatch",
|
||||
"license": "MIT",
|
||||
"contributors": [
|
||||
{
|
||||
"name": "vvakame",
|
||||
"url": "https://github.com/vvakame",
|
||||
"githubUsername": "vvakame"
|
||||
},
|
||||
{
|
||||
"name": "Shant Marouti",
|
||||
"url": "https://github.com/shantmarouti",
|
||||
"githubUsername": "shantmarouti"
|
||||
},
|
||||
{
|
||||
"name": "BendingBender",
|
||||
"url": "https://github.com/BendingBender",
|
||||
"githubUsername": "BendingBender"
|
||||
}
|
||||
],
|
||||
"main": "",
|
||||
"types": "index.d.ts",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
|
||||
"directory": "types/minimatch"
|
||||
},
|
||||
"scripts": {},
|
||||
"dependencies": {},
|
||||
"typesPublisherContentHash": "393ad7dd03ff638ad34b79d6f5bffdff845be56b6982b86f0152a6e201ef0839",
|
||||
"typeScriptVersion": "4.0"
|
||||
}
|
@ -0,0 +1,21 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) Microsoft Corporation.
|
||||
|
||||
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
|
@ -0,0 +1,16 @@
|
||||
# Installation
|
||||
> `npm install --save @types/node`
|
||||
|
||||
# Summary
|
||||
This package contains type definitions for Node.js (https://nodejs.org/).
|
||||
|
||||
# Details
|
||||
Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node.
|
||||
|
||||
### Additional Details
|
||||
* Last updated: Wed, 24 Aug 2022 08:32:18 GMT
|
||||
* Dependencies: none
|
||||
* Global values: `AbortController`, `AbortSignal`, `__dirname`, `__filename`, `console`, `exports`, `gc`, `global`, `module`, `process`, `require`, `structuredClone`
|
||||
|
||||
# Credits
|
||||
These definitions were written by [Microsoft TypeScript](https://github.com/Microsoft), [DefinitelyTyped](https://github.com/DefinitelyTyped), [Alberto Schiabel](https://github.com/jkomyno), [Alvis HT Tang](https://github.com/alvis), [Andrew Makarov](https://github.com/r3nya), [Benjamin Toueg](https://github.com/btoueg), [Chigozirim C.](https://github.com/smac89), [David Junger](https://github.com/touffy), [Deividas Bakanas](https://github.com/DeividasBakanas), [Eugene Y. Q. Shen](https://github.com/eyqs), [Hannes Magnusson](https://github.com/Hannes-Magnusson-CK), [Huw](https://github.com/hoo29), [Kelvin Jin](https://github.com/kjin), [Klaus Meinhardt](https://github.com/ajafff), [Lishude](https://github.com/islishude), [Mariusz Wiktorczyk](https://github.com/mwiktorczyk), [Mohsen Azimi](https://github.com/mohsen1), [Nicolas Even](https://github.com/n-e), [Nikita Galkin](https://github.com/galkin), [Parambir Singh](https://github.com/parambirs), [Sebastian Silbermann](https://github.com/eps1lon), [Simon Schick](https://github.com/SimonSchick), [Thomas den Hollander](https://github.com/ThomasdenH), [Wilco Bakker](https://github.com/WilcoBakker), [wwwy3y3](https://github.com/wwwy3y3), [Samuel Ainsworth](https://github.com/samuela), [Kyle Uehlein](https://github.com/kuehlein), [Thanik Bhongbhibhat](https://github.com/bhongy), [Marcin Kopacz](https://github.com/chyzwar), [Trivikram Kamat](https://github.com/trivikr), [Junxiao Shi](https://github.com/yoursunny), [Ilia Baryshnikov](https://github.com/qwelias), [ExE Boss](https://github.com/ExE-Boss), [Piotr Błażejewicz](https://github.com/peterblazejewicz), [Anna Henningsen](https://github.com/addaleax), [Victor Perin](https://github.com/victorperin), [Yongsheng Zhang](https://github.com/ZYSzys), [NodeJS Contributors](https://github.com/NodeJS), [Linus Unnebäck](https://github.com/LinusU), [wafuwafu13](https://github.com/wafuwafu13), and [Matteo Collina](https://github.com/mcollina).
|
@ -0,0 +1,911 @@
|
||||
/**
|
||||
* The `assert` module provides a set of assertion functions for verifying
|
||||
* invariants.
|
||||
* @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/assert.js)
|
||||
*/
|
||||
declare module 'assert' {
|
||||
/**
|
||||
* An alias of {@link ok}.
|
||||
* @since v0.5.9
|
||||
* @param value The input that is checked for being truthy.
|
||||
*/
|
||||
function assert(value: unknown, message?: string | Error): asserts value;
|
||||
namespace assert {
|
||||
/**
|
||||
* Indicates the failure of an assertion. All errors thrown by the `assert` module
|
||||
* will be instances of the `AssertionError` class.
|
||||
*/
|
||||
class AssertionError extends Error {
|
||||
actual: unknown;
|
||||
expected: unknown;
|
||||
operator: string;
|
||||
generatedMessage: boolean;
|
||||
code: 'ERR_ASSERTION';
|
||||
constructor(options?: {
|
||||
/** If provided, the error message is set to this value. */
|
||||
message?: string | undefined;
|
||||
/** The `actual` property on the error instance. */
|
||||
actual?: unknown | undefined;
|
||||
/** The `expected` property on the error instance. */
|
||||
expected?: unknown | undefined;
|
||||
/** The `operator` property on the error instance. */
|
||||
operator?: string | undefined;
|
||||
/** If provided, the generated stack trace omits frames before this function. */
|
||||
// tslint:disable-next-line:ban-types
|
||||
stackStartFn?: Function | undefined;
|
||||
});
|
||||
}
|
||||
/**
|
||||
* This feature is currently experimental and behavior might still change.
|
||||
* @since v14.2.0, v12.19.0
|
||||
* @experimental
|
||||
*/
|
||||
class CallTracker {
|
||||
/**
|
||||
* The wrapper function is expected to be called exactly `exact` times. If the
|
||||
* function has not been called exactly `exact` times when `tracker.verify()` is called, then `tracker.verify()` will throw an
|
||||
* error.
|
||||
*
|
||||
* ```js
|
||||
* import assert from 'assert';
|
||||
*
|
||||
* // Creates call tracker.
|
||||
* const tracker = new assert.CallTracker();
|
||||
*
|
||||
* function func() {}
|
||||
*
|
||||
* // Returns a function that wraps func() that must be called exact times
|
||||
* // before tracker.verify().
|
||||
* const callsfunc = tracker.calls(func);
|
||||
* ```
|
||||
* @since v14.2.0, v12.19.0
|
||||
* @param [fn='A no-op function']
|
||||
* @param [exact=1]
|
||||
* @return that wraps `fn`.
|
||||
*/
|
||||
calls(exact?: number): () => void;
|
||||
calls<Func extends (...args: any[]) => any>(fn?: Func, exact?: number): Func;
|
||||
/**
|
||||
* The arrays contains information about the expected and actual number of calls of
|
||||
* the functions that have not been called the expected number of times.
|
||||
*
|
||||
* ```js
|
||||
* import assert from 'assert';
|
||||
*
|
||||
* // Creates call tracker.
|
||||
* const tracker = new assert.CallTracker();
|
||||
*
|
||||
* function func() {}
|
||||
*
|
||||
* function foo() {}
|
||||
*
|
||||
* // Returns a function that wraps func() that must be called exact times
|
||||
* // before tracker.verify().
|
||||
* const callsfunc = tracker.calls(func, 2);
|
||||
*
|
||||
* // Returns an array containing information on callsfunc()
|
||||
* tracker.report();
|
||||
* // [
|
||||
* // {
|
||||
* // message: 'Expected the func function to be executed 2 time(s) but was
|
||||
* // executed 0 time(s).',
|
||||
* // actual: 0,
|
||||
* // expected: 2,
|
||||
* // operator: 'func',
|
||||
* // stack: stack trace
|
||||
* // }
|
||||
* // ]
|
||||
* ```
|
||||
* @since v14.2.0, v12.19.0
|
||||
* @return of objects containing information about the wrapper functions returned by `calls`.
|
||||
*/
|
||||
report(): CallTrackerReportInformation[];
|
||||
/**
|
||||
* Iterates through the list of functions passed to `tracker.calls()` and will throw an error for functions that
|
||||
* have not been called the expected number of times.
|
||||
*
|
||||
* ```js
|
||||
* import assert from 'assert';
|
||||
*
|
||||
* // Creates call tracker.
|
||||
* const tracker = new assert.CallTracker();
|
||||
*
|
||||
* function func() {}
|
||||
*
|
||||
* // Returns a function that wraps func() that must be called exact times
|
||||
* // before tracker.verify().
|
||||
* const callsfunc = tracker.calls(func, 2);
|
||||
*
|
||||
* callsfunc();
|
||||
*
|
||||
* // Will throw an error since callsfunc() was only called once.
|
||||
* tracker.verify();
|
||||
* ```
|
||||
* @since v14.2.0, v12.19.0
|
||||
*/
|
||||
verify(): void;
|
||||
}
|
||||
interface CallTrackerReportInformation {
|
||||
message: string;
|
||||
/** The actual number of times the function was called. */
|
||||
actual: number;
|
||||
/** The number of times the function was expected to be called. */
|
||||
expected: number;
|
||||
/** The name of the function that is wrapped. */
|
||||
operator: string;
|
||||
/** A stack trace of the function. */
|
||||
stack: object;
|
||||
}
|
||||
type AssertPredicate = RegExp | (new () => object) | ((thrown: unknown) => boolean) | object | Error;
|
||||
/**
|
||||
* Throws an `AssertionError` with the provided error message or a default
|
||||
* error message. If the `message` parameter is an instance of an `Error` then
|
||||
* it will be thrown instead of the `AssertionError`.
|
||||
*
|
||||
* ```js
|
||||
* import assert from 'assert/strict';
|
||||
*
|
||||
* assert.fail();
|
||||
* // AssertionError [ERR_ASSERTION]: Failed
|
||||
*
|
||||
* assert.fail('boom');
|
||||
* // AssertionError [ERR_ASSERTION]: boom
|
||||
*
|
||||
* assert.fail(new TypeError('need array'));
|
||||
* // TypeError: need array
|
||||
* ```
|
||||
*
|
||||
* Using `assert.fail()` with more than two arguments is possible but deprecated.
|
||||
* See below for further details.
|
||||
* @since v0.1.21
|
||||
* @param [message='Failed']
|
||||
*/
|
||||
function fail(message?: string | Error): never;
|
||||
/** @deprecated since v10.0.0 - use fail([message]) or other assert functions instead. */
|
||||
function fail(
|
||||
actual: unknown,
|
||||
expected: unknown,
|
||||
message?: string | Error,
|
||||
operator?: string,
|
||||
// tslint:disable-next-line:ban-types
|
||||
stackStartFn?: Function
|
||||
): never;
|
||||
/**
|
||||
* Tests if `value` is truthy. It is equivalent to`assert.equal(!!value, true, message)`.
|
||||
*
|
||||
* If `value` is not truthy, an `AssertionError` is thrown with a `message`property set equal to the value of the `message` parameter. If the `message`parameter is `undefined`, a default
|
||||
* error message is assigned. If the `message`parameter is an instance of an `Error` then it will be thrown instead of the`AssertionError`.
|
||||
* If no arguments are passed in at all `message` will be set to the string:`` 'No value argument passed to `assert.ok()`' ``.
|
||||
*
|
||||
* Be aware that in the `repl` the error message will be different to the one
|
||||
* thrown in a file! See below for further details.
|
||||
*
|
||||
* ```js
|
||||
* import assert from 'assert/strict';
|
||||
*
|
||||
* assert.ok(true);
|
||||
* // OK
|
||||
* assert.ok(1);
|
||||
* // OK
|
||||
*
|
||||
* assert.ok();
|
||||
* // AssertionError: No value argument passed to `assert.ok()`
|
||||
*
|
||||
* assert.ok(false, 'it\'s false');
|
||||
* // AssertionError: it's false
|
||||
*
|
||||
* // In the repl:
|
||||
* assert.ok(typeof 123 === 'string');
|
||||
* // AssertionError: false == true
|
||||
*
|
||||
* // In a file (e.g. test.js):
|
||||
* assert.ok(typeof 123 === 'string');
|
||||
* // AssertionError: The expression evaluated to a falsy value:
|
||||
* //
|
||||
* // assert.ok(typeof 123 === 'string')
|
||||
*
|
||||
* assert.ok(false);
|
||||
* // AssertionError: The expression evaluated to a falsy value:
|
||||
* //
|
||||
* // assert.ok(false)
|
||||
*
|
||||
* assert.ok(0);
|
||||
* // AssertionError: The expression evaluated to a falsy value:
|
||||
* //
|
||||
* // assert.ok(0)
|
||||
* ```
|
||||
*
|
||||
* ```js
|
||||
* import assert from 'assert/strict';
|
||||
*
|
||||
* // Using `assert()` works the same:
|
||||
* assert(0);
|
||||
* // AssertionError: The expression evaluated to a falsy value:
|
||||
* //
|
||||
* // assert(0)
|
||||
* ```
|
||||
* @since v0.1.21
|
||||
*/
|
||||
function ok(value: unknown, message?: string | Error): asserts value;
|
||||
/**
|
||||
* **Strict assertion mode**
|
||||
*
|
||||
* An alias of {@link strictEqual}.
|
||||
*
|
||||
* **Legacy assertion mode**
|
||||
*
|
||||
* > Stability: 3 - Legacy: Use {@link strictEqual} instead.
|
||||
*
|
||||
* Tests shallow, coercive equality between the `actual` and `expected` parameters
|
||||
* using the [`==` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Equality). `NaN` is specially handled
|
||||
* and treated as being identical if both sides are `NaN`.
|
||||
*
|
||||
* ```js
|
||||
* import assert from 'assert';
|
||||
*
|
||||
* assert.equal(1, 1);
|
||||
* // OK, 1 == 1
|
||||
* assert.equal(1, '1');
|
||||
* // OK, 1 == '1'
|
||||
* assert.equal(NaN, NaN);
|
||||
* // OK
|
||||
*
|
||||
* assert.equal(1, 2);
|
||||
* // AssertionError: 1 == 2
|
||||
* assert.equal({ a: { b: 1 } }, { a: { b: 1 } });
|
||||
* // AssertionError: { a: { b: 1 } } == { a: { b: 1 } }
|
||||
* ```
|
||||
*
|
||||
* If the values are not equal, an `AssertionError` is thrown with a `message`property set equal to the value of the `message` parameter. If the `message`parameter is undefined, a default
|
||||
* error message is assigned. If the `message`parameter is an instance of an `Error` then it will be thrown instead of the`AssertionError`.
|
||||
* @since v0.1.21
|
||||
*/
|
||||
function equal(actual: unknown, expected: unknown, message?: string | Error): void;
|
||||
/**
|
||||
* **Strict assertion mode**
|
||||
*
|
||||
* An alias of {@link notStrictEqual}.
|
||||
*
|
||||
* **Legacy assertion mode**
|
||||
*
|
||||
* > Stability: 3 - Legacy: Use {@link notStrictEqual} instead.
|
||||
*
|
||||
* Tests shallow, coercive inequality with the [`!=` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Inequality). `NaN` is
|
||||
* specially handled and treated as being identical if both sides are `NaN`.
|
||||
*
|
||||
* ```js
|
||||
* import assert from 'assert';
|
||||
*
|
||||
* assert.notEqual(1, 2);
|
||||
* // OK
|
||||
*
|
||||
* assert.notEqual(1, 1);
|
||||
* // AssertionError: 1 != 1
|
||||
*
|
||||
* assert.notEqual(1, '1');
|
||||
* // AssertionError: 1 != '1'
|
||||
* ```
|
||||
*
|
||||
* If the values are equal, an `AssertionError` is thrown with a `message`property set equal to the value of the `message` parameter. If the `message`parameter is undefined, a default error
|
||||
* message is assigned. If the `message`parameter is an instance of an `Error` then it will be thrown instead of the`AssertionError`.
|
||||
* @since v0.1.21
|
||||
*/
|
||||
function notEqual(actual: unknown, expected: unknown, message?: string | Error): void;
|
||||
/**
|
||||
* **Strict assertion mode**
|
||||
*
|
||||
* An alias of {@link deepStrictEqual}.
|
||||
*
|
||||
* **Legacy assertion mode**
|
||||
*
|
||||
* > Stability: 3 - Legacy: Use {@link deepStrictEqual} instead.
|
||||
*
|
||||
* Tests for deep equality between the `actual` and `expected` parameters. Consider
|
||||
* using {@link deepStrictEqual} instead. {@link deepEqual} can have
|
||||
* surprising results.
|
||||
*
|
||||
* _Deep equality_ means that the enumerable "own" properties of child objects
|
||||
* are also recursively evaluated by the following rules.
|
||||
* @since v0.1.21
|
||||
*/
|
||||
function deepEqual(actual: unknown, expected: unknown, message?: string | Error): void;
|
||||
/**
|
||||
* **Strict assertion mode**
|
||||
*
|
||||
* An alias of {@link notDeepStrictEqual}.
|
||||
*
|
||||
* **Legacy assertion mode**
|
||||
*
|
||||
* > Stability: 3 - Legacy: Use {@link notDeepStrictEqual} instead.
|
||||
*
|
||||
* Tests for any deep inequality. Opposite of {@link deepEqual}.
|
||||
*
|
||||
* ```js
|
||||
* import assert from 'assert';
|
||||
*
|
||||
* const obj1 = {
|
||||
* a: {
|
||||
* b: 1
|
||||
* }
|
||||
* };
|
||||
* const obj2 = {
|
||||
* a: {
|
||||
* b: 2
|
||||
* }
|
||||
* };
|
||||
* const obj3 = {
|
||||
* a: {
|
||||
* b: 1
|
||||
* }
|
||||
* };
|
||||
* const obj4 = Object.create(obj1);
|
||||
*
|
||||
* assert.notDeepEqual(obj1, obj1);
|
||||
* // AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }
|
||||
*
|
||||
* assert.notDeepEqual(obj1, obj2);
|
||||
* // OK
|
||||
*
|
||||
* assert.notDeepEqual(obj1, obj3);
|
||||
* // AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }
|
||||
*
|
||||
* assert.notDeepEqual(obj1, obj4);
|
||||
* // OK
|
||||
* ```
|
||||
*
|
||||
* If the values are deeply equal, an `AssertionError` is thrown with a`message` property set equal to the value of the `message` parameter. If the`message` parameter is undefined, a default
|
||||
* error message is assigned. If the`message` parameter is an instance of an `Error` then it will be thrown
|
||||
* instead of the `AssertionError`.
|
||||
* @since v0.1.21
|
||||
*/
|
||||
function notDeepEqual(actual: unknown, expected: unknown, message?: string | Error): void;
|
||||
/**
|
||||
* Tests strict equality between the `actual` and `expected` parameters as
|
||||
* determined by [`Object.is()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is).
|
||||
*
|
||||
* ```js
|
||||
* import assert from 'assert/strict';
|
||||
*
|
||||
* assert.strictEqual(1, 2);
|
||||
* // AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:
|
||||
* //
|
||||
* // 1 !== 2
|
||||
*
|
||||
* assert.strictEqual(1, 1);
|
||||
* // OK
|
||||
*
|
||||
* assert.strictEqual('Hello foobar', 'Hello World!');
|
||||
* // AssertionError [ERR_ASSERTION]: Expected inputs to be strictly equal:
|
||||
* // + actual - expected
|
||||
* //
|
||||
* // + 'Hello foobar'
|
||||
* // - 'Hello World!'
|
||||
* // ^
|
||||
*
|
||||
* const apples = 1;
|
||||
* const oranges = 2;
|
||||
* assert.strictEqual(apples, oranges, `apples ${apples} !== oranges ${oranges}`);
|
||||
* // AssertionError [ERR_ASSERTION]: apples 1 !== oranges 2
|
||||
*
|
||||
* assert.strictEqual(1, '1', new TypeError('Inputs are not identical'));
|
||||
* // TypeError: Inputs are not identical
|
||||
* ```
|
||||
*
|
||||
* If the values are not strictly equal, an `AssertionError` is thrown with a`message` property set equal to the value of the `message` parameter. If the`message` parameter is undefined, a
|
||||
* default error message is assigned. If the`message` parameter is an instance of an `Error` then it will be thrown
|
||||
* instead of the `AssertionError`.
|
||||
* @since v0.1.21
|
||||
*/
|
||||
function strictEqual<T>(actual: unknown, expected: T, message?: string | Error): asserts actual is T;
|
||||
/**
|
||||
* Tests strict inequality between the `actual` and `expected` parameters as
|
||||
* determined by [`Object.is()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is).
|
||||
*
|
||||
* ```js
|
||||
* import assert from 'assert/strict';
|
||||
*
|
||||
* assert.notStrictEqual(1, 2);
|
||||
* // OK
|
||||
*
|
||||
* assert.notStrictEqual(1, 1);
|
||||
* // AssertionError [ERR_ASSERTION]: Expected "actual" to be strictly unequal to:
|
||||
* //
|
||||
* // 1
|
||||
*
|
||||
* assert.notStrictEqual(1, '1');
|
||||
* // OK
|
||||
* ```
|
||||
*
|
||||
* If the values are strictly equal, an `AssertionError` is thrown with a`message` property set equal to the value of the `message` parameter. If the`message` parameter is undefined, a
|
||||
* default error message is assigned. If the`message` parameter is an instance of an `Error` then it will be thrown
|
||||
* instead of the `AssertionError`.
|
||||
* @since v0.1.21
|
||||
*/
|
||||
function notStrictEqual(actual: unknown, expected: unknown, message?: string | Error): void;
|
||||
/**
|
||||
* Tests for deep equality between the `actual` and `expected` parameters.
|
||||
* "Deep" equality means that the enumerable "own" properties of child objects
|
||||
* are recursively evaluated also by the following rules.
|
||||
* @since v1.2.0
|
||||
*/
|
||||
function deepStrictEqual<T>(actual: unknown, expected: T, message?: string | Error): asserts actual is T;
|
||||
/**
|
||||
* Tests for deep strict inequality. Opposite of {@link deepStrictEqual}.
|
||||
*
|
||||
* ```js
|
||||
* import assert from 'assert/strict';
|
||||
*
|
||||
* assert.notDeepStrictEqual({ a: 1 }, { a: '1' });
|
||||
* // OK
|
||||
* ```
|
||||
*
|
||||
* If the values are deeply and strictly equal, an `AssertionError` is thrown
|
||||
* with a `message` property set equal to the value of the `message` parameter. If
|
||||
* the `message` parameter is undefined, a default error message is assigned. If
|
||||
* the `message` parameter is an instance of an `Error` then it will be thrown
|
||||
* instead of the `AssertionError`.
|
||||
* @since v1.2.0
|
||||
*/
|
||||
function notDeepStrictEqual(actual: unknown, expected: unknown, message?: string | Error): void;
|
||||
/**
|
||||
* Expects the function `fn` to throw an error.
|
||||
*
|
||||
* If specified, `error` can be a [`Class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes),
|
||||
* [`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions), a validation function,
|
||||
* a validation object where each property will be tested for strict deep equality,
|
||||
* or an instance of error where each property will be tested for strict deep
|
||||
* equality including the non-enumerable `message` and `name` properties. When
|
||||
* using an object, it is also possible to use a regular expression, when
|
||||
* validating against a string property. See below for examples.
|
||||
*
|
||||
* If specified, `message` will be appended to the message provided by the`AssertionError` if the `fn` call fails to throw or in case the error validation
|
||||
* fails.
|
||||
*
|
||||
* Custom validation object/error instance:
|
||||
*
|
||||
* ```js
|
||||
* import assert from 'assert/strict';
|
||||
*
|
||||
* const err = new TypeError('Wrong value');
|
||||
* err.code = 404;
|
||||
* err.foo = 'bar';
|
||||
* err.info = {
|
||||
* nested: true,
|
||||
* baz: 'text'
|
||||
* };
|
||||
* err.reg = /abc/i;
|
||||
*
|
||||
* assert.throws(
|
||||
* () => {
|
||||
* throw err;
|
||||
* },
|
||||
* {
|
||||
* name: 'TypeError',
|
||||
* message: 'Wrong value',
|
||||
* info: {
|
||||
* nested: true,
|
||||
* baz: 'text'
|
||||
* }
|
||||
* // Only properties on the validation object will be tested for.
|
||||
* // Using nested objects requires all properties to be present. Otherwise
|
||||
* // the validation is going to fail.
|
||||
* }
|
||||
* );
|
||||
*
|
||||
* // Using regular expressions to validate error properties:
|
||||
* throws(
|
||||
* () => {
|
||||
* throw err;
|
||||
* },
|
||||
* {
|
||||
* // The `name` and `message` properties are strings and using regular
|
||||
* // expressions on those will match against the string. If they fail, an
|
||||
* // error is thrown.
|
||||
* name: /^TypeError$/,
|
||||
* message: /Wrong/,
|
||||
* foo: 'bar',
|
||||
* info: {
|
||||
* nested: true,
|
||||
* // It is not possible to use regular expressions for nested properties!
|
||||
* baz: 'text'
|
||||
* },
|
||||
* // The `reg` property contains a regular expression and only if the
|
||||
* // validation object contains an identical regular expression, it is going
|
||||
* // to pass.
|
||||
* reg: /abc/i
|
||||
* }
|
||||
* );
|
||||
*
|
||||
* // Fails due to the different `message` and `name` properties:
|
||||
* throws(
|
||||
* () => {
|
||||
* const otherErr = new Error('Not found');
|
||||
* // Copy all enumerable properties from `err` to `otherErr`.
|
||||
* for (const [key, value] of Object.entries(err)) {
|
||||
* otherErr[key] = value;
|
||||
* }
|
||||
* throw otherErr;
|
||||
* },
|
||||
* // The error's `message` and `name` properties will also be checked when using
|
||||
* // an error as validation object.
|
||||
* err
|
||||
* );
|
||||
* ```
|
||||
*
|
||||
* Validate instanceof using constructor:
|
||||
*
|
||||
* ```js
|
||||
* import assert from 'assert/strict';
|
||||
*
|
||||
* assert.throws(
|
||||
* () => {
|
||||
* throw new Error('Wrong value');
|
||||
* },
|
||||
* Error
|
||||
* );
|
||||
* ```
|
||||
*
|
||||
* Validate error message using [`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions):
|
||||
*
|
||||
* Using a regular expression runs `.toString` on the error object, and will
|
||||
* therefore also include the error name.
|
||||
*
|
||||
* ```js
|
||||
* import assert from 'assert/strict';
|
||||
*
|
||||
* assert.throws(
|
||||
* () => {
|
||||
* throw new Error('Wrong value');
|
||||
* },
|
||||
* /^Error: Wrong value$/
|
||||
* );
|
||||
* ```
|
||||
*
|
||||
* Custom error validation:
|
||||
*
|
||||
* The function must return `true` to indicate all internal validations passed.
|
||||
* It will otherwise fail with an `AssertionError`.
|
||||
*
|
||||
* ```js
|
||||
* import assert from 'assert/strict';
|
||||
*
|
||||
* assert.throws(
|
||||
* () => {
|
||||
* throw new Error('Wrong value');
|
||||
* },
|
||||
* (err) => {
|
||||
* assert(err instanceof Error);
|
||||
* assert(/value/.test(err));
|
||||
* // Avoid returning anything from validation functions besides `true`.
|
||||
* // Otherwise, it's not clear what part of the validation failed. Instead,
|
||||
* // throw an error about the specific validation that failed (as done in this
|
||||
* // example) and add as much helpful debugging information to that error as
|
||||
* // possible.
|
||||
* return true;
|
||||
* },
|
||||
* 'unexpected error'
|
||||
* );
|
||||
* ```
|
||||
*
|
||||
* `error` cannot be a string. If a string is provided as the second
|
||||
* argument, then `error` is assumed to be omitted and the string will be used for`message` instead. This can lead to easy-to-miss mistakes. Using the same
|
||||
* message as the thrown error message is going to result in an`ERR_AMBIGUOUS_ARGUMENT` error. Please read the example below carefully if using
|
||||
* a string as the second argument gets considered:
|
||||
*
|
||||
* ```js
|
||||
* import assert from 'assert/strict';
|
||||
*
|
||||
* function throwingFirst() {
|
||||
* throw new Error('First');
|
||||
* }
|
||||
*
|
||||
* function throwingSecond() {
|
||||
* throw new Error('Second');
|
||||
* }
|
||||
*
|
||||
* function notThrowing() {}
|
||||
*
|
||||
* // The second argument is a string and the input function threw an Error.
|
||||
* // The first case will not throw as it does not match for the error message
|
||||
* // thrown by the input function!
|
||||
* assert.throws(throwingFirst, 'Second');
|
||||
* // In the next example the message has no benefit over the message from the
|
||||
* // error and since it is not clear if the user intended to actually match
|
||||
* // against the error message, Node.js throws an `ERR_AMBIGUOUS_ARGUMENT` error.
|
||||
* assert.throws(throwingSecond, 'Second');
|
||||
* // TypeError [ERR_AMBIGUOUS_ARGUMENT]
|
||||
*
|
||||
* // The string is only used (as message) in case the function does not throw:
|
||||
* assert.throws(notThrowing, 'Second');
|
||||
* // AssertionError [ERR_ASSERTION]: Missing expected exception: Second
|
||||
*
|
||||
* // If it was intended to match for the error message do this instead:
|
||||
* // It does not throw because the error messages match.
|
||||
* assert.throws(throwingSecond, /Second$/);
|
||||
*
|
||||
* // If the error message does not match, an AssertionError is thrown.
|
||||
* assert.throws(throwingFirst, /Second$/);
|
||||
* // AssertionError [ERR_ASSERTION]
|
||||
* ```
|
||||
*
|
||||
* Due to the confusing error-prone notation, avoid a string as the second
|
||||
* argument.
|
||||
* @since v0.1.21
|
||||
*/
|
||||
function throws(block: () => unknown, message?: string | Error): void;
|
||||
function throws(block: () => unknown, error: AssertPredicate, message?: string | Error): void;
|
||||
/**
|
||||
* Asserts that the function `fn` does not throw an error.
|
||||
*
|
||||
* Using `assert.doesNotThrow()` is actually not useful because there
|
||||
* is no benefit in catching an error and then rethrowing it. Instead, consider
|
||||
* adding a comment next to the specific code path that should not throw and keep
|
||||
* error messages as expressive as possible.
|
||||
*
|
||||
* When `assert.doesNotThrow()` is called, it will immediately call the `fn`function.
|
||||
*
|
||||
* If an error is thrown and it is the same type as that specified by the `error`parameter, then an `AssertionError` is thrown. If the error is of a
|
||||
* different type, or if the `error` parameter is undefined, the error is
|
||||
* propagated back to the caller.
|
||||
*
|
||||
* If specified, `error` can be a [`Class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes),
|
||||
* [`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions) or a validation
|
||||
* function. See {@link throws} for more details.
|
||||
*
|
||||
* The following, for instance, will throw the `TypeError` because there is no
|
||||
* matching error type in the assertion:
|
||||
*
|
||||
* ```js
|
||||
* import assert from 'assert/strict';
|
||||
*
|
||||
* assert.doesNotThrow(
|
||||
* () => {
|
||||
* throw new TypeError('Wrong value');
|
||||
* },
|
||||
* SyntaxError
|
||||
* );
|
||||
* ```
|
||||
*
|
||||
* However, the following will result in an `AssertionError` with the message
|
||||
* 'Got unwanted exception...':
|
||||
*
|
||||
* ```js
|
||||
* import assert from 'assert/strict';
|
||||
*
|
||||
* assert.doesNotThrow(
|
||||
* () => {
|
||||
* throw new TypeError('Wrong value');
|
||||
* },
|
||||
* TypeError
|
||||
* );
|
||||
* ```
|
||||
*
|
||||
* If an `AssertionError` is thrown and a value is provided for the `message`parameter, the value of `message` will be appended to the `AssertionError` message:
|
||||
*
|
||||
* ```js
|
||||
* import assert from 'assert/strict';
|
||||
*
|
||||
* assert.doesNotThrow(
|
||||
* () => {
|
||||
* throw new TypeError('Wrong value');
|
||||
* },
|
||||
* /Wrong value/,
|
||||
* 'Whoops'
|
||||
* );
|
||||
* // Throws: AssertionError: Got unwanted exception: Whoops
|
||||
* ```
|
||||
* @since v0.1.21
|
||||
*/
|
||||
function doesNotThrow(block: () => unknown, message?: string | Error): void;
|
||||
function doesNotThrow(block: () => unknown, error: AssertPredicate, message?: string | Error): void;
|
||||
/**
|
||||
* Throws `value` if `value` is not `undefined` or `null`. This is useful when
|
||||
* testing the `error` argument in callbacks. The stack trace contains all frames
|
||||
* from the error passed to `ifError()` including the potential new frames for`ifError()` itself.
|
||||
*
|
||||
* ```js
|
||||
* import assert from 'assert/strict';
|
||||
*
|
||||
* assert.ifError(null);
|
||||
* // OK
|
||||
* assert.ifError(0);
|
||||
* // AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 0
|
||||
* assert.ifError('error');
|
||||
* // AssertionError [ERR_ASSERTION]: ifError got unwanted exception: 'error'
|
||||
* assert.ifError(new Error());
|
||||
* // AssertionError [ERR_ASSERTION]: ifError got unwanted exception: Error
|
||||
*
|
||||
* // Create some random error frames.
|
||||
* let err;
|
||||
* (function errorFrame() {
|
||||
* err = new Error('test error');
|
||||
* })();
|
||||
*
|
||||
* (function ifErrorFrame() {
|
||||
* assert.ifError(err);
|
||||
* })();
|
||||
* // AssertionError [ERR_ASSERTION]: ifError got unwanted exception: test error
|
||||
* // at ifErrorFrame
|
||||
* // at errorFrame
|
||||
* ```
|
||||
* @since v0.1.97
|
||||
*/
|
||||
function ifError(value: unknown): asserts value is null | undefined;
|
||||
/**
|
||||
* Awaits the `asyncFn` promise or, if `asyncFn` is a function, immediately
|
||||
* calls the function and awaits the returned promise to complete. It will then
|
||||
* check that the promise is rejected.
|
||||
*
|
||||
* If `asyncFn` is a function and it throws an error synchronously,`assert.rejects()` will return a rejected `Promise` with that error. If the
|
||||
* function does not return a promise, `assert.rejects()` will return a rejected`Promise` with an `ERR_INVALID_RETURN_VALUE` error. In both cases the error
|
||||
* handler is skipped.
|
||||
*
|
||||
* Besides the async nature to await the completion behaves identically to {@link throws}.
|
||||
*
|
||||
* If specified, `error` can be a [`Class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes),
|
||||
* [`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions), a validation function,
|
||||
* an object where each property will be tested for, or an instance of error where
|
||||
* each property will be tested for including the non-enumerable `message` and`name` properties.
|
||||
*
|
||||
* If specified, `message` will be the message provided by the `AssertionError` if the `asyncFn` fails to reject.
|
||||
*
|
||||
* ```js
|
||||
* import assert from 'assert/strict';
|
||||
*
|
||||
* await assert.rejects(
|
||||
* async () => {
|
||||
* throw new TypeError('Wrong value');
|
||||
* },
|
||||
* {
|
||||
* name: 'TypeError',
|
||||
* message: 'Wrong value'
|
||||
* }
|
||||
* );
|
||||
* ```
|
||||
*
|
||||
* ```js
|
||||
* import assert from 'assert/strict';
|
||||
*
|
||||
* await assert.rejects(
|
||||
* async () => {
|
||||
* throw new TypeError('Wrong value');
|
||||
* },
|
||||
* (err) => {
|
||||
* assert.strictEqual(err.name, 'TypeError');
|
||||
* assert.strictEqual(err.message, 'Wrong value');
|
||||
* return true;
|
||||
* }
|
||||
* );
|
||||
* ```
|
||||
*
|
||||
* ```js
|
||||
* import assert from 'assert/strict';
|
||||
*
|
||||
* assert.rejects(
|
||||
* Promise.reject(new Error('Wrong value')),
|
||||
* Error
|
||||
* ).then(() => {
|
||||
* // ...
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* `error` cannot be a string. If a string is provided as the second
|
||||
* argument, then `error` is assumed to be omitted and the string will be used for`message` instead. This can lead to easy-to-miss mistakes. Please read the
|
||||
* example in {@link throws} carefully if using a string as the second
|
||||
* argument gets considered.
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function rejects(block: (() => Promise<unknown>) | Promise<unknown>, message?: string | Error): Promise<void>;
|
||||
function rejects(block: (() => Promise<unknown>) | Promise<unknown>, error: AssertPredicate, message?: string | Error): Promise<void>;
|
||||
/**
|
||||
* Awaits the `asyncFn` promise or, if `asyncFn` is a function, immediately
|
||||
* calls the function and awaits the returned promise to complete. It will then
|
||||
* check that the promise is not rejected.
|
||||
*
|
||||
* If `asyncFn` is a function and it throws an error synchronously,`assert.doesNotReject()` will return a rejected `Promise` with that error. If
|
||||
* the function does not return a promise, `assert.doesNotReject()` will return a
|
||||
* rejected `Promise` with an `ERR_INVALID_RETURN_VALUE` error. In both cases
|
||||
* the error handler is skipped.
|
||||
*
|
||||
* Using `assert.doesNotReject()` is actually not useful because there is little
|
||||
* benefit in catching a rejection and then rejecting it again. Instead, consider
|
||||
* adding a comment next to the specific code path that should not reject and keep
|
||||
* error messages as expressive as possible.
|
||||
*
|
||||
* If specified, `error` can be a [`Class`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes),
|
||||
* [`RegExp`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions) or a validation
|
||||
* function. See {@link throws} for more details.
|
||||
*
|
||||
* Besides the async nature to await the completion behaves identically to {@link doesNotThrow}.
|
||||
*
|
||||
* ```js
|
||||
* import assert from 'assert/strict';
|
||||
*
|
||||
* await assert.doesNotReject(
|
||||
* async () => {
|
||||
* throw new TypeError('Wrong value');
|
||||
* },
|
||||
* SyntaxError
|
||||
* );
|
||||
* ```
|
||||
*
|
||||
* ```js
|
||||
* import assert from 'assert/strict';
|
||||
*
|
||||
* assert.doesNotReject(Promise.reject(new TypeError('Wrong value')))
|
||||
* .then(() => {
|
||||
* // ...
|
||||
* });
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function doesNotReject(block: (() => Promise<unknown>) | Promise<unknown>, message?: string | Error): Promise<void>;
|
||||
function doesNotReject(block: (() => Promise<unknown>) | Promise<unknown>, error: AssertPredicate, message?: string | Error): Promise<void>;
|
||||
/**
|
||||
* Expects the `string` input to match the regular expression.
|
||||
*
|
||||
* ```js
|
||||
* import assert from 'assert/strict';
|
||||
*
|
||||
* assert.match('I will fail', /pass/);
|
||||
* // AssertionError [ERR_ASSERTION]: The input did not match the regular ...
|
||||
*
|
||||
* assert.match(123, /pass/);
|
||||
* // AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.
|
||||
*
|
||||
* assert.match('I will pass', /pass/);
|
||||
* // OK
|
||||
* ```
|
||||
*
|
||||
* If the values do not match, or if the `string` argument is of another type than`string`, an `AssertionError` is thrown with a `message` property set equal
|
||||
* to the value of the `message` parameter. If the `message` parameter is
|
||||
* undefined, a default error message is assigned. If the `message` parameter is an
|
||||
* instance of an `Error` then it will be thrown instead of the `AssertionError`.
|
||||
* @since v13.6.0, v12.16.0
|
||||
*/
|
||||
function match(value: string, regExp: RegExp, message?: string | Error): void;
|
||||
/**
|
||||
* Expects the `string` input not to match the regular expression.
|
||||
*
|
||||
* ```js
|
||||
* import assert from 'assert/strict';
|
||||
*
|
||||
* assert.doesNotMatch('I will fail', /fail/);
|
||||
* // AssertionError [ERR_ASSERTION]: The input was expected to not match the ...
|
||||
*
|
||||
* assert.doesNotMatch(123, /pass/);
|
||||
* // AssertionError [ERR_ASSERTION]: The "string" argument must be of type string.
|
||||
*
|
||||
* assert.doesNotMatch('I will pass', /different/);
|
||||
* // OK
|
||||
* ```
|
||||
*
|
||||
* If the values do match, or if the `string` argument is of another type than`string`, an `AssertionError` is thrown with a `message` property set equal
|
||||
* to the value of the `message` parameter. If the `message` parameter is
|
||||
* undefined, a default error message is assigned. If the `message` parameter is an
|
||||
* instance of an `Error` then it will be thrown instead of the `AssertionError`.
|
||||
* @since v13.6.0, v12.16.0
|
||||
*/
|
||||
function doesNotMatch(value: string, regExp: RegExp, message?: string | Error): void;
|
||||
const strict: Omit<typeof assert, 'equal' | 'notEqual' | 'deepEqual' | 'notDeepEqual' | 'ok' | 'strictEqual' | 'deepStrictEqual' | 'ifError' | 'strict'> & {
|
||||
(value: unknown, message?: string | Error): asserts value;
|
||||
equal: typeof strictEqual;
|
||||
notEqual: typeof notStrictEqual;
|
||||
deepEqual: typeof deepStrictEqual;
|
||||
notDeepEqual: typeof notDeepStrictEqual;
|
||||
// Mapped types and assertion functions are incompatible?
|
||||
// TS2775: Assertions require every name in the call target
|
||||
// to be declared with an explicit type annotation.
|
||||
ok: typeof ok;
|
||||
strictEqual: typeof strictEqual;
|
||||
deepStrictEqual: typeof deepStrictEqual;
|
||||
ifError: typeof ifError;
|
||||
strict: typeof strict;
|
||||
};
|
||||
}
|
||||
export = assert;
|
||||
}
|
||||
declare module 'node:assert' {
|
||||
import assert = require('assert');
|
||||
export = assert;
|
||||
}
|
8
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/assert/strict.d.ts
generated
vendored
8
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/assert/strict.d.ts
generated
vendored
@ -0,0 +1,8 @@
|
||||
declare module 'assert/strict' {
|
||||
import { strict } from 'node:assert';
|
||||
export = strict;
|
||||
}
|
||||
declare module 'node:assert/strict' {
|
||||
import { strict } from 'node:assert';
|
||||
export = strict;
|
||||
}
|
501
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/async_hooks.d.ts
generated
vendored
501
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/async_hooks.d.ts
generated
vendored
@ -0,0 +1,501 @@
|
||||
/**
|
||||
* The `async_hooks` module provides an API to track asynchronous resources. It
|
||||
* can be accessed using:
|
||||
*
|
||||
* ```js
|
||||
* import async_hooks from 'async_hooks';
|
||||
* ```
|
||||
* @experimental
|
||||
* @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/async_hooks.js)
|
||||
*/
|
||||
declare module 'async_hooks' {
|
||||
/**
|
||||
* ```js
|
||||
* import { executionAsyncId } from 'async_hooks';
|
||||
*
|
||||
* console.log(executionAsyncId()); // 1 - bootstrap
|
||||
* fs.open(path, 'r', (err, fd) => {
|
||||
* console.log(executionAsyncId()); // 6 - open()
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* The ID returned from `executionAsyncId()` is related to execution timing, not
|
||||
* causality (which is covered by `triggerAsyncId()`):
|
||||
*
|
||||
* ```js
|
||||
* const server = net.createServer((conn) => {
|
||||
* // Returns the ID of the server, not of the new connection, because the
|
||||
* // callback runs in the execution scope of the server's MakeCallback().
|
||||
* async_hooks.executionAsyncId();
|
||||
*
|
||||
* }).listen(port, () => {
|
||||
* // Returns the ID of a TickObject (process.nextTick()) because all
|
||||
* // callbacks passed to .listen() are wrapped in a nextTick().
|
||||
* async_hooks.executionAsyncId();
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* Promise contexts may not get precise `executionAsyncIds` by default.
|
||||
* See the section on `promise execution tracking`.
|
||||
* @since v8.1.0
|
||||
* @return The `asyncId` of the current execution context. Useful to track when something calls.
|
||||
*/
|
||||
function executionAsyncId(): number;
|
||||
/**
|
||||
* Resource objects returned by `executionAsyncResource()` are most often internal
|
||||
* Node.js handle objects with undocumented APIs. Using any functions or properties
|
||||
* on the object is likely to crash your application and should be avoided.
|
||||
*
|
||||
* Using `executionAsyncResource()` in the top-level execution context will
|
||||
* return an empty object as there is no handle or request object to use,
|
||||
* but having an object representing the top-level can be helpful.
|
||||
*
|
||||
* ```js
|
||||
* import { open } from 'fs';
|
||||
* import { executionAsyncId, executionAsyncResource } from 'async_hooks';
|
||||
*
|
||||
* console.log(executionAsyncId(), executionAsyncResource()); // 1 {}
|
||||
* open(new URL(import.meta.url), 'r', (err, fd) => {
|
||||
* console.log(executionAsyncId(), executionAsyncResource()); // 7 FSReqWrap
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* This can be used to implement continuation local storage without the
|
||||
* use of a tracking `Map` to store the metadata:
|
||||
*
|
||||
* ```js
|
||||
* import { createServer } from 'http';
|
||||
* import {
|
||||
* executionAsyncId,
|
||||
* executionAsyncResource,
|
||||
* createHook
|
||||
* } from 'async_hooks';
|
||||
* const sym = Symbol('state'); // Private symbol to avoid pollution
|
||||
*
|
||||
* createHook({
|
||||
* init(asyncId, type, triggerAsyncId, resource) {
|
||||
* const cr = executionAsyncResource();
|
||||
* if (cr) {
|
||||
* resource[sym] = cr[sym];
|
||||
* }
|
||||
* }
|
||||
* }).enable();
|
||||
*
|
||||
* const server = createServer((req, res) => {
|
||||
* executionAsyncResource()[sym] = { state: req.url };
|
||||
* setTimeout(function() {
|
||||
* res.end(JSON.stringify(executionAsyncResource()[sym]));
|
||||
* }, 100);
|
||||
* }).listen(3000);
|
||||
* ```
|
||||
* @since v13.9.0, v12.17.0
|
||||
* @return The resource representing the current execution. Useful to store data within the resource.
|
||||
*/
|
||||
function executionAsyncResource(): object;
|
||||
/**
|
||||
* ```js
|
||||
* const server = net.createServer((conn) => {
|
||||
* // The resource that caused (or triggered) this callback to be called
|
||||
* // was that of the new connection. Thus the return value of triggerAsyncId()
|
||||
* // is the asyncId of "conn".
|
||||
* async_hooks.triggerAsyncId();
|
||||
*
|
||||
* }).listen(port, () => {
|
||||
* // Even though all callbacks passed to .listen() are wrapped in a nextTick()
|
||||
* // the callback itself exists because the call to the server's .listen()
|
||||
* // was made. So the return value would be the ID of the server.
|
||||
* async_hooks.triggerAsyncId();
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* Promise contexts may not get valid `triggerAsyncId`s by default. See
|
||||
* the section on `promise execution tracking`.
|
||||
* @return The ID of the resource responsible for calling the callback that is currently being executed.
|
||||
*/
|
||||
function triggerAsyncId(): number;
|
||||
interface HookCallbacks {
|
||||
/**
|
||||
* Called when a class is constructed that has the possibility to emit an asynchronous event.
|
||||
* @param asyncId a unique ID for the async resource
|
||||
* @param type the type of the async resource
|
||||
* @param triggerAsyncId the unique ID of the async resource in whose execution context this async resource was created
|
||||
* @param resource reference to the resource representing the async operation, needs to be released during destroy
|
||||
*/
|
||||
init?(asyncId: number, type: string, triggerAsyncId: number, resource: object): void;
|
||||
/**
|
||||
* When an asynchronous operation is initiated or completes a callback is called to notify the user.
|
||||
* The before callback is called just before said callback is executed.
|
||||
* @param asyncId the unique identifier assigned to the resource about to execute the callback.
|
||||
*/
|
||||
before?(asyncId: number): void;
|
||||
/**
|
||||
* Called immediately after the callback specified in before is completed.
|
||||
* @param asyncId the unique identifier assigned to the resource which has executed the callback.
|
||||
*/
|
||||
after?(asyncId: number): void;
|
||||
/**
|
||||
* Called when a promise has resolve() called. This may not be in the same execution id
|
||||
* as the promise itself.
|
||||
* @param asyncId the unique id for the promise that was resolve()d.
|
||||
*/
|
||||
promiseResolve?(asyncId: number): void;
|
||||
/**
|
||||
* Called after the resource corresponding to asyncId is destroyed
|
||||
* @param asyncId a unique ID for the async resource
|
||||
*/
|
||||
destroy?(asyncId: number): void;
|
||||
}
|
||||
interface AsyncHook {
|
||||
/**
|
||||
* Enable the callbacks for a given AsyncHook instance. If no callbacks are provided enabling is a noop.
|
||||
*/
|
||||
enable(): this;
|
||||
/**
|
||||
* Disable the callbacks for a given AsyncHook instance from the global pool of AsyncHook callbacks to be executed. Once a hook has been disabled it will not be called again until enabled.
|
||||
*/
|
||||
disable(): this;
|
||||
}
|
||||
/**
|
||||
* Registers functions to be called for different lifetime events of each async
|
||||
* operation.
|
||||
*
|
||||
* The callbacks `init()`/`before()`/`after()`/`destroy()` are called for the
|
||||
* respective asynchronous event during a resource's lifetime.
|
||||
*
|
||||
* All callbacks are optional. For example, if only resource cleanup needs to
|
||||
* be tracked, then only the `destroy` callback needs to be passed. The
|
||||
* specifics of all functions that can be passed to `callbacks` is in the `Hook Callbacks` section.
|
||||
*
|
||||
* ```js
|
||||
* import { createHook } from 'async_hooks';
|
||||
*
|
||||
* const asyncHook = createHook({
|
||||
* init(asyncId, type, triggerAsyncId, resource) { },
|
||||
* destroy(asyncId) { }
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* The callbacks will be inherited via the prototype chain:
|
||||
*
|
||||
* ```js
|
||||
* class MyAsyncCallbacks {
|
||||
* init(asyncId, type, triggerAsyncId, resource) { }
|
||||
* destroy(asyncId) {}
|
||||
* }
|
||||
*
|
||||
* class MyAddedCallbacks extends MyAsyncCallbacks {
|
||||
* before(asyncId) { }
|
||||
* after(asyncId) { }
|
||||
* }
|
||||
*
|
||||
* const asyncHook = async_hooks.createHook(new MyAddedCallbacks());
|
||||
* ```
|
||||
*
|
||||
* Because promises are asynchronous resources whose lifecycle is tracked
|
||||
* via the async hooks mechanism, the `init()`, `before()`, `after()`, and`destroy()` callbacks _must not_ be async functions that return promises.
|
||||
* @since v8.1.0
|
||||
* @param callbacks The `Hook Callbacks` to register
|
||||
* @return Instance used for disabling and enabling hooks
|
||||
*/
|
||||
function createHook(callbacks: HookCallbacks): AsyncHook;
|
||||
interface AsyncResourceOptions {
|
||||
/**
|
||||
* The ID of the execution context that created this async event.
|
||||
* @default executionAsyncId()
|
||||
*/
|
||||
triggerAsyncId?: number | undefined;
|
||||
/**
|
||||
* Disables automatic `emitDestroy` when the object is garbage collected.
|
||||
* This usually does not need to be set (even if `emitDestroy` is called
|
||||
* manually), unless the resource's `asyncId` is retrieved and the
|
||||
* sensitive API's `emitDestroy` is called with it.
|
||||
* @default false
|
||||
*/
|
||||
requireManualDestroy?: boolean | undefined;
|
||||
}
|
||||
/**
|
||||
* The class `AsyncResource` is designed to be extended by the embedder's async
|
||||
* resources. Using this, users can easily trigger the lifetime events of their
|
||||
* own resources.
|
||||
*
|
||||
* The `init` hook will trigger when an `AsyncResource` is instantiated.
|
||||
*
|
||||
* The following is an overview of the `AsyncResource` API.
|
||||
*
|
||||
* ```js
|
||||
* import { AsyncResource, executionAsyncId } from 'async_hooks';
|
||||
*
|
||||
* // AsyncResource() is meant to be extended. Instantiating a
|
||||
* // new AsyncResource() also triggers init. If triggerAsyncId is omitted then
|
||||
* // async_hook.executionAsyncId() is used.
|
||||
* const asyncResource = new AsyncResource(
|
||||
* type, { triggerAsyncId: executionAsyncId(), requireManualDestroy: false }
|
||||
* );
|
||||
*
|
||||
* // Run a function in the execution context of the resource. This will
|
||||
* // * establish the context of the resource
|
||||
* // * trigger the AsyncHooks before callbacks
|
||||
* // * call the provided function `fn` with the supplied arguments
|
||||
* // * trigger the AsyncHooks after callbacks
|
||||
* // * restore the original execution context
|
||||
* asyncResource.runInAsyncScope(fn, thisArg, ...args);
|
||||
*
|
||||
* // Call AsyncHooks destroy callbacks.
|
||||
* asyncResource.emitDestroy();
|
||||
*
|
||||
* // Return the unique ID assigned to the AsyncResource instance.
|
||||
* asyncResource.asyncId();
|
||||
*
|
||||
* // Return the trigger ID for the AsyncResource instance.
|
||||
* asyncResource.triggerAsyncId();
|
||||
* ```
|
||||
*/
|
||||
class AsyncResource {
|
||||
/**
|
||||
* AsyncResource() is meant to be extended. Instantiating a
|
||||
* new AsyncResource() also triggers init. If triggerAsyncId is omitted then
|
||||
* async_hook.executionAsyncId() is used.
|
||||
* @param type The type of async event.
|
||||
* @param triggerAsyncId The ID of the execution context that created
|
||||
* this async event (default: `executionAsyncId()`), or an
|
||||
* AsyncResourceOptions object (since v9.3.0)
|
||||
*/
|
||||
constructor(type: string, triggerAsyncId?: number | AsyncResourceOptions);
|
||||
/**
|
||||
* Binds the given function to the current execution context.
|
||||
*
|
||||
* The returned function will have an `asyncResource` property referencing
|
||||
* the `AsyncResource` to which the function is bound.
|
||||
* @since v14.8.0, v12.19.0
|
||||
* @param fn The function to bind to the current execution context.
|
||||
* @param type An optional name to associate with the underlying `AsyncResource`.
|
||||
*/
|
||||
static bind<Func extends (this: ThisArg, ...args: any[]) => any, ThisArg>(
|
||||
fn: Func,
|
||||
type?: string,
|
||||
thisArg?: ThisArg
|
||||
): Func & {
|
||||
asyncResource: AsyncResource;
|
||||
};
|
||||
/**
|
||||
* Binds the given function to execute to this `AsyncResource`'s scope.
|
||||
*
|
||||
* The returned function will have an `asyncResource` property referencing
|
||||
* the `AsyncResource` to which the function is bound.
|
||||
* @since v14.8.0, v12.19.0
|
||||
* @param fn The function to bind to the current `AsyncResource`.
|
||||
*/
|
||||
bind<Func extends (...args: any[]) => any>(
|
||||
fn: Func
|
||||
): Func & {
|
||||
asyncResource: AsyncResource;
|
||||
};
|
||||
/**
|
||||
* Call the provided function with the provided arguments in the execution context
|
||||
* of the async resource. This will establish the context, trigger the AsyncHooks
|
||||
* before callbacks, call the function, trigger the AsyncHooks after callbacks, and
|
||||
* then restore the original execution context.
|
||||
* @since v9.6.0
|
||||
* @param fn The function to call in the execution context of this async resource.
|
||||
* @param thisArg The receiver to be used for the function call.
|
||||
* @param args Optional arguments to pass to the function.
|
||||
*/
|
||||
runInAsyncScope<This, Result>(fn: (this: This, ...args: any[]) => Result, thisArg?: This, ...args: any[]): Result;
|
||||
/**
|
||||
* Call all `destroy` hooks. This should only ever be called once. An error will
|
||||
* be thrown if it is called more than once. This **must** be manually called. If
|
||||
* the resource is left to be collected by the GC then the `destroy` hooks will
|
||||
* never be called.
|
||||
* @return A reference to `asyncResource`.
|
||||
*/
|
||||
emitDestroy(): this;
|
||||
/**
|
||||
* @return The unique `asyncId` assigned to the resource.
|
||||
*/
|
||||
asyncId(): number;
|
||||
/**
|
||||
*
|
||||
* @return The same `triggerAsyncId` that is passed to the `AsyncResource` constructor.
|
||||
*/
|
||||
triggerAsyncId(): number;
|
||||
}
|
||||
/**
|
||||
* This class creates stores that stay coherent through asynchronous operations.
|
||||
*
|
||||
* While you can create your own implementation on top of the `async_hooks` module,`AsyncLocalStorage` should be preferred as it is a performant and memory safe
|
||||
* implementation that involves significant optimizations that are non-obvious to
|
||||
* implement.
|
||||
*
|
||||
* The following example uses `AsyncLocalStorage` to build a simple logger
|
||||
* that assigns IDs to incoming HTTP requests and includes them in messages
|
||||
* logged within each request.
|
||||
*
|
||||
* ```js
|
||||
* import http from 'http';
|
||||
* import { AsyncLocalStorage } from 'async_hooks';
|
||||
*
|
||||
* const asyncLocalStorage = new AsyncLocalStorage();
|
||||
*
|
||||
* function logWithId(msg) {
|
||||
* const id = asyncLocalStorage.getStore();
|
||||
* console.log(`${id !== undefined ? id : '-'}:`, msg);
|
||||
* }
|
||||
*
|
||||
* let idSeq = 0;
|
||||
* http.createServer((req, res) => {
|
||||
* asyncLocalStorage.run(idSeq++, () => {
|
||||
* logWithId('start');
|
||||
* // Imagine any chain of async operations here
|
||||
* setImmediate(() => {
|
||||
* logWithId('finish');
|
||||
* res.end();
|
||||
* });
|
||||
* });
|
||||
* }).listen(8080);
|
||||
*
|
||||
* http.get('http://localhost:8080');
|
||||
* http.get('http://localhost:8080');
|
||||
* // Prints:
|
||||
* // 0: start
|
||||
* // 1: start
|
||||
* // 0: finish
|
||||
* // 1: finish
|
||||
* ```
|
||||
*
|
||||
* Each instance of `AsyncLocalStorage` maintains an independent storage context.
|
||||
* Multiple instances can safely exist simultaneously without risk of interfering
|
||||
* with each other's data.
|
||||
* @since v13.10.0, v12.17.0
|
||||
*/
|
||||
class AsyncLocalStorage<T> {
|
||||
/**
|
||||
* Disables the instance of `AsyncLocalStorage`. All subsequent calls
|
||||
* to `asyncLocalStorage.getStore()` will return `undefined` until`asyncLocalStorage.run()` or `asyncLocalStorage.enterWith()` is called again.
|
||||
*
|
||||
* When calling `asyncLocalStorage.disable()`, all current contexts linked to the
|
||||
* instance will be exited.
|
||||
*
|
||||
* Calling `asyncLocalStorage.disable()` is required before the`asyncLocalStorage` can be garbage collected. This does not apply to stores
|
||||
* provided by the `asyncLocalStorage`, as those objects are garbage collected
|
||||
* along with the corresponding async resources.
|
||||
*
|
||||
* Use this method when the `asyncLocalStorage` is not in use anymore
|
||||
* in the current process.
|
||||
* @since v13.10.0, v12.17.0
|
||||
* @experimental
|
||||
*/
|
||||
disable(): void;
|
||||
/**
|
||||
* Returns the current store.
|
||||
* If called outside of an asynchronous context initialized by
|
||||
* calling `asyncLocalStorage.run()` or `asyncLocalStorage.enterWith()`, it
|
||||
* returns `undefined`.
|
||||
* @since v13.10.0, v12.17.0
|
||||
*/
|
||||
getStore(): T | undefined;
|
||||
/**
|
||||
* Runs a function synchronously within a context and returns its
|
||||
* return value. The store is not accessible outside of the callback function.
|
||||
* The store is accessible to any asynchronous operations created within the
|
||||
* callback.
|
||||
*
|
||||
* The optional `args` are passed to the callback function.
|
||||
*
|
||||
* If the callback function throws an error, the error is thrown by `run()` too.
|
||||
* The stacktrace is not impacted by this call and the context is exited.
|
||||
*
|
||||
* Example:
|
||||
*
|
||||
* ```js
|
||||
* const store = { id: 2 };
|
||||
* try {
|
||||
* asyncLocalStorage.run(store, () => {
|
||||
* asyncLocalStorage.getStore(); // Returns the store object
|
||||
* setTimeout(() => {
|
||||
* asyncLocalStorage.getStore(); // Returns the store object
|
||||
* }, 200);
|
||||
* throw new Error();
|
||||
* });
|
||||
* } catch (e) {
|
||||
* asyncLocalStorage.getStore(); // Returns undefined
|
||||
* // The error will be caught here
|
||||
* }
|
||||
* ```
|
||||
* @since v13.10.0, v12.17.0
|
||||
*/
|
||||
run<R, TArgs extends any[]>(store: T, callback: (...args: TArgs) => R, ...args: TArgs): R;
|
||||
/**
|
||||
* Runs a function synchronously outside of a context and returns its
|
||||
* return value. The store is not accessible within the callback function or
|
||||
* the asynchronous operations created within the callback. Any `getStore()`call done within the callback function will always return `undefined`.
|
||||
*
|
||||
* The optional `args` are passed to the callback function.
|
||||
*
|
||||
* If the callback function throws an error, the error is thrown by `exit()` too.
|
||||
* The stacktrace is not impacted by this call and the context is re-entered.
|
||||
*
|
||||
* Example:
|
||||
*
|
||||
* ```js
|
||||
* // Within a call to run
|
||||
* try {
|
||||
* asyncLocalStorage.getStore(); // Returns the store object or value
|
||||
* asyncLocalStorage.exit(() => {
|
||||
* asyncLocalStorage.getStore(); // Returns undefined
|
||||
* throw new Error();
|
||||
* });
|
||||
* } catch (e) {
|
||||
* asyncLocalStorage.getStore(); // Returns the same object or value
|
||||
* // The error will be caught here
|
||||
* }
|
||||
* ```
|
||||
* @since v13.10.0, v12.17.0
|
||||
* @experimental
|
||||
*/
|
||||
exit<R, TArgs extends any[]>(callback: (...args: TArgs) => R, ...args: TArgs): R;
|
||||
/**
|
||||
* Transitions into the context for the remainder of the current
|
||||
* synchronous execution and then persists the store through any following
|
||||
* asynchronous calls.
|
||||
*
|
||||
* Example:
|
||||
*
|
||||
* ```js
|
||||
* const store = { id: 1 };
|
||||
* // Replaces previous store with the given store object
|
||||
* asyncLocalStorage.enterWith(store);
|
||||
* asyncLocalStorage.getStore(); // Returns the store object
|
||||
* someAsyncOperation(() => {
|
||||
* asyncLocalStorage.getStore(); // Returns the same object
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* This transition will continue for the _entire_ synchronous execution.
|
||||
* This means that if, for example, the context is entered within an event
|
||||
* handler subsequent event handlers will also run within that context unless
|
||||
* specifically bound to another context with an `AsyncResource`. That is why`run()` should be preferred over `enterWith()` unless there are strong reasons
|
||||
* to use the latter method.
|
||||
*
|
||||
* ```js
|
||||
* const store = { id: 1 };
|
||||
*
|
||||
* emitter.on('my-event', () => {
|
||||
* asyncLocalStorage.enterWith(store);
|
||||
* });
|
||||
* emitter.on('my-event', () => {
|
||||
* asyncLocalStorage.getStore(); // Returns the same object
|
||||
* });
|
||||
*
|
||||
* asyncLocalStorage.getStore(); // Returns undefined
|
||||
* emitter.emit('my-event');
|
||||
* asyncLocalStorage.getStore(); // Returns the same object
|
||||
* ```
|
||||
* @since v13.11.0, v12.17.0
|
||||
* @experimental
|
||||
*/
|
||||
enterWith(store: T): void;
|
||||
}
|
||||
}
|
||||
declare module 'node:async_hooks' {
|
||||
export * from 'async_hooks';
|
||||
}
|
File diff suppressed because it is too large
Load Diff
1369
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/child_process.d.ts
generated
vendored
1369
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/child_process.d.ts
generated
vendored
File diff suppressed because it is too large
Load Diff
18
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/constants.d.ts
generated
vendored
18
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/constants.d.ts
generated
vendored
@ -0,0 +1,18 @@
|
||||
/** @deprecated since v6.3.0 - use constants property exposed by the relevant module instead. */
|
||||
declare module 'constants' {
|
||||
import { constants as osConstants, SignalConstants } from 'node:os';
|
||||
import { constants as cryptoConstants } from 'node:crypto';
|
||||
import { constants as fsConstants } from 'node:fs';
|
||||
|
||||
const exp: typeof osConstants.errno &
|
||||
typeof osConstants.priority &
|
||||
SignalConstants &
|
||||
typeof cryptoConstants &
|
||||
typeof fsConstants;
|
||||
export = exp;
|
||||
}
|
||||
|
||||
declare module 'node:constants' {
|
||||
import constants = require('constants');
|
||||
export = constants;
|
||||
}
|
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,545 @@
|
||||
/**
|
||||
* The `dgram` module provides an implementation of UDP datagram sockets.
|
||||
*
|
||||
* ```js
|
||||
* import dgram from 'dgram';
|
||||
*
|
||||
* const server = dgram.createSocket('udp4');
|
||||
*
|
||||
* server.on('error', (err) => {
|
||||
* console.log(`server error:\n${err.stack}`);
|
||||
* server.close();
|
||||
* });
|
||||
*
|
||||
* server.on('message', (msg, rinfo) => {
|
||||
* console.log(`server got: ${msg} from ${rinfo.address}:${rinfo.port}`);
|
||||
* });
|
||||
*
|
||||
* server.on('listening', () => {
|
||||
* const address = server.address();
|
||||
* console.log(`server listening ${address.address}:${address.port}`);
|
||||
* });
|
||||
*
|
||||
* server.bind(41234);
|
||||
* // Prints: server listening 0.0.0.0:41234
|
||||
* ```
|
||||
* @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/dgram.js)
|
||||
*/
|
||||
declare module 'dgram' {
|
||||
import { AddressInfo } from 'node:net';
|
||||
import * as dns from 'node:dns';
|
||||
import { EventEmitter, Abortable } from 'node:events';
|
||||
interface RemoteInfo {
|
||||
address: string;
|
||||
family: 'IPv4' | 'IPv6';
|
||||
port: number;
|
||||
size: number;
|
||||
}
|
||||
interface BindOptions {
|
||||
port?: number | undefined;
|
||||
address?: string | undefined;
|
||||
exclusive?: boolean | undefined;
|
||||
fd?: number | undefined;
|
||||
}
|
||||
type SocketType = 'udp4' | 'udp6';
|
||||
interface SocketOptions extends Abortable {
|
||||
type: SocketType;
|
||||
reuseAddr?: boolean | undefined;
|
||||
/**
|
||||
* @default false
|
||||
*/
|
||||
ipv6Only?: boolean | undefined;
|
||||
recvBufferSize?: number | undefined;
|
||||
sendBufferSize?: number | undefined;
|
||||
lookup?: ((hostname: string, options: dns.LookupOneOptions, callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void) => void) | undefined;
|
||||
}
|
||||
/**
|
||||
* Creates a `dgram.Socket` object. Once the socket is created, calling `socket.bind()` will instruct the socket to begin listening for datagram
|
||||
* messages. When `address` and `port` are not passed to `socket.bind()` the
|
||||
* method will bind the socket to the "all interfaces" address on a random port
|
||||
* (it does the right thing for both `udp4` and `udp6` sockets). The bound address
|
||||
* and port can be retrieved using `socket.address().address` and `socket.address().port`.
|
||||
*
|
||||
* If the `signal` option is enabled, calling `.abort()` on the corresponding`AbortController` is similar to calling `.close()` on the socket:
|
||||
*
|
||||
* ```js
|
||||
* const controller = new AbortController();
|
||||
* const { signal } = controller;
|
||||
* const server = dgram.createSocket({ type: 'udp4', signal });
|
||||
* server.on('message', (msg, rinfo) => {
|
||||
* console.log(`server got: ${msg} from ${rinfo.address}:${rinfo.port}`);
|
||||
* });
|
||||
* // Later, when you want to close the server.
|
||||
* controller.abort();
|
||||
* ```
|
||||
* @since v0.11.13
|
||||
* @param options Available options are:
|
||||
* @param callback Attached as a listener for `'message'` events. Optional.
|
||||
*/
|
||||
function createSocket(type: SocketType, callback?: (msg: Buffer, rinfo: RemoteInfo) => void): Socket;
|
||||
function createSocket(options: SocketOptions, callback?: (msg: Buffer, rinfo: RemoteInfo) => void): Socket;
|
||||
/**
|
||||
* Encapsulates the datagram functionality.
|
||||
*
|
||||
* New instances of `dgram.Socket` are created using {@link createSocket}.
|
||||
* The `new` keyword is not to be used to create `dgram.Socket` instances.
|
||||
* @since v0.1.99
|
||||
*/
|
||||
class Socket extends EventEmitter {
|
||||
/**
|
||||
* Tells the kernel to join a multicast group at the given `multicastAddress` and`multicastInterface` using the `IP_ADD_MEMBERSHIP` socket option. If the`multicastInterface` argument is not
|
||||
* specified, the operating system will choose
|
||||
* one interface and will add membership to it. To add membership to every
|
||||
* available interface, call `addMembership` multiple times, once per interface.
|
||||
*
|
||||
* When called on an unbound socket, this method will implicitly bind to a random
|
||||
* port, listening on all interfaces.
|
||||
*
|
||||
* When sharing a UDP socket across multiple `cluster` workers, the`socket.addMembership()` function must be called only once or an`EADDRINUSE` error will occur:
|
||||
*
|
||||
* ```js
|
||||
* import cluster from 'cluster';
|
||||
* import dgram from 'dgram';
|
||||
*
|
||||
* if (cluster.isPrimary) {
|
||||
* cluster.fork(); // Works ok.
|
||||
* cluster.fork(); // Fails with EADDRINUSE.
|
||||
* } else {
|
||||
* const s = dgram.createSocket('udp4');
|
||||
* s.bind(1234, () => {
|
||||
* s.addMembership('224.0.0.114');
|
||||
* });
|
||||
* }
|
||||
* ```
|
||||
* @since v0.6.9
|
||||
*/
|
||||
addMembership(multicastAddress: string, multicastInterface?: string): void;
|
||||
/**
|
||||
* Returns an object containing the address information for a socket.
|
||||
* For UDP sockets, this object will contain `address`, `family` and `port`properties.
|
||||
*
|
||||
* This method throws `EBADF` if called on an unbound socket.
|
||||
* @since v0.1.99
|
||||
*/
|
||||
address(): AddressInfo;
|
||||
/**
|
||||
* For UDP sockets, causes the `dgram.Socket` to listen for datagram
|
||||
* messages on a named `port` and optional `address`. If `port` is not
|
||||
* specified or is `0`, the operating system will attempt to bind to a
|
||||
* random port. If `address` is not specified, the operating system will
|
||||
* attempt to listen on all addresses. Once binding is complete, a`'listening'` event is emitted and the optional `callback` function is
|
||||
* called.
|
||||
*
|
||||
* Specifying both a `'listening'` event listener and passing a`callback` to the `socket.bind()` method is not harmful but not very
|
||||
* useful.
|
||||
*
|
||||
* A bound datagram socket keeps the Node.js process running to receive
|
||||
* datagram messages.
|
||||
*
|
||||
* If binding fails, an `'error'` event is generated. In rare case (e.g.
|
||||
* attempting to bind with a closed socket), an `Error` may be thrown.
|
||||
*
|
||||
* Example of a UDP server listening on port 41234:
|
||||
*
|
||||
* ```js
|
||||
* import dgram from 'dgram';
|
||||
*
|
||||
* const server = dgram.createSocket('udp4');
|
||||
*
|
||||
* server.on('error', (err) => {
|
||||
* console.log(`server error:\n${err.stack}`);
|
||||
* server.close();
|
||||
* });
|
||||
*
|
||||
* server.on('message', (msg, rinfo) => {
|
||||
* console.log(`server got: ${msg} from ${rinfo.address}:${rinfo.port}`);
|
||||
* });
|
||||
*
|
||||
* server.on('listening', () => {
|
||||
* const address = server.address();
|
||||
* console.log(`server listening ${address.address}:${address.port}`);
|
||||
* });
|
||||
*
|
||||
* server.bind(41234);
|
||||
* // Prints: server listening 0.0.0.0:41234
|
||||
* ```
|
||||
* @since v0.1.99
|
||||
* @param callback with no parameters. Called when binding is complete.
|
||||
*/
|
||||
bind(port?: number, address?: string, callback?: () => void): this;
|
||||
bind(port?: number, callback?: () => void): this;
|
||||
bind(callback?: () => void): this;
|
||||
bind(options: BindOptions, callback?: () => void): this;
|
||||
/**
|
||||
* Close the underlying socket and stop listening for data on it. If a callback is
|
||||
* provided, it is added as a listener for the `'close'` event.
|
||||
* @since v0.1.99
|
||||
* @param callback Called when the socket has been closed.
|
||||
*/
|
||||
close(callback?: () => void): this;
|
||||
/**
|
||||
* Associates the `dgram.Socket` to a remote address and port. Every
|
||||
* message sent by this handle is automatically sent to that destination. Also,
|
||||
* the socket will only receive messages from that remote peer.
|
||||
* Trying to call `connect()` on an already connected socket will result
|
||||
* in an `ERR_SOCKET_DGRAM_IS_CONNECTED` exception. If `address` is not
|
||||
* provided, `'127.0.0.1'` (for `udp4` sockets) or `'::1'` (for `udp6` sockets)
|
||||
* will be used by default. Once the connection is complete, a `'connect'` event
|
||||
* is emitted and the optional `callback` function is called. In case of failure,
|
||||
* the `callback` is called or, failing this, an `'error'` event is emitted.
|
||||
* @since v12.0.0
|
||||
* @param callback Called when the connection is completed or on error.
|
||||
*/
|
||||
connect(port: number, address?: string, callback?: () => void): void;
|
||||
connect(port: number, callback: () => void): void;
|
||||
/**
|
||||
* A synchronous function that disassociates a connected `dgram.Socket` from
|
||||
* its remote address. Trying to call `disconnect()` on an unbound or already
|
||||
* disconnected socket will result in an `ERR_SOCKET_DGRAM_NOT_CONNECTED` exception.
|
||||
* @since v12.0.0
|
||||
*/
|
||||
disconnect(): void;
|
||||
/**
|
||||
* Instructs the kernel to leave a multicast group at `multicastAddress` using the`IP_DROP_MEMBERSHIP` socket option. This method is automatically called by the
|
||||
* kernel when the socket is closed or the process terminates, so most apps will
|
||||
* never have reason to call this.
|
||||
*
|
||||
* If `multicastInterface` is not specified, the operating system will attempt to
|
||||
* drop membership on all valid interfaces.
|
||||
* @since v0.6.9
|
||||
*/
|
||||
dropMembership(multicastAddress: string, multicastInterface?: string): void;
|
||||
/**
|
||||
* This method throws `ERR_SOCKET_BUFFER_SIZE` if called on an unbound socket.
|
||||
* @since v8.7.0
|
||||
* @return the `SO_RCVBUF` socket receive buffer size in bytes.
|
||||
*/
|
||||
getRecvBufferSize(): number;
|
||||
/**
|
||||
* This method throws `ERR_SOCKET_BUFFER_SIZE` if called on an unbound socket.
|
||||
* @since v8.7.0
|
||||
* @return the `SO_SNDBUF` socket send buffer size in bytes.
|
||||
*/
|
||||
getSendBufferSize(): number;
|
||||
/**
|
||||
* By default, binding a socket will cause it to block the Node.js process from
|
||||
* exiting as long as the socket is open. The `socket.unref()` method can be used
|
||||
* to exclude the socket from the reference counting that keeps the Node.js
|
||||
* process active. The `socket.ref()` method adds the socket back to the reference
|
||||
* counting and restores the default behavior.
|
||||
*
|
||||
* Calling `socket.ref()` multiples times will have no additional effect.
|
||||
*
|
||||
* The `socket.ref()` method returns a reference to the socket so calls can be
|
||||
* chained.
|
||||
* @since v0.9.1
|
||||
*/
|
||||
ref(): this;
|
||||
/**
|
||||
* Returns an object containing the `address`, `family`, and `port` of the remote
|
||||
* endpoint. This method throws an `ERR_SOCKET_DGRAM_NOT_CONNECTED` exception
|
||||
* if the socket is not connected.
|
||||
* @since v12.0.0
|
||||
*/
|
||||
remoteAddress(): AddressInfo;
|
||||
/**
|
||||
* Broadcasts a datagram on the socket.
|
||||
* For connectionless sockets, the destination `port` and `address` must be
|
||||
* specified. Connected sockets, on the other hand, will use their associated
|
||||
* remote endpoint, so the `port` and `address` arguments must not be set.
|
||||
*
|
||||
* The `msg` argument contains the message to be sent.
|
||||
* Depending on its type, different behavior can apply. If `msg` is a `Buffer`,
|
||||
* any `TypedArray` or a `DataView`,
|
||||
* the `offset` and `length` specify the offset within the `Buffer` where the
|
||||
* message begins and the number of bytes in the message, respectively.
|
||||
* If `msg` is a `String`, then it is automatically converted to a `Buffer`with `'utf8'` encoding. With messages that
|
||||
* contain multi-byte characters, `offset` and `length` will be calculated with
|
||||
* respect to `byte length` and not the character position.
|
||||
* If `msg` is an array, `offset` and `length` must not be specified.
|
||||
*
|
||||
* The `address` argument is a string. If the value of `address` is a host name,
|
||||
* DNS will be used to resolve the address of the host. If `address` is not
|
||||
* provided or otherwise nullish, `'127.0.0.1'` (for `udp4` sockets) or `'::1'`(for `udp6` sockets) will be used by default.
|
||||
*
|
||||
* If the socket has not been previously bound with a call to `bind`, the socket
|
||||
* is assigned a random port number and is bound to the "all interfaces" address
|
||||
* (`'0.0.0.0'` for `udp4` sockets, `'::0'` for `udp6` sockets.)
|
||||
*
|
||||
* An optional `callback` function may be specified to as a way of reporting
|
||||
* DNS errors or for determining when it is safe to reuse the `buf` object.
|
||||
* DNS lookups delay the time to send for at least one tick of the
|
||||
* Node.js event loop.
|
||||
*
|
||||
* The only way to know for sure that the datagram has been sent is by using a`callback`. If an error occurs and a `callback` is given, the error will be
|
||||
* passed as the first argument to the `callback`. If a `callback` is not given,
|
||||
* the error is emitted as an `'error'` event on the `socket` object.
|
||||
*
|
||||
* Offset and length are optional but both _must_ be set if either are used.
|
||||
* They are supported only when the first argument is a `Buffer`, a `TypedArray`,
|
||||
* or a `DataView`.
|
||||
*
|
||||
* This method throws `ERR_SOCKET_BAD_PORT` if called on an unbound socket.
|
||||
*
|
||||
* Example of sending a UDP packet to a port on `localhost`;
|
||||
*
|
||||
* ```js
|
||||
* import dgram from 'dgram';
|
||||
* import { Buffer } from 'buffer';
|
||||
*
|
||||
* const message = Buffer.from('Some bytes');
|
||||
* const client = dgram.createSocket('udp4');
|
||||
* client.send(message, 41234, 'localhost', (err) => {
|
||||
* client.close();
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* Example of sending a UDP packet composed of multiple buffers to a port on`127.0.0.1`;
|
||||
*
|
||||
* ```js
|
||||
* import dgram from 'dgram';
|
||||
* import { Buffer } from 'buffer';
|
||||
*
|
||||
* const buf1 = Buffer.from('Some ');
|
||||
* const buf2 = Buffer.from('bytes');
|
||||
* const client = dgram.createSocket('udp4');
|
||||
* client.send([buf1, buf2], 41234, (err) => {
|
||||
* client.close();
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* Sending multiple buffers might be faster or slower depending on the
|
||||
* application and operating system. Run benchmarks to
|
||||
* determine the optimal strategy on a case-by-case basis. Generally speaking,
|
||||
* however, sending multiple buffers is faster.
|
||||
*
|
||||
* Example of sending a UDP packet using a socket connected to a port on`localhost`:
|
||||
*
|
||||
* ```js
|
||||
* import dgram from 'dgram';
|
||||
* import { Buffer } from 'buffer';
|
||||
*
|
||||
* const message = Buffer.from('Some bytes');
|
||||
* const client = dgram.createSocket('udp4');
|
||||
* client.connect(41234, 'localhost', (err) => {
|
||||
* client.send(message, (err) => {
|
||||
* client.close();
|
||||
* });
|
||||
* });
|
||||
* ```
|
||||
* @since v0.1.99
|
||||
* @param msg Message to be sent.
|
||||
* @param offset Offset in the buffer where the message starts.
|
||||
* @param length Number of bytes in the message.
|
||||
* @param port Destination port.
|
||||
* @param address Destination host name or IP address.
|
||||
* @param callback Called when the message has been sent.
|
||||
*/
|
||||
send(msg: string | Uint8Array | ReadonlyArray<any>, port?: number, address?: string, callback?: (error: Error | null, bytes: number) => void): void;
|
||||
send(msg: string | Uint8Array | ReadonlyArray<any>, port?: number, callback?: (error: Error | null, bytes: number) => void): void;
|
||||
send(msg: string | Uint8Array | ReadonlyArray<any>, callback?: (error: Error | null, bytes: number) => void): void;
|
||||
send(msg: string | Uint8Array, offset: number, length: number, port?: number, address?: string, callback?: (error: Error | null, bytes: number) => void): void;
|
||||
send(msg: string | Uint8Array, offset: number, length: number, port?: number, callback?: (error: Error | null, bytes: number) => void): void;
|
||||
send(msg: string | Uint8Array, offset: number, length: number, callback?: (error: Error | null, bytes: number) => void): void;
|
||||
/**
|
||||
* Sets or clears the `SO_BROADCAST` socket option. When set to `true`, UDP
|
||||
* packets may be sent to a local interface's broadcast address.
|
||||
*
|
||||
* This method throws `EBADF` if called on an unbound socket.
|
||||
* @since v0.6.9
|
||||
*/
|
||||
setBroadcast(flag: boolean): void;
|
||||
/**
|
||||
* _All references to scope in this section are referring to [IPv6 Zone Indices](https://en.wikipedia.org/wiki/IPv6_address#Scoped_literal_IPv6_addresses), which are defined by [RFC
|
||||
* 4007](https://tools.ietf.org/html/rfc4007). In string form, an IP_
|
||||
* _with a scope index is written as `'IP%scope'` where scope is an interface name_
|
||||
* _or interface number._
|
||||
*
|
||||
* Sets the default outgoing multicast interface of the socket to a chosen
|
||||
* interface or back to system interface selection. The `multicastInterface` must
|
||||
* be a valid string representation of an IP from the socket's family.
|
||||
*
|
||||
* For IPv4 sockets, this should be the IP configured for the desired physical
|
||||
* interface. All packets sent to multicast on the socket will be sent on the
|
||||
* interface determined by the most recent successful use of this call.
|
||||
*
|
||||
* For IPv6 sockets, `multicastInterface` should include a scope to indicate the
|
||||
* interface as in the examples that follow. In IPv6, individual `send` calls can
|
||||
* also use explicit scope in addresses, so only packets sent to a multicast
|
||||
* address without specifying an explicit scope are affected by the most recent
|
||||
* successful use of this call.
|
||||
*
|
||||
* This method throws `EBADF` if called on an unbound socket.
|
||||
*
|
||||
* #### Example: IPv6 outgoing multicast interface
|
||||
*
|
||||
* On most systems, where scope format uses the interface name:
|
||||
*
|
||||
* ```js
|
||||
* const socket = dgram.createSocket('udp6');
|
||||
*
|
||||
* socket.bind(1234, () => {
|
||||
* socket.setMulticastInterface('::%eth1');
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* On Windows, where scope format uses an interface number:
|
||||
*
|
||||
* ```js
|
||||
* const socket = dgram.createSocket('udp6');
|
||||
*
|
||||
* socket.bind(1234, () => {
|
||||
* socket.setMulticastInterface('::%2');
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* #### Example: IPv4 outgoing multicast interface
|
||||
*
|
||||
* All systems use an IP of the host on the desired physical interface:
|
||||
*
|
||||
* ```js
|
||||
* const socket = dgram.createSocket('udp4');
|
||||
*
|
||||
* socket.bind(1234, () => {
|
||||
* socket.setMulticastInterface('10.0.0.2');
|
||||
* });
|
||||
* ```
|
||||
* @since v8.6.0
|
||||
*/
|
||||
setMulticastInterface(multicastInterface: string): void;
|
||||
/**
|
||||
* Sets or clears the `IP_MULTICAST_LOOP` socket option. When set to `true`,
|
||||
* multicast packets will also be received on the local interface.
|
||||
*
|
||||
* This method throws `EBADF` if called on an unbound socket.
|
||||
* @since v0.3.8
|
||||
*/
|
||||
setMulticastLoopback(flag: boolean): boolean;
|
||||
/**
|
||||
* Sets the `IP_MULTICAST_TTL` socket option. While TTL generally stands for
|
||||
* "Time to Live", in this context it specifies the number of IP hops that a
|
||||
* packet is allowed to travel through, specifically for multicast traffic. Each
|
||||
* router or gateway that forwards a packet decrements the TTL. If the TTL is
|
||||
* decremented to 0 by a router, it will not be forwarded.
|
||||
*
|
||||
* The `ttl` argument may be between 0 and 255\. The default on most systems is `1`.
|
||||
*
|
||||
* This method throws `EBADF` if called on an unbound socket.
|
||||
* @since v0.3.8
|
||||
*/
|
||||
setMulticastTTL(ttl: number): number;
|
||||
/**
|
||||
* Sets the `SO_RCVBUF` socket option. Sets the maximum socket receive buffer
|
||||
* in bytes.
|
||||
*
|
||||
* This method throws `ERR_SOCKET_BUFFER_SIZE` if called on an unbound socket.
|
||||
* @since v8.7.0
|
||||
*/
|
||||
setRecvBufferSize(size: number): void;
|
||||
/**
|
||||
* Sets the `SO_SNDBUF` socket option. Sets the maximum socket send buffer
|
||||
* in bytes.
|
||||
*
|
||||
* This method throws `ERR_SOCKET_BUFFER_SIZE` if called on an unbound socket.
|
||||
* @since v8.7.0
|
||||
*/
|
||||
setSendBufferSize(size: number): void;
|
||||
/**
|
||||
* Sets the `IP_TTL` socket option. While TTL generally stands for "Time to Live",
|
||||
* in this context it specifies the number of IP hops that a packet is allowed to
|
||||
* travel through. Each router or gateway that forwards a packet decrements the
|
||||
* TTL. If the TTL is decremented to 0 by a router, it will not be forwarded.
|
||||
* Changing TTL values is typically done for network probes or when multicasting.
|
||||
*
|
||||
* The `ttl` argument may be between 1 and 255\. The default on most systems
|
||||
* is 64.
|
||||
*
|
||||
* This method throws `EBADF` if called on an unbound socket.
|
||||
* @since v0.1.101
|
||||
*/
|
||||
setTTL(ttl: number): number;
|
||||
/**
|
||||
* By default, binding a socket will cause it to block the Node.js process from
|
||||
* exiting as long as the socket is open. The `socket.unref()` method can be used
|
||||
* to exclude the socket from the reference counting that keeps the Node.js
|
||||
* process active, allowing the process to exit even if the socket is still
|
||||
* listening.
|
||||
*
|
||||
* Calling `socket.unref()` multiple times will have no addition effect.
|
||||
*
|
||||
* The `socket.unref()` method returns a reference to the socket so calls can be
|
||||
* chained.
|
||||
* @since v0.9.1
|
||||
*/
|
||||
unref(): this;
|
||||
/**
|
||||
* Tells the kernel to join a source-specific multicast channel at the given`sourceAddress` and `groupAddress`, using the `multicastInterface` with the`IP_ADD_SOURCE_MEMBERSHIP` socket
|
||||
* option. If the `multicastInterface` argument
|
||||
* is not specified, the operating system will choose one interface and will add
|
||||
* membership to it. To add membership to every available interface, call`socket.addSourceSpecificMembership()` multiple times, once per interface.
|
||||
*
|
||||
* When called on an unbound socket, this method will implicitly bind to a random
|
||||
* port, listening on all interfaces.
|
||||
* @since v13.1.0, v12.16.0
|
||||
*/
|
||||
addSourceSpecificMembership(sourceAddress: string, groupAddress: string, multicastInterface?: string): void;
|
||||
/**
|
||||
* Instructs the kernel to leave a source-specific multicast channel at the given`sourceAddress` and `groupAddress` using the `IP_DROP_SOURCE_MEMBERSHIP`socket option. This method is
|
||||
* automatically called by the kernel when the
|
||||
* socket is closed or the process terminates, so most apps will never have
|
||||
* reason to call this.
|
||||
*
|
||||
* If `multicastInterface` is not specified, the operating system will attempt to
|
||||
* drop membership on all valid interfaces.
|
||||
* @since v13.1.0, v12.16.0
|
||||
*/
|
||||
dropSourceSpecificMembership(sourceAddress: string, groupAddress: string, multicastInterface?: string): void;
|
||||
/**
|
||||
* events.EventEmitter
|
||||
* 1. close
|
||||
* 2. connect
|
||||
* 3. error
|
||||
* 4. listening
|
||||
* 5. message
|
||||
*/
|
||||
addListener(event: string, listener: (...args: any[]) => void): this;
|
||||
addListener(event: 'close', listener: () => void): this;
|
||||
addListener(event: 'connect', listener: () => void): this;
|
||||
addListener(event: 'error', listener: (err: Error) => void): this;
|
||||
addListener(event: 'listening', listener: () => void): this;
|
||||
addListener(event: 'message', listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
|
||||
emit(event: string | symbol, ...args: any[]): boolean;
|
||||
emit(event: 'close'): boolean;
|
||||
emit(event: 'connect'): boolean;
|
||||
emit(event: 'error', err: Error): boolean;
|
||||
emit(event: 'listening'): boolean;
|
||||
emit(event: 'message', msg: Buffer, rinfo: RemoteInfo): boolean;
|
||||
on(event: string, listener: (...args: any[]) => void): this;
|
||||
on(event: 'close', listener: () => void): this;
|
||||
on(event: 'connect', listener: () => void): this;
|
||||
on(event: 'error', listener: (err: Error) => void): this;
|
||||
on(event: 'listening', listener: () => void): this;
|
||||
on(event: 'message', listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
|
||||
once(event: string, listener: (...args: any[]) => void): this;
|
||||
once(event: 'close', listener: () => void): this;
|
||||
once(event: 'connect', listener: () => void): this;
|
||||
once(event: 'error', listener: (err: Error) => void): this;
|
||||
once(event: 'listening', listener: () => void): this;
|
||||
once(event: 'message', listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
|
||||
prependListener(event: string, listener: (...args: any[]) => void): this;
|
||||
prependListener(event: 'close', listener: () => void): this;
|
||||
prependListener(event: 'connect', listener: () => void): this;
|
||||
prependListener(event: 'error', listener: (err: Error) => void): this;
|
||||
prependListener(event: 'listening', listener: () => void): this;
|
||||
prependListener(event: 'message', listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
|
||||
prependOnceListener(event: string, listener: (...args: any[]) => void): this;
|
||||
prependOnceListener(event: 'close', listener: () => void): this;
|
||||
prependOnceListener(event: 'connect', listener: () => void): this;
|
||||
prependOnceListener(event: 'error', listener: (err: Error) => void): this;
|
||||
prependOnceListener(event: 'listening', listener: () => void): this;
|
||||
prependOnceListener(event: 'message', listener: (msg: Buffer, rinfo: RemoteInfo) => void): this;
|
||||
}
|
||||
}
|
||||
declare module 'node:dgram' {
|
||||
export * from 'dgram';
|
||||
}
|
153
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/diagnostics_channel.d.ts
generated
vendored
153
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/diagnostics_channel.d.ts
generated
vendored
@ -0,0 +1,153 @@
|
||||
/**
|
||||
* The `diagnostics_channel` module provides an API to create named channels
|
||||
* to report arbitrary message data for diagnostics purposes.
|
||||
*
|
||||
* It can be accessed using:
|
||||
*
|
||||
* ```js
|
||||
* import diagnostics_channel from 'diagnostics_channel';
|
||||
* ```
|
||||
*
|
||||
* It is intended that a module writer wanting to report diagnostics messages
|
||||
* will create one or many top-level channels to report messages through.
|
||||
* Channels may also be acquired at runtime but it is not encouraged
|
||||
* due to the additional overhead of doing so. Channels may be exported for
|
||||
* convenience, but as long as the name is known it can be acquired anywhere.
|
||||
*
|
||||
* If you intend for your module to produce diagnostics data for others to
|
||||
* consume it is recommended that you include documentation of what named
|
||||
* channels are used along with the shape of the message data. Channel names
|
||||
* should generally include the module name to avoid collisions with data from
|
||||
* other modules.
|
||||
* @experimental
|
||||
* @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/diagnostics_channel.js)
|
||||
*/
|
||||
declare module 'diagnostics_channel' {
|
||||
/**
|
||||
* Check if there are active subscribers to the named channel. This is helpful if
|
||||
* the message you want to send might be expensive to prepare.
|
||||
*
|
||||
* This API is optional but helpful when trying to publish messages from very
|
||||
* performance-sensitive code.
|
||||
*
|
||||
* ```js
|
||||
* import diagnostics_channel from 'diagnostics_channel';
|
||||
*
|
||||
* if (diagnostics_channel.hasSubscribers('my-channel')) {
|
||||
* // There are subscribers, prepare and publish message
|
||||
* }
|
||||
* ```
|
||||
* @since v15.1.0, v14.17.0
|
||||
* @param name The channel name
|
||||
* @return If there are active subscribers
|
||||
*/
|
||||
function hasSubscribers(name: string): boolean;
|
||||
/**
|
||||
* This is the primary entry-point for anyone wanting to interact with a named
|
||||
* channel. It produces a channel object which is optimized to reduce overhead at
|
||||
* publish time as much as possible.
|
||||
*
|
||||
* ```js
|
||||
* import diagnostics_channel from 'diagnostics_channel';
|
||||
*
|
||||
* const channel = diagnostics_channel.channel('my-channel');
|
||||
* ```
|
||||
* @since v15.1.0, v14.17.0
|
||||
* @param name The channel name
|
||||
* @return The named channel object
|
||||
*/
|
||||
function channel(name: string): Channel;
|
||||
type ChannelListener = (message: unknown, name: string) => void;
|
||||
/**
|
||||
* The class `Channel` represents an individual named channel within the data
|
||||
* pipeline. It is use to track subscribers and to publish messages when there
|
||||
* are subscribers present. It exists as a separate object to avoid channel
|
||||
* lookups at publish time, enabling very fast publish speeds and allowing
|
||||
* for heavy use while incurring very minimal cost. Channels are created with {@link channel}, constructing a channel directly
|
||||
* with `new Channel(name)` is not supported.
|
||||
* @since v15.1.0, v14.17.0
|
||||
*/
|
||||
class Channel {
|
||||
readonly name: string;
|
||||
/**
|
||||
* Check if there are active subscribers to this channel. This is helpful if
|
||||
* the message you want to send might be expensive to prepare.
|
||||
*
|
||||
* This API is optional but helpful when trying to publish messages from very
|
||||
* performance-sensitive code.
|
||||
*
|
||||
* ```js
|
||||
* import diagnostics_channel from 'diagnostics_channel';
|
||||
*
|
||||
* const channel = diagnostics_channel.channel('my-channel');
|
||||
*
|
||||
* if (channel.hasSubscribers) {
|
||||
* // There are subscribers, prepare and publish message
|
||||
* }
|
||||
* ```
|
||||
* @since v15.1.0, v14.17.0
|
||||
*/
|
||||
readonly hasSubscribers: boolean;
|
||||
private constructor(name: string);
|
||||
/**
|
||||
* Publish a message to any subscribers to the channel. This will
|
||||
* trigger message handlers synchronously so they will execute within
|
||||
* the same context.
|
||||
*
|
||||
* ```js
|
||||
* import diagnostics_channel from 'diagnostics_channel';
|
||||
*
|
||||
* const channel = diagnostics_channel.channel('my-channel');
|
||||
*
|
||||
* channel.publish({
|
||||
* some: 'message'
|
||||
* });
|
||||
* ```
|
||||
* @since v15.1.0, v14.17.0
|
||||
* @param message The message to send to the channel subscribers
|
||||
*/
|
||||
publish(message: unknown): void;
|
||||
/**
|
||||
* Register a message handler to subscribe to this channel. This message handler
|
||||
* will be run synchronously whenever a message is published to the channel. Any
|
||||
* errors thrown in the message handler will trigger an `'uncaughtException'`.
|
||||
*
|
||||
* ```js
|
||||
* import diagnostics_channel from 'diagnostics_channel';
|
||||
*
|
||||
* const channel = diagnostics_channel.channel('my-channel');
|
||||
*
|
||||
* channel.subscribe((message, name) => {
|
||||
* // Received data
|
||||
* });
|
||||
* ```
|
||||
* @since v15.1.0, v14.17.0
|
||||
* @param onMessage The handler to receive channel messages
|
||||
*/
|
||||
subscribe(onMessage: ChannelListener): void;
|
||||
/**
|
||||
* Remove a message handler previously registered to this channel with `channel.subscribe(onMessage)`.
|
||||
*
|
||||
* ```js
|
||||
* import diagnostics_channel from 'diagnostics_channel';
|
||||
*
|
||||
* const channel = diagnostics_channel.channel('my-channel');
|
||||
*
|
||||
* function onMessage(message, name) {
|
||||
* // Received data
|
||||
* }
|
||||
*
|
||||
* channel.subscribe(onMessage);
|
||||
*
|
||||
* channel.unsubscribe(onMessage);
|
||||
* ```
|
||||
* @since v15.1.0, v14.17.0
|
||||
* @param onMessage The previous subscribed handler to remove
|
||||
* @return `true` if the handler was found, `false` otherwise.
|
||||
*/
|
||||
unsubscribe(onMessage: ChannelListener): void;
|
||||
}
|
||||
}
|
||||
declare module 'node:diagnostics_channel' {
|
||||
export * from 'diagnostics_channel';
|
||||
}
|
370
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/dns/promises.d.ts
generated
vendored
370
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/dns/promises.d.ts
generated
vendored
@ -0,0 +1,170 @@
|
||||
/**
|
||||
* **This module is pending deprecation.** Once a replacement API has been
|
||||
* finalized, this module will be fully deprecated. Most developers should
|
||||
* **not** have cause to use this module. Users who absolutely must have
|
||||
* the functionality that domains provide may rely on it for the time being
|
||||
* but should expect to have to migrate to a different solution
|
||||
* in the future.
|
||||
*
|
||||
* Domains provide a way to handle multiple different IO operations as a
|
||||
* single group. If any of the event emitters or callbacks registered to a
|
||||
* domain emit an `'error'` event, or throw an error, then the domain object
|
||||
* will be notified, rather than losing the context of the error in the`process.on('uncaughtException')` handler, or causing the program to
|
||||
* exit immediately with an error code.
|
||||
* @deprecated Since v1.4.2 - Deprecated
|
||||
* @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/domain.js)
|
||||
*/
|
||||
declare module 'domain' {
|
||||
import EventEmitter = require('node:events');
|
||||
/**
|
||||
* The `Domain` class encapsulates the functionality of routing errors and
|
||||
* uncaught exceptions to the active `Domain` object.
|
||||
*
|
||||
* To handle the errors that it catches, listen to its `'error'` event.
|
||||
*/
|
||||
class Domain extends EventEmitter {
|
||||
/**
|
||||
* An array of timers and event emitters that have been explicitly added
|
||||
* to the domain.
|
||||
*/
|
||||
members: Array<EventEmitter | NodeJS.Timer>;
|
||||
/**
|
||||
* The `enter()` method is plumbing used by the `run()`, `bind()`, and`intercept()` methods to set the active domain. It sets `domain.active` and`process.domain` to the domain, and implicitly
|
||||
* pushes the domain onto the domain
|
||||
* stack managed by the domain module (see {@link exit} for details on the
|
||||
* domain stack). The call to `enter()` delimits the beginning of a chain of
|
||||
* asynchronous calls and I/O operations bound to a domain.
|
||||
*
|
||||
* Calling `enter()` changes only the active domain, and does not alter the domain
|
||||
* itself. `enter()` and `exit()` can be called an arbitrary number of times on a
|
||||
* single domain.
|
||||
*/
|
||||
enter(): void;
|
||||
/**
|
||||
* The `exit()` method exits the current domain, popping it off the domain stack.
|
||||
* Any time execution is going to switch to the context of a different chain of
|
||||
* asynchronous calls, it's important to ensure that the current domain is exited.
|
||||
* The call to `exit()` delimits either the end of or an interruption to the chain
|
||||
* of asynchronous calls and I/O operations bound to a domain.
|
||||
*
|
||||
* If there are multiple, nested domains bound to the current execution context,`exit()` will exit any domains nested within this domain.
|
||||
*
|
||||
* Calling `exit()` changes only the active domain, and does not alter the domain
|
||||
* itself. `enter()` and `exit()` can be called an arbitrary number of times on a
|
||||
* single domain.
|
||||
*/
|
||||
exit(): void;
|
||||
/**
|
||||
* Run the supplied function in the context of the domain, implicitly
|
||||
* binding all event emitters, timers, and lowlevel requests that are
|
||||
* created in that context. Optionally, arguments can be passed to
|
||||
* the function.
|
||||
*
|
||||
* This is the most basic way to use a domain.
|
||||
*
|
||||
* ```js
|
||||
* const domain = require('domain');
|
||||
* const fs = require('fs');
|
||||
* const d = domain.create();
|
||||
* d.on('error', (er) => {
|
||||
* console.error('Caught error!', er);
|
||||
* });
|
||||
* d.run(() => {
|
||||
* process.nextTick(() => {
|
||||
* setTimeout(() => { // Simulating some various async stuff
|
||||
* fs.open('non-existent file', 'r', (er, fd) => {
|
||||
* if (er) throw er;
|
||||
* // proceed...
|
||||
* });
|
||||
* }, 100);
|
||||
* });
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* In this example, the `d.on('error')` handler will be triggered, rather
|
||||
* than crashing the program.
|
||||
*/
|
||||
run<T>(fn: (...args: any[]) => T, ...args: any[]): T;
|
||||
/**
|
||||
* Explicitly adds an emitter to the domain. If any event handlers called by
|
||||
* the emitter throw an error, or if the emitter emits an `'error'` event, it
|
||||
* will be routed to the domain's `'error'` event, just like with implicit
|
||||
* binding.
|
||||
*
|
||||
* This also works with timers that are returned from `setInterval()` and `setTimeout()`. If their callback function throws, it will be caught by
|
||||
* the domain `'error'` handler.
|
||||
*
|
||||
* If the Timer or `EventEmitter` was already bound to a domain, it is removed
|
||||
* from that one, and bound to this one instead.
|
||||
* @param emitter emitter or timer to be added to the domain
|
||||
*/
|
||||
add(emitter: EventEmitter | NodeJS.Timer): void;
|
||||
/**
|
||||
* The opposite of {@link add}. Removes domain handling from the
|
||||
* specified emitter.
|
||||
* @param emitter emitter or timer to be removed from the domain
|
||||
*/
|
||||
remove(emitter: EventEmitter | NodeJS.Timer): void;
|
||||
/**
|
||||
* The returned function will be a wrapper around the supplied callback
|
||||
* function. When the returned function is called, any errors that are
|
||||
* thrown will be routed to the domain's `'error'` event.
|
||||
*
|
||||
* ```js
|
||||
* const d = domain.create();
|
||||
*
|
||||
* function readSomeFile(filename, cb) {
|
||||
* fs.readFile(filename, 'utf8', d.bind((er, data) => {
|
||||
* // If this throws, it will also be passed to the domain.
|
||||
* return cb(er, data ? JSON.parse(data) : null);
|
||||
* }));
|
||||
* }
|
||||
*
|
||||
* d.on('error', (er) => {
|
||||
* // An error occurred somewhere. If we throw it now, it will crash the program
|
||||
* // with the normal line number and stack message.
|
||||
* });
|
||||
* ```
|
||||
* @param callback The callback function
|
||||
* @return The bound function
|
||||
*/
|
||||
bind<T extends Function>(callback: T): T;
|
||||
/**
|
||||
* This method is almost identical to {@link bind}. However, in
|
||||
* addition to catching thrown errors, it will also intercept `Error` objects sent as the first argument to the function.
|
||||
*
|
||||
* In this way, the common `if (err) return callback(err);` pattern can be replaced
|
||||
* with a single error handler in a single place.
|
||||
*
|
||||
* ```js
|
||||
* const d = domain.create();
|
||||
*
|
||||
* function readSomeFile(filename, cb) {
|
||||
* fs.readFile(filename, 'utf8', d.intercept((data) => {
|
||||
* // Note, the first argument is never passed to the
|
||||
* // callback since it is assumed to be the 'Error' argument
|
||||
* // and thus intercepted by the domain.
|
||||
*
|
||||
* // If this throws, it will also be passed to the domain
|
||||
* // so the error-handling logic can be moved to the 'error'
|
||||
* // event on the domain instead of being repeated throughout
|
||||
* // the program.
|
||||
* return cb(null, JSON.parse(data));
|
||||
* }));
|
||||
* }
|
||||
*
|
||||
* d.on('error', (er) => {
|
||||
* // An error occurred somewhere. If we throw it now, it will crash the program
|
||||
* // with the normal line number and stack message.
|
||||
* });
|
||||
* ```
|
||||
* @param callback The callback function
|
||||
* @return The intercepted function
|
||||
*/
|
||||
intercept<T extends Function>(callback: T): T;
|
||||
}
|
||||
function create(): Domain;
|
||||
}
|
||||
declare module 'node:domain' {
|
||||
export * from 'domain';
|
||||
}
|
@ -0,0 +1,641 @@
|
||||
/**
|
||||
* Much of the Node.js core API is built around an idiomatic asynchronous
|
||||
* event-driven architecture in which certain kinds of objects (called "emitters")
|
||||
* emit named events that cause `Function` objects ("listeners") to be called.
|
||||
*
|
||||
* For instance: a `net.Server` object emits an event each time a peer
|
||||
* connects to it; a `fs.ReadStream` emits an event when the file is opened;
|
||||
* a `stream` emits an event whenever data is available to be read.
|
||||
*
|
||||
* All objects that emit events are instances of the `EventEmitter` class. These
|
||||
* objects expose an `eventEmitter.on()` function that allows one or more
|
||||
* functions to be attached to named events emitted by the object. Typically,
|
||||
* event names are camel-cased strings but any valid JavaScript property key
|
||||
* can be used.
|
||||
*
|
||||
* When the `EventEmitter` object emits an event, all of the functions attached
|
||||
* to that specific event are called _synchronously_. Any values returned by the
|
||||
* called listeners are _ignored_ and discarded.
|
||||
*
|
||||
* The following example shows a simple `EventEmitter` instance with a single
|
||||
* listener. The `eventEmitter.on()` method is used to register listeners, while
|
||||
* the `eventEmitter.emit()` method is used to trigger the event.
|
||||
*
|
||||
* ```js
|
||||
* const EventEmitter = require('events');
|
||||
*
|
||||
* class MyEmitter extends EventEmitter {}
|
||||
*
|
||||
* const myEmitter = new MyEmitter();
|
||||
* myEmitter.on('event', () => {
|
||||
* console.log('an event occurred!');
|
||||
* });
|
||||
* myEmitter.emit('event');
|
||||
* ```
|
||||
* @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/events.js)
|
||||
*/
|
||||
declare module 'events' {
|
||||
interface EventEmitterOptions {
|
||||
/**
|
||||
* Enables automatic capturing of promise rejection.
|
||||
*/
|
||||
captureRejections?: boolean | undefined;
|
||||
}
|
||||
interface NodeEventTarget {
|
||||
once(eventName: string | symbol, listener: (...args: any[]) => void): this;
|
||||
}
|
||||
interface DOMEventTarget {
|
||||
addEventListener(
|
||||
eventName: string,
|
||||
listener: (...args: any[]) => void,
|
||||
opts?: {
|
||||
once: boolean;
|
||||
}
|
||||
): any;
|
||||
}
|
||||
interface StaticEventEmitterOptions {
|
||||
signal?: AbortSignal | undefined;
|
||||
}
|
||||
interface EventEmitter extends NodeJS.EventEmitter {}
|
||||
/**
|
||||
* The `EventEmitter` class is defined and exposed by the `events` module:
|
||||
*
|
||||
* ```js
|
||||
* const EventEmitter = require('events');
|
||||
* ```
|
||||
*
|
||||
* All `EventEmitter`s emit the event `'newListener'` when new listeners are
|
||||
* added and `'removeListener'` when existing listeners are removed.
|
||||
*
|
||||
* It supports the following option:
|
||||
* @since v0.1.26
|
||||
*/
|
||||
class EventEmitter {
|
||||
constructor(options?: EventEmitterOptions);
|
||||
/**
|
||||
* Creates a `Promise` that is fulfilled when the `EventEmitter` emits the given
|
||||
* event or that is rejected if the `EventEmitter` emits `'error'` while waiting.
|
||||
* The `Promise` will resolve with an array of all the arguments emitted to the
|
||||
* given event.
|
||||
*
|
||||
* This method is intentionally generic and works with the web platform [EventTarget](https://dom.spec.whatwg.org/#interface-eventtarget) interface, which has no special`'error'` event
|
||||
* semantics and does not listen to the `'error'` event.
|
||||
*
|
||||
* ```js
|
||||
* const { once, EventEmitter } = require('events');
|
||||
*
|
||||
* async function run() {
|
||||
* const ee = new EventEmitter();
|
||||
*
|
||||
* process.nextTick(() => {
|
||||
* ee.emit('myevent', 42);
|
||||
* });
|
||||
*
|
||||
* const [value] = await once(ee, 'myevent');
|
||||
* console.log(value);
|
||||
*
|
||||
* const err = new Error('kaboom');
|
||||
* process.nextTick(() => {
|
||||
* ee.emit('error', err);
|
||||
* });
|
||||
*
|
||||
* try {
|
||||
* await once(ee, 'myevent');
|
||||
* } catch (err) {
|
||||
* console.log('error happened', err);
|
||||
* }
|
||||
* }
|
||||
*
|
||||
* run();
|
||||
* ```
|
||||
*
|
||||
* The special handling of the `'error'` event is only used when `events.once()`is used to wait for another event. If `events.once()` is used to wait for the
|
||||
* '`error'` event itself, then it is treated as any other kind of event without
|
||||
* special handling:
|
||||
*
|
||||
* ```js
|
||||
* const { EventEmitter, once } = require('events');
|
||||
*
|
||||
* const ee = new EventEmitter();
|
||||
*
|
||||
* once(ee, 'error')
|
||||
* .then(([err]) => console.log('ok', err.message))
|
||||
* .catch((err) => console.log('error', err.message));
|
||||
*
|
||||
* ee.emit('error', new Error('boom'));
|
||||
*
|
||||
* // Prints: ok boom
|
||||
* ```
|
||||
*
|
||||
* An `AbortSignal` can be used to cancel waiting for the event:
|
||||
*
|
||||
* ```js
|
||||
* const { EventEmitter, once } = require('events');
|
||||
*
|
||||
* const ee = new EventEmitter();
|
||||
* const ac = new AbortController();
|
||||
*
|
||||
* async function foo(emitter, event, signal) {
|
||||
* try {
|
||||
* await once(emitter, event, { signal });
|
||||
* console.log('event emitted!');
|
||||
* } catch (error) {
|
||||
* if (error.name === 'AbortError') {
|
||||
* console.error('Waiting for the event was canceled!');
|
||||
* } else {
|
||||
* console.error('There was an error', error.message);
|
||||
* }
|
||||
* }
|
||||
* }
|
||||
*
|
||||
* foo(ee, 'foo', ac.signal);
|
||||
* ac.abort(); // Abort waiting for the event
|
||||
* ee.emit('foo'); // Prints: Waiting for the event was canceled!
|
||||
* ```
|
||||
* @since v11.13.0, v10.16.0
|
||||
*/
|
||||
static once(emitter: NodeEventTarget, eventName: string | symbol, options?: StaticEventEmitterOptions): Promise<any[]>;
|
||||
static once(emitter: DOMEventTarget, eventName: string, options?: StaticEventEmitterOptions): Promise<any[]>;
|
||||
/**
|
||||
* ```js
|
||||
* const { on, EventEmitter } = require('events');
|
||||
*
|
||||
* (async () => {
|
||||
* const ee = new EventEmitter();
|
||||
*
|
||||
* // Emit later on
|
||||
* process.nextTick(() => {
|
||||
* ee.emit('foo', 'bar');
|
||||
* ee.emit('foo', 42);
|
||||
* });
|
||||
*
|
||||
* for await (const event of on(ee, 'foo')) {
|
||||
* // The execution of this inner block is synchronous and it
|
||||
* // processes one event at a time (even with await). Do not use
|
||||
* // if concurrent execution is required.
|
||||
* console.log(event); // prints ['bar'] [42]
|
||||
* }
|
||||
* // Unreachable here
|
||||
* })();
|
||||
* ```
|
||||
*
|
||||
* Returns an `AsyncIterator` that iterates `eventName` events. It will throw
|
||||
* if the `EventEmitter` emits `'error'`. It removes all listeners when
|
||||
* exiting the loop. The `value` returned by each iteration is an array
|
||||
* composed of the emitted event arguments.
|
||||
*
|
||||
* An `AbortSignal` can be used to cancel waiting on events:
|
||||
*
|
||||
* ```js
|
||||
* const { on, EventEmitter } = require('events');
|
||||
* const ac = new AbortController();
|
||||
*
|
||||
* (async () => {
|
||||
* const ee = new EventEmitter();
|
||||
*
|
||||
* // Emit later on
|
||||
* process.nextTick(() => {
|
||||
* ee.emit('foo', 'bar');
|
||||
* ee.emit('foo', 42);
|
||||
* });
|
||||
*
|
||||
* for await (const event of on(ee, 'foo', { signal: ac.signal })) {
|
||||
* // The execution of this inner block is synchronous and it
|
||||
* // processes one event at a time (even with await). Do not use
|
||||
* // if concurrent execution is required.
|
||||
* console.log(event); // prints ['bar'] [42]
|
||||
* }
|
||||
* // Unreachable here
|
||||
* })();
|
||||
*
|
||||
* process.nextTick(() => ac.abort());
|
||||
* ```
|
||||
* @since v13.6.0, v12.16.0
|
||||
* @param eventName The name of the event being listened for
|
||||
* @return that iterates `eventName` events emitted by the `emitter`
|
||||
*/
|
||||
static on(emitter: NodeJS.EventEmitter, eventName: string, options?: StaticEventEmitterOptions): AsyncIterableIterator<any>;
|
||||
/**
|
||||
* A class method that returns the number of listeners for the given `eventName`registered on the given `emitter`.
|
||||
*
|
||||
* ```js
|
||||
* const { EventEmitter, listenerCount } = require('events');
|
||||
* const myEmitter = new EventEmitter();
|
||||
* myEmitter.on('event', () => {});
|
||||
* myEmitter.on('event', () => {});
|
||||
* console.log(listenerCount(myEmitter, 'event'));
|
||||
* // Prints: 2
|
||||
* ```
|
||||
* @since v0.9.12
|
||||
* @deprecated Since v3.2.0 - Use `listenerCount` instead.
|
||||
* @param emitter The emitter to query
|
||||
* @param eventName The event name
|
||||
*/
|
||||
static listenerCount(emitter: NodeJS.EventEmitter, eventName: string | symbol): number;
|
||||
/**
|
||||
* Returns a copy of the array of listeners for the event named `eventName`.
|
||||
*
|
||||
* For `EventEmitter`s this behaves exactly the same as calling `.listeners` on
|
||||
* the emitter.
|
||||
*
|
||||
* For `EventTarget`s this is the only way to get the event listeners for the
|
||||
* event target. This is useful for debugging and diagnostic purposes.
|
||||
*
|
||||
* ```js
|
||||
* const { getEventListeners, EventEmitter } = require('events');
|
||||
*
|
||||
* {
|
||||
* const ee = new EventEmitter();
|
||||
* const listener = () => console.log('Events are fun');
|
||||
* ee.on('foo', listener);
|
||||
* getEventListeners(ee, 'foo'); // [listener]
|
||||
* }
|
||||
* {
|
||||
* const et = new EventTarget();
|
||||
* const listener = () => console.log('Events are fun');
|
||||
* et.addEventListener('foo', listener);
|
||||
* getEventListeners(et, 'foo'); // [listener]
|
||||
* }
|
||||
* ```
|
||||
* @since v15.2.0, v14.17.0
|
||||
*/
|
||||
static getEventListeners(emitter: DOMEventTarget | NodeJS.EventEmitter, name: string | symbol): Function[];
|
||||
/**
|
||||
* ```js
|
||||
* const {
|
||||
* setMaxListeners,
|
||||
* EventEmitter
|
||||
* } = require('events');
|
||||
*
|
||||
* const target = new EventTarget();
|
||||
* const emitter = new EventEmitter();
|
||||
*
|
||||
* setMaxListeners(5, target, emitter);
|
||||
* ```
|
||||
* @since v15.4.0
|
||||
* @param n A non-negative number. The maximum number of listeners per `EventTarget` event.
|
||||
* @param eventsTargets Zero or more {EventTarget} or {EventEmitter} instances. If none are specified, `n` is set as the default max for all newly created {EventTarget} and {EventEmitter}
|
||||
* objects.
|
||||
*/
|
||||
static setMaxListeners(n?: number, ...eventTargets: Array<DOMEventTarget | NodeJS.EventEmitter>): void;
|
||||
/**
|
||||
* This symbol shall be used to install a listener for only monitoring `'error'`
|
||||
* events. Listeners installed using this symbol are called before the regular
|
||||
* `'error'` listeners are called.
|
||||
*
|
||||
* Installing a listener using this symbol does not change the behavior once an
|
||||
* `'error'` event is emitted, therefore the process will still crash if no
|
||||
* regular `'error'` listener is installed.
|
||||
*/
|
||||
static readonly errorMonitor: unique symbol;
|
||||
static readonly captureRejectionSymbol: unique symbol;
|
||||
/**
|
||||
* Sets or gets the default captureRejection value for all emitters.
|
||||
*/
|
||||
// TODO: These should be described using static getter/setter pairs:
|
||||
static captureRejections: boolean;
|
||||
static defaultMaxListeners: number;
|
||||
}
|
||||
import internal = require('node:events');
|
||||
namespace EventEmitter {
|
||||
// Should just be `export { EventEmitter }`, but that doesn't work in TypeScript 3.4
|
||||
export { internal as EventEmitter };
|
||||
export interface Abortable {
|
||||
/**
|
||||
* When provided the corresponding `AbortController` can be used to cancel an asynchronous action.
|
||||
*/
|
||||
signal?: AbortSignal | undefined;
|
||||
}
|
||||
}
|
||||
global {
|
||||
namespace NodeJS {
|
||||
interface EventEmitter {
|
||||
/**
|
||||
* Alias for `emitter.on(eventName, listener)`.
|
||||
* @since v0.1.26
|
||||
*/
|
||||
addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
|
||||
/**
|
||||
* Adds the `listener` function to the end of the listeners array for the
|
||||
* event named `eventName`. No checks are made to see if the `listener` has
|
||||
* already been added. Multiple calls passing the same combination of `eventName`and `listener` will result in the `listener` being added, and called, multiple
|
||||
* times.
|
||||
*
|
||||
* ```js
|
||||
* server.on('connection', (stream) => {
|
||||
* console.log('someone connected!');
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* Returns a reference to the `EventEmitter`, so that calls can be chained.
|
||||
*
|
||||
* By default, event listeners are invoked in the order they are added. The`emitter.prependListener()` method can be used as an alternative to add the
|
||||
* event listener to the beginning of the listeners array.
|
||||
*
|
||||
* ```js
|
||||
* const myEE = new EventEmitter();
|
||||
* myEE.on('foo', () => console.log('a'));
|
||||
* myEE.prependListener('foo', () => console.log('b'));
|
||||
* myEE.emit('foo');
|
||||
* // Prints:
|
||||
* // b
|
||||
* // a
|
||||
* ```
|
||||
* @since v0.1.101
|
||||
* @param eventName The name of the event.
|
||||
* @param listener The callback function
|
||||
*/
|
||||
on(eventName: string | symbol, listener: (...args: any[]) => void): this;
|
||||
/**
|
||||
* Adds a **one-time**`listener` function for the event named `eventName`. The
|
||||
* next time `eventName` is triggered, this listener is removed and then invoked.
|
||||
*
|
||||
* ```js
|
||||
* server.once('connection', (stream) => {
|
||||
* console.log('Ah, we have our first user!');
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* Returns a reference to the `EventEmitter`, so that calls can be chained.
|
||||
*
|
||||
* By default, event listeners are invoked in the order they are added. The`emitter.prependOnceListener()` method can be used as an alternative to add the
|
||||
* event listener to the beginning of the listeners array.
|
||||
*
|
||||
* ```js
|
||||
* const myEE = new EventEmitter();
|
||||
* myEE.once('foo', () => console.log('a'));
|
||||
* myEE.prependOnceListener('foo', () => console.log('b'));
|
||||
* myEE.emit('foo');
|
||||
* // Prints:
|
||||
* // b
|
||||
* // a
|
||||
* ```
|
||||
* @since v0.3.0
|
||||
* @param eventName The name of the event.
|
||||
* @param listener The callback function
|
||||
*/
|
||||
once(eventName: string | symbol, listener: (...args: any[]) => void): this;
|
||||
/**
|
||||
* Removes the specified `listener` from the listener array for the event named`eventName`.
|
||||
*
|
||||
* ```js
|
||||
* const callback = (stream) => {
|
||||
* console.log('someone connected!');
|
||||
* };
|
||||
* server.on('connection', callback);
|
||||
* // ...
|
||||
* server.removeListener('connection', callback);
|
||||
* ```
|
||||
*
|
||||
* `removeListener()` will remove, at most, one instance of a listener from the
|
||||
* listener array. If any single listener has been added multiple times to the
|
||||
* listener array for the specified `eventName`, then `removeListener()` must be
|
||||
* called multiple times to remove each instance.
|
||||
*
|
||||
* Once an event is emitted, all listeners attached to it at the
|
||||
* time of emitting are called in order. This implies that any`removeListener()` or `removeAllListeners()` calls _after_ emitting and _before_ the last listener finishes execution
|
||||
* will not remove them from`emit()` in progress. Subsequent events behave as expected.
|
||||
*
|
||||
* ```js
|
||||
* const myEmitter = new MyEmitter();
|
||||
*
|
||||
* const callbackA = () => {
|
||||
* console.log('A');
|
||||
* myEmitter.removeListener('event', callbackB);
|
||||
* };
|
||||
*
|
||||
* const callbackB = () => {
|
||||
* console.log('B');
|
||||
* };
|
||||
*
|
||||
* myEmitter.on('event', callbackA);
|
||||
*
|
||||
* myEmitter.on('event', callbackB);
|
||||
*
|
||||
* // callbackA removes listener callbackB but it will still be called.
|
||||
* // Internal listener array at time of emit [callbackA, callbackB]
|
||||
* myEmitter.emit('event');
|
||||
* // Prints:
|
||||
* // A
|
||||
* // B
|
||||
*
|
||||
* // callbackB is now removed.
|
||||
* // Internal listener array [callbackA]
|
||||
* myEmitter.emit('event');
|
||||
* // Prints:
|
||||
* // A
|
||||
* ```
|
||||
*
|
||||
* Because listeners are managed using an internal array, calling this will
|
||||
* change the position indices of any listener registered _after_ the listener
|
||||
* being removed. This will not impact the order in which listeners are called,
|
||||
* but it means that any copies of the listener array as returned by
|
||||
* the `emitter.listeners()` method will need to be recreated.
|
||||
*
|
||||
* When a single function has been added as a handler multiple times for a single
|
||||
* event (as in the example below), `removeListener()` will remove the most
|
||||
* recently added instance. In the example the `once('ping')`listener is removed:
|
||||
*
|
||||
* ```js
|
||||
* const ee = new EventEmitter();
|
||||
*
|
||||
* function pong() {
|
||||
* console.log('pong');
|
||||
* }
|
||||
*
|
||||
* ee.on('ping', pong);
|
||||
* ee.once('ping', pong);
|
||||
* ee.removeListener('ping', pong);
|
||||
*
|
||||
* ee.emit('ping');
|
||||
* ee.emit('ping');
|
||||
* ```
|
||||
*
|
||||
* Returns a reference to the `EventEmitter`, so that calls can be chained.
|
||||
* @since v0.1.26
|
||||
*/
|
||||
removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
|
||||
/**
|
||||
* Alias for `emitter.removeListener()`.
|
||||
* @since v10.0.0
|
||||
*/
|
||||
off(eventName: string | symbol, listener: (...args: any[]) => void): this;
|
||||
/**
|
||||
* Removes all listeners, or those of the specified `eventName`.
|
||||
*
|
||||
* It is bad practice to remove listeners added elsewhere in the code,
|
||||
* particularly when the `EventEmitter` instance was created by some other
|
||||
* component or module (e.g. sockets or file streams).
|
||||
*
|
||||
* Returns a reference to the `EventEmitter`, so that calls can be chained.
|
||||
* @since v0.1.26
|
||||
*/
|
||||
removeAllListeners(event?: string | symbol): this;
|
||||
/**
|
||||
* By default `EventEmitter`s will print a warning if more than `10` listeners are
|
||||
* added for a particular event. This is a useful default that helps finding
|
||||
* memory leaks. The `emitter.setMaxListeners()` method allows the limit to be
|
||||
* modified for this specific `EventEmitter` instance. The value can be set to`Infinity` (or `0`) to indicate an unlimited number of listeners.
|
||||
*
|
||||
* Returns a reference to the `EventEmitter`, so that calls can be chained.
|
||||
* @since v0.3.5
|
||||
*/
|
||||
setMaxListeners(n: number): this;
|
||||
/**
|
||||
* Returns the current max listener value for the `EventEmitter` which is either
|
||||
* set by `emitter.setMaxListeners(n)` or defaults to {@link defaultMaxListeners}.
|
||||
* @since v1.0.0
|
||||
*/
|
||||
getMaxListeners(): number;
|
||||
/**
|
||||
* Returns a copy of the array of listeners for the event named `eventName`.
|
||||
*
|
||||
* ```js
|
||||
* server.on('connection', (stream) => {
|
||||
* console.log('someone connected!');
|
||||
* });
|
||||
* console.log(util.inspect(server.listeners('connection')));
|
||||
* // Prints: [ [Function] ]
|
||||
* ```
|
||||
* @since v0.1.26
|
||||
*/
|
||||
listeners(eventName: string | symbol): Function[];
|
||||
/**
|
||||
* Returns a copy of the array of listeners for the event named `eventName`,
|
||||
* including any wrappers (such as those created by `.once()`).
|
||||
*
|
||||
* ```js
|
||||
* const emitter = new EventEmitter();
|
||||
* emitter.once('log', () => console.log('log once'));
|
||||
*
|
||||
* // Returns a new Array with a function `onceWrapper` which has a property
|
||||
* // `listener` which contains the original listener bound above
|
||||
* const listeners = emitter.rawListeners('log');
|
||||
* const logFnWrapper = listeners[0];
|
||||
*
|
||||
* // Logs "log once" to the console and does not unbind the `once` event
|
||||
* logFnWrapper.listener();
|
||||
*
|
||||
* // Logs "log once" to the console and removes the listener
|
||||
* logFnWrapper();
|
||||
*
|
||||
* emitter.on('log', () => console.log('log persistently'));
|
||||
* // Will return a new Array with a single function bound by `.on()` above
|
||||
* const newListeners = emitter.rawListeners('log');
|
||||
*
|
||||
* // Logs "log persistently" twice
|
||||
* newListeners[0]();
|
||||
* emitter.emit('log');
|
||||
* ```
|
||||
* @since v9.4.0
|
||||
*/
|
||||
rawListeners(eventName: string | symbol): Function[];
|
||||
/**
|
||||
* Synchronously calls each of the listeners registered for the event named`eventName`, in the order they were registered, passing the supplied arguments
|
||||
* to each.
|
||||
*
|
||||
* Returns `true` if the event had listeners, `false` otherwise.
|
||||
*
|
||||
* ```js
|
||||
* const EventEmitter = require('events');
|
||||
* const myEmitter = new EventEmitter();
|
||||
*
|
||||
* // First listener
|
||||
* myEmitter.on('event', function firstListener() {
|
||||
* console.log('Helloooo! first listener');
|
||||
* });
|
||||
* // Second listener
|
||||
* myEmitter.on('event', function secondListener(arg1, arg2) {
|
||||
* console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
|
||||
* });
|
||||
* // Third listener
|
||||
* myEmitter.on('event', function thirdListener(...args) {
|
||||
* const parameters = args.join(', ');
|
||||
* console.log(`event with parameters ${parameters} in third listener`);
|
||||
* });
|
||||
*
|
||||
* console.log(myEmitter.listeners('event'));
|
||||
*
|
||||
* myEmitter.emit('event', 1, 2, 3, 4, 5);
|
||||
*
|
||||
* // Prints:
|
||||
* // [
|
||||
* // [Function: firstListener],
|
||||
* // [Function: secondListener],
|
||||
* // [Function: thirdListener]
|
||||
* // ]
|
||||
* // Helloooo! first listener
|
||||
* // event with parameters 1, 2 in second listener
|
||||
* // event with parameters 1, 2, 3, 4, 5 in third listener
|
||||
* ```
|
||||
* @since v0.1.26
|
||||
*/
|
||||
emit(eventName: string | symbol, ...args: any[]): boolean;
|
||||
/**
|
||||
* Returns the number of listeners listening to the event named `eventName`.
|
||||
* @since v3.2.0
|
||||
* @param eventName The name of the event being listened for
|
||||
*/
|
||||
listenerCount(eventName: string | symbol): number;
|
||||
/**
|
||||
* Adds the `listener` function to the _beginning_ of the listeners array for the
|
||||
* event named `eventName`. No checks are made to see if the `listener` has
|
||||
* already been added. Multiple calls passing the same combination of `eventName`and `listener` will result in the `listener` being added, and called, multiple
|
||||
* times.
|
||||
*
|
||||
* ```js
|
||||
* server.prependListener('connection', (stream) => {
|
||||
* console.log('someone connected!');
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* Returns a reference to the `EventEmitter`, so that calls can be chained.
|
||||
* @since v6.0.0
|
||||
* @param eventName The name of the event.
|
||||
* @param listener The callback function
|
||||
*/
|
||||
prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
|
||||
/**
|
||||
* Adds a **one-time**`listener` function for the event named `eventName` to the _beginning_ of the listeners array. The next time `eventName` is triggered, this
|
||||
* listener is removed, and then invoked.
|
||||
*
|
||||
* ```js
|
||||
* server.prependOnceListener('connection', (stream) => {
|
||||
* console.log('Ah, we have our first user!');
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* Returns a reference to the `EventEmitter`, so that calls can be chained.
|
||||
* @since v6.0.0
|
||||
* @param eventName The name of the event.
|
||||
* @param listener The callback function
|
||||
*/
|
||||
prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
|
||||
/**
|
||||
* Returns an array listing the events for which the emitter has registered
|
||||
* listeners. The values in the array are strings or `Symbol`s.
|
||||
*
|
||||
* ```js
|
||||
* const EventEmitter = require('events');
|
||||
* const myEE = new EventEmitter();
|
||||
* myEE.on('foo', () => {});
|
||||
* myEE.on('bar', () => {});
|
||||
*
|
||||
* const sym = Symbol('symbol');
|
||||
* myEE.on(sym, () => {});
|
||||
*
|
||||
* console.log(myEE.eventNames());
|
||||
* // Prints: [ 'foo', 'bar', Symbol(symbol) ]
|
||||
* ```
|
||||
* @since v6.0.0
|
||||
*/
|
||||
eventNames(): Array<string | symbol>;
|
||||
}
|
||||
}
|
||||
}
|
||||
export = EventEmitter;
|
||||
}
|
||||
declare module 'node:events' {
|
||||
import events = require('events');
|
||||
export = events;
|
||||
}
|
File diff suppressed because it is too large
Load Diff
1120
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/fs/promises.d.ts
generated
vendored
1120
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/fs/promises.d.ts
generated
vendored
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,294 @@
|
||||
// Declare "static" methods in Error
|
||||
interface ErrorConstructor {
|
||||
/** Create .stack property on a target object */
|
||||
captureStackTrace(targetObject: object, constructorOpt?: Function): void;
|
||||
|
||||
/**
|
||||
* Optional override for formatting stack traces
|
||||
*
|
||||
* @see https://v8.dev/docs/stack-trace-api#customizing-stack-traces
|
||||
*/
|
||||
prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
|
||||
|
||||
stackTraceLimit: number;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------*
|
||||
* *
|
||||
* GLOBAL *
|
||||
* *
|
||||
------------------------------------------------*/
|
||||
|
||||
// For backwards compability
|
||||
interface NodeRequire extends NodeJS.Require { }
|
||||
interface RequireResolve extends NodeJS.RequireResolve { }
|
||||
interface NodeModule extends NodeJS.Module { }
|
||||
|
||||
declare var process: NodeJS.Process;
|
||||
declare var console: Console;
|
||||
|
||||
declare var __filename: string;
|
||||
declare var __dirname: string;
|
||||
|
||||
declare var require: NodeRequire;
|
||||
declare var module: NodeModule;
|
||||
|
||||
// Same as module.exports
|
||||
declare var exports: any;
|
||||
|
||||
/**
|
||||
* Only available if `--expose-gc` is passed to the process.
|
||||
*/
|
||||
declare var gc: undefined | (() => void);
|
||||
|
||||
//#region borrowed
|
||||
// from https://github.com/microsoft/TypeScript/blob/38da7c600c83e7b31193a62495239a0fe478cb67/lib/lib.webworker.d.ts#L633 until moved to separate lib
|
||||
/** A controller object that allows you to abort one or more DOM requests as and when desired. */
|
||||
interface AbortController {
|
||||
/**
|
||||
* Returns the AbortSignal object associated with this object.
|
||||
*/
|
||||
|
||||
readonly signal: AbortSignal;
|
||||
/**
|
||||
* Invoking this method will set this object's AbortSignal's aborted flag and signal to any observers that the associated activity is to be aborted.
|
||||
*/
|
||||
abort(): void;
|
||||
}
|
||||
|
||||
/** A signal object that allows you to communicate with a DOM request (such as a Fetch) and abort it if required via an AbortController object. */
|
||||
interface AbortSignal {
|
||||
/**
|
||||
* Returns true if this AbortSignal's AbortController has signaled to abort, and false otherwise.
|
||||
*/
|
||||
readonly aborted: boolean;
|
||||
}
|
||||
|
||||
declare var AbortController: {
|
||||
prototype: AbortController;
|
||||
new(): AbortController;
|
||||
};
|
||||
|
||||
declare var AbortSignal: {
|
||||
prototype: AbortSignal;
|
||||
new(): AbortSignal;
|
||||
// TODO: Add abort() static
|
||||
};
|
||||
//#endregion borrowed
|
||||
|
||||
//#region ArrayLike.at()
|
||||
interface RelativeIndexable<T> {
|
||||
/**
|
||||
* Takes an integer value and returns the item at that index,
|
||||
* allowing for positive and negative integers.
|
||||
* Negative integers count back from the last item in the array.
|
||||
*/
|
||||
at(index: number): T | undefined;
|
||||
}
|
||||
interface String extends RelativeIndexable<string> {}
|
||||
interface Array<T> extends RelativeIndexable<T> {}
|
||||
interface Int8Array extends RelativeIndexable<number> {}
|
||||
interface Uint8Array extends RelativeIndexable<number> {}
|
||||
interface Uint8ClampedArray extends RelativeIndexable<number> {}
|
||||
interface Int16Array extends RelativeIndexable<number> {}
|
||||
interface Uint16Array extends RelativeIndexable<number> {}
|
||||
interface Int32Array extends RelativeIndexable<number> {}
|
||||
interface Uint32Array extends RelativeIndexable<number> {}
|
||||
interface Float32Array extends RelativeIndexable<number> {}
|
||||
interface Float64Array extends RelativeIndexable<number> {}
|
||||
interface BigInt64Array extends RelativeIndexable<bigint> {}
|
||||
interface BigUint64Array extends RelativeIndexable<bigint> {}
|
||||
//#endregion ArrayLike.at() end
|
||||
|
||||
/**
|
||||
* @since v17.0.0
|
||||
*
|
||||
* Creates a deep clone of an object.
|
||||
*/
|
||||
declare function structuredClone<T>(
|
||||
value: T,
|
||||
transfer?: { transfer: ReadonlyArray<import('worker_threads').TransferListItem> },
|
||||
): T;
|
||||
|
||||
/*----------------------------------------------*
|
||||
* *
|
||||
* GLOBAL INTERFACES *
|
||||
* *
|
||||
*-----------------------------------------------*/
|
||||
declare namespace NodeJS {
|
||||
interface CallSite {
|
||||
/**
|
||||
* Value of "this"
|
||||
*/
|
||||
getThis(): unknown;
|
||||
|
||||
/**
|
||||
* Type of "this" as a string.
|
||||
* This is the name of the function stored in the constructor field of
|
||||
* "this", if available. Otherwise the object's [[Class]] internal
|
||||
* property.
|
||||
*/
|
||||
getTypeName(): string | null;
|
||||
|
||||
/**
|
||||
* Current function
|
||||
*/
|
||||
getFunction(): Function | undefined;
|
||||
|
||||
/**
|
||||
* Name of the current function, typically its name property.
|
||||
* If a name property is not available an attempt will be made to try
|
||||
* to infer a name from the function's context.
|
||||
*/
|
||||
getFunctionName(): string | null;
|
||||
|
||||
/**
|
||||
* Name of the property [of "this" or one of its prototypes] that holds
|
||||
* the current function
|
||||
*/
|
||||
getMethodName(): string | null;
|
||||
|
||||
/**
|
||||
* Name of the script [if this function was defined in a script]
|
||||
*/
|
||||
getFileName(): string | null;
|
||||
|
||||
/**
|
||||
* Current line number [if this function was defined in a script]
|
||||
*/
|
||||
getLineNumber(): number | null;
|
||||
|
||||
/**
|
||||
* Current column number [if this function was defined in a script]
|
||||
*/
|
||||
getColumnNumber(): number | null;
|
||||
|
||||
/**
|
||||
* A call site object representing the location where eval was called
|
||||
* [if this function was created using a call to eval]
|
||||
*/
|
||||
getEvalOrigin(): string | undefined;
|
||||
|
||||
/**
|
||||
* Is this a toplevel invocation, that is, is "this" the global object?
|
||||
*/
|
||||
isToplevel(): boolean;
|
||||
|
||||
/**
|
||||
* Does this call take place in code defined by a call to eval?
|
||||
*/
|
||||
isEval(): boolean;
|
||||
|
||||
/**
|
||||
* Is this call in native V8 code?
|
||||
*/
|
||||
isNative(): boolean;
|
||||
|
||||
/**
|
||||
* Is this a constructor call?
|
||||
*/
|
||||
isConstructor(): boolean;
|
||||
}
|
||||
|
||||
interface ErrnoException extends Error {
|
||||
errno?: number | undefined;
|
||||
code?: string | undefined;
|
||||
path?: string | undefined;
|
||||
syscall?: string | undefined;
|
||||
}
|
||||
|
||||
interface ReadableStream extends EventEmitter {
|
||||
readable: boolean;
|
||||
read(size?: number): string | Buffer;
|
||||
setEncoding(encoding: BufferEncoding): this;
|
||||
pause(): this;
|
||||
resume(): this;
|
||||
isPaused(): boolean;
|
||||
pipe<T extends WritableStream>(destination: T, options?: { end?: boolean | undefined; }): T;
|
||||
unpipe(destination?: WritableStream): this;
|
||||
unshift(chunk: string | Uint8Array, encoding?: BufferEncoding): void;
|
||||
wrap(oldStream: ReadableStream): this;
|
||||
[Symbol.asyncIterator](): AsyncIterableIterator<string | Buffer>;
|
||||
}
|
||||
|
||||
interface WritableStream extends EventEmitter {
|
||||
writable: boolean;
|
||||
write(buffer: Uint8Array | string, cb?: (err?: Error | null) => void): boolean;
|
||||
write(str: string, encoding?: BufferEncoding, cb?: (err?: Error | null) => void): boolean;
|
||||
end(cb?: () => void): this;
|
||||
end(data: string | Uint8Array, cb?: () => void): this;
|
||||
end(str: string, encoding?: BufferEncoding, cb?: () => void): this;
|
||||
}
|
||||
|
||||
interface ReadWriteStream extends ReadableStream, WritableStream { }
|
||||
|
||||
interface RefCounted {
|
||||
ref(): this;
|
||||
unref(): this;
|
||||
}
|
||||
|
||||
type TypedArray =
|
||||
| Uint8Array
|
||||
| Uint8ClampedArray
|
||||
| Uint16Array
|
||||
| Uint32Array
|
||||
| Int8Array
|
||||
| Int16Array
|
||||
| Int32Array
|
||||
| BigUint64Array
|
||||
| BigInt64Array
|
||||
| Float32Array
|
||||
| Float64Array;
|
||||
type ArrayBufferView = TypedArray | DataView;
|
||||
|
||||
interface Require {
|
||||
(id: string): any;
|
||||
resolve: RequireResolve;
|
||||
cache: Dict<NodeModule>;
|
||||
/**
|
||||
* @deprecated
|
||||
*/
|
||||
extensions: RequireExtensions;
|
||||
main: Module | undefined;
|
||||
}
|
||||
|
||||
interface RequireResolve {
|
||||
(id: string, options?: { paths?: string[] | undefined; }): string;
|
||||
paths(request: string): string[] | null;
|
||||
}
|
||||
|
||||
interface RequireExtensions extends Dict<(m: Module, filename: string) => any> {
|
||||
'.js': (m: Module, filename: string) => any;
|
||||
'.json': (m: Module, filename: string) => any;
|
||||
'.node': (m: Module, filename: string) => any;
|
||||
}
|
||||
interface Module {
|
||||
/**
|
||||
* `true` if the module is running during the Node.js preload
|
||||
*/
|
||||
isPreloading: boolean;
|
||||
exports: any;
|
||||
require: Require;
|
||||
id: string;
|
||||
filename: string;
|
||||
loaded: boolean;
|
||||
/** @deprecated since v14.6.0 Please use `require.main` and `module.children` instead. */
|
||||
parent: Module | null | undefined;
|
||||
children: Module[];
|
||||
/**
|
||||
* @since v11.14.0
|
||||
*
|
||||
* The directory name of the module. This is usually the same as the path.dirname() of the module.id.
|
||||
*/
|
||||
path: string;
|
||||
paths: string[];
|
||||
}
|
||||
|
||||
interface Dict<T> {
|
||||
[key: string]: T | undefined;
|
||||
}
|
||||
|
||||
interface ReadOnlyDict<T> {
|
||||
readonly [key: string]: T | undefined;
|
||||
}
|
||||
}
|
1
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/globals.global.d.ts
generated
vendored
1
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/globals.global.d.ts
generated
vendored
@ -0,0 +1 @@
|
||||
declare var global: typeof globalThis;
|
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,401 @@
|
||||
/**
|
||||
* HTTPS is the HTTP protocol over TLS/SSL. In Node.js this is implemented as a
|
||||
* separate module.
|
||||
* @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/https.js)
|
||||
*/
|
||||
declare module 'https' {
|
||||
import { Duplex } from 'node:stream';
|
||||
import * as tls from 'node:tls';
|
||||
import * as http from 'node:http';
|
||||
import { URL } from 'node:url';
|
||||
type ServerOptions = tls.SecureContextOptions & tls.TlsOptions & http.ServerOptions;
|
||||
type RequestOptions = http.RequestOptions &
|
||||
tls.SecureContextOptions & {
|
||||
rejectUnauthorized?: boolean | undefined; // Defaults to true
|
||||
servername?: string | undefined; // SNI TLS Extension
|
||||
};
|
||||
interface AgentOptions extends http.AgentOptions, tls.ConnectionOptions {
|
||||
rejectUnauthorized?: boolean | undefined;
|
||||
maxCachedSessions?: number | undefined;
|
||||
}
|
||||
/**
|
||||
* An `Agent` object for HTTPS similar to `http.Agent`. See {@link request} for more information.
|
||||
* @since v0.4.5
|
||||
*/
|
||||
class Agent extends http.Agent {
|
||||
constructor(options?: AgentOptions);
|
||||
options: AgentOptions;
|
||||
}
|
||||
interface Server extends http.Server {}
|
||||
/**
|
||||
* See `http.Server` for more information.
|
||||
* @since v0.3.4
|
||||
*/
|
||||
class Server extends tls.Server {
|
||||
constructor(requestListener?: http.RequestListener);
|
||||
constructor(options: ServerOptions, requestListener?: http.RequestListener);
|
||||
/**
|
||||
* Closes all connections connected to this server.
|
||||
* @since v18.2.0
|
||||
*/
|
||||
closeAllConnections(): void;
|
||||
/**
|
||||
* Closes all connections connected to this server which are not sending a request or waiting for a response.
|
||||
* @since v18.2.0
|
||||
*/
|
||||
closeIdleConnections(): void;
|
||||
addListener(event: string, listener: (...args: any[]) => void): this;
|
||||
addListener(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
|
||||
addListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
|
||||
addListener(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
|
||||
addListener(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
|
||||
addListener(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
|
||||
addListener(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
|
||||
addListener(event: 'close', listener: () => void): this;
|
||||
addListener(event: 'connection', listener: (socket: Duplex) => void): this;
|
||||
addListener(event: 'error', listener: (err: Error) => void): this;
|
||||
addListener(event: 'listening', listener: () => void): this;
|
||||
addListener(event: 'checkContinue', listener: http.RequestListener): this;
|
||||
addListener(event: 'checkExpectation', listener: http.RequestListener): this;
|
||||
addListener(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
|
||||
addListener(event: 'connect', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
|
||||
addListener(event: 'request', listener: http.RequestListener): this;
|
||||
addListener(event: 'upgrade', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
|
||||
emit(event: string, ...args: any[]): boolean;
|
||||
emit(event: 'keylog', line: Buffer, tlsSocket: tls.TLSSocket): boolean;
|
||||
emit(event: 'newSession', sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void): boolean;
|
||||
emit(event: 'OCSPRequest', certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void): boolean;
|
||||
emit(event: 'resumeSession', sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void): boolean;
|
||||
emit(event: 'secureConnection', tlsSocket: tls.TLSSocket): boolean;
|
||||
emit(event: 'tlsClientError', err: Error, tlsSocket: tls.TLSSocket): boolean;
|
||||
emit(event: 'close'): boolean;
|
||||
emit(event: 'connection', socket: Duplex): boolean;
|
||||
emit(event: 'error', err: Error): boolean;
|
||||
emit(event: 'listening'): boolean;
|
||||
emit(event: 'checkContinue', req: http.IncomingMessage, res: http.ServerResponse): boolean;
|
||||
emit(event: 'checkExpectation', req: http.IncomingMessage, res: http.ServerResponse): boolean;
|
||||
emit(event: 'clientError', err: Error, socket: Duplex): boolean;
|
||||
emit(event: 'connect', req: http.IncomingMessage, socket: Duplex, head: Buffer): boolean;
|
||||
emit(event: 'request', req: http.IncomingMessage, res: http.ServerResponse): boolean;
|
||||
emit(event: 'upgrade', req: http.IncomingMessage, socket: Duplex, head: Buffer): boolean;
|
||||
on(event: string, listener: (...args: any[]) => void): this;
|
||||
on(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
|
||||
on(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
|
||||
on(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
|
||||
on(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
|
||||
on(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
|
||||
on(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
|
||||
on(event: 'close', listener: () => void): this;
|
||||
on(event: 'connection', listener: (socket: Duplex) => void): this;
|
||||
on(event: 'error', listener: (err: Error) => void): this;
|
||||
on(event: 'listening', listener: () => void): this;
|
||||
on(event: 'checkContinue', listener: http.RequestListener): this;
|
||||
on(event: 'checkExpectation', listener: http.RequestListener): this;
|
||||
on(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
|
||||
on(event: 'connect', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
|
||||
on(event: 'request', listener: http.RequestListener): this;
|
||||
on(event: 'upgrade', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
|
||||
once(event: string, listener: (...args: any[]) => void): this;
|
||||
once(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
|
||||
once(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
|
||||
once(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
|
||||
once(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
|
||||
once(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
|
||||
once(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
|
||||
once(event: 'close', listener: () => void): this;
|
||||
once(event: 'connection', listener: (socket: Duplex) => void): this;
|
||||
once(event: 'error', listener: (err: Error) => void): this;
|
||||
once(event: 'listening', listener: () => void): this;
|
||||
once(event: 'checkContinue', listener: http.RequestListener): this;
|
||||
once(event: 'checkExpectation', listener: http.RequestListener): this;
|
||||
once(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
|
||||
once(event: 'connect', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
|
||||
once(event: 'request', listener: http.RequestListener): this;
|
||||
once(event: 'upgrade', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
|
||||
prependListener(event: string, listener: (...args: any[]) => void): this;
|
||||
prependListener(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
|
||||
prependListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
|
||||
prependListener(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
|
||||
prependListener(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
|
||||
prependListener(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
|
||||
prependListener(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
|
||||
prependListener(event: 'close', listener: () => void): this;
|
||||
prependListener(event: 'connection', listener: (socket: Duplex) => void): this;
|
||||
prependListener(event: 'error', listener: (err: Error) => void): this;
|
||||
prependListener(event: 'listening', listener: () => void): this;
|
||||
prependListener(event: 'checkContinue', listener: http.RequestListener): this;
|
||||
prependListener(event: 'checkExpectation', listener: http.RequestListener): this;
|
||||
prependListener(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
|
||||
prependListener(event: 'connect', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
|
||||
prependListener(event: 'request', listener: http.RequestListener): this;
|
||||
prependListener(event: 'upgrade', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
|
||||
prependOnceListener(event: string, listener: (...args: any[]) => void): this;
|
||||
prependOnceListener(event: 'keylog', listener: (line: Buffer, tlsSocket: tls.TLSSocket) => void): this;
|
||||
prependOnceListener(event: 'newSession', listener: (sessionId: Buffer, sessionData: Buffer, callback: (err: Error, resp: Buffer) => void) => void): this;
|
||||
prependOnceListener(event: 'OCSPRequest', listener: (certificate: Buffer, issuer: Buffer, callback: (err: Error | null, resp: Buffer) => void) => void): this;
|
||||
prependOnceListener(event: 'resumeSession', listener: (sessionId: Buffer, callback: (err: Error, sessionData: Buffer) => void) => void): this;
|
||||
prependOnceListener(event: 'secureConnection', listener: (tlsSocket: tls.TLSSocket) => void): this;
|
||||
prependOnceListener(event: 'tlsClientError', listener: (err: Error, tlsSocket: tls.TLSSocket) => void): this;
|
||||
prependOnceListener(event: 'close', listener: () => void): this;
|
||||
prependOnceListener(event: 'connection', listener: (socket: Duplex) => void): this;
|
||||
prependOnceListener(event: 'error', listener: (err: Error) => void): this;
|
||||
prependOnceListener(event: 'listening', listener: () => void): this;
|
||||
prependOnceListener(event: 'checkContinue', listener: http.RequestListener): this;
|
||||
prependOnceListener(event: 'checkExpectation', listener: http.RequestListener): this;
|
||||
prependOnceListener(event: 'clientError', listener: (err: Error, socket: Duplex) => void): this;
|
||||
prependOnceListener(event: 'connect', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
|
||||
prependOnceListener(event: 'request', listener: http.RequestListener): this;
|
||||
prependOnceListener(event: 'upgrade', listener: (req: http.IncomingMessage, socket: Duplex, head: Buffer) => void): this;
|
||||
}
|
||||
/**
|
||||
* ```js
|
||||
* // curl -k https://localhost:8000/
|
||||
* const https = require('https');
|
||||
* const fs = require('fs');
|
||||
*
|
||||
* const options = {
|
||||
* key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),
|
||||
* cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem')
|
||||
* };
|
||||
*
|
||||
* https.createServer(options, (req, res) => {
|
||||
* res.writeHead(200);
|
||||
* res.end('hello world\n');
|
||||
* }).listen(8000);
|
||||
* ```
|
||||
*
|
||||
* Or
|
||||
*
|
||||
* ```js
|
||||
* const https = require('https');
|
||||
* const fs = require('fs');
|
||||
*
|
||||
* const options = {
|
||||
* pfx: fs.readFileSync('test/fixtures/test_cert.pfx'),
|
||||
* passphrase: 'sample'
|
||||
* };
|
||||
*
|
||||
* https.createServer(options, (req, res) => {
|
||||
* res.writeHead(200);
|
||||
* res.end('hello world\n');
|
||||
* }).listen(8000);
|
||||
* ```
|
||||
* @since v0.3.4
|
||||
* @param options Accepts `options` from `createServer`, `createSecureContext` and `createServer`.
|
||||
* @param requestListener A listener to be added to the `'request'` event.
|
||||
*/
|
||||
function createServer(requestListener?: http.RequestListener): Server;
|
||||
function createServer(options: ServerOptions, requestListener?: http.RequestListener): Server;
|
||||
/**
|
||||
* Makes a request to a secure web server.
|
||||
*
|
||||
* The following additional `options` from `tls.connect()` are also accepted:`ca`, `cert`, `ciphers`, `clientCertEngine`, `crl`, `dhparam`, `ecdhCurve`,`honorCipherOrder`, `key`, `passphrase`,
|
||||
* `pfx`, `rejectUnauthorized`,`secureOptions`, `secureProtocol`, `servername`, `sessionIdContext`,`highWaterMark`.
|
||||
*
|
||||
* `options` can be an object, a string, or a `URL` object. If `options` is a
|
||||
* string, it is automatically parsed with `new URL()`. If it is a `URL` object, it will be automatically converted to an ordinary `options` object.
|
||||
*
|
||||
* `https.request()` returns an instance of the `http.ClientRequest` class. The `ClientRequest` instance is a writable stream. If one needs to
|
||||
* upload a file with a POST request, then write to the `ClientRequest` object.
|
||||
*
|
||||
* ```js
|
||||
* const https = require('https');
|
||||
*
|
||||
* const options = {
|
||||
* hostname: 'encrypted.google.com',
|
||||
* port: 443,
|
||||
* path: '/',
|
||||
* method: 'GET'
|
||||
* };
|
||||
*
|
||||
* const req = https.request(options, (res) => {
|
||||
* console.log('statusCode:', res.statusCode);
|
||||
* console.log('headers:', res.headers);
|
||||
*
|
||||
* res.on('data', (d) => {
|
||||
* process.stdout.write(d);
|
||||
* });
|
||||
* });
|
||||
*
|
||||
* req.on('error', (e) => {
|
||||
* console.error(e);
|
||||
* });
|
||||
* req.end();
|
||||
* ```
|
||||
*
|
||||
* Example using options from `tls.connect()`:
|
||||
*
|
||||
* ```js
|
||||
* const options = {
|
||||
* hostname: 'encrypted.google.com',
|
||||
* port: 443,
|
||||
* path: '/',
|
||||
* method: 'GET',
|
||||
* key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),
|
||||
* cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem')
|
||||
* };
|
||||
* options.agent = new https.Agent(options);
|
||||
*
|
||||
* const req = https.request(options, (res) => {
|
||||
* // ...
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* Alternatively, opt out of connection pooling by not using an `Agent`.
|
||||
*
|
||||
* ```js
|
||||
* const options = {
|
||||
* hostname: 'encrypted.google.com',
|
||||
* port: 443,
|
||||
* path: '/',
|
||||
* method: 'GET',
|
||||
* key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),
|
||||
* cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem'),
|
||||
* agent: false
|
||||
* };
|
||||
*
|
||||
* const req = https.request(options, (res) => {
|
||||
* // ...
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* Example using a `URL` as `options`:
|
||||
*
|
||||
* ```js
|
||||
* const options = new URL('https://abc:xyz@example.com');
|
||||
*
|
||||
* const req = https.request(options, (res) => {
|
||||
* // ...
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* Example pinning on certificate fingerprint, or the public key (similar to`pin-sha256`):
|
||||
*
|
||||
* ```js
|
||||
* const tls = require('tls');
|
||||
* const https = require('https');
|
||||
* const crypto = require('crypto');
|
||||
*
|
||||
* function sha256(s) {
|
||||
* return crypto.createHash('sha256').update(s).digest('base64');
|
||||
* }
|
||||
* const options = {
|
||||
* hostname: 'github.com',
|
||||
* port: 443,
|
||||
* path: '/',
|
||||
* method: 'GET',
|
||||
* checkServerIdentity: function(host, cert) {
|
||||
* // Make sure the certificate is issued to the host we are connected to
|
||||
* const err = tls.checkServerIdentity(host, cert);
|
||||
* if (err) {
|
||||
* return err;
|
||||
* }
|
||||
*
|
||||
* // Pin the public key, similar to HPKP pin-sha25 pinning
|
||||
* const pubkey256 = 'pL1+qb9HTMRZJmuC/bB/ZI9d302BYrrqiVuRyW+DGrU=';
|
||||
* if (sha256(cert.pubkey) !== pubkey256) {
|
||||
* const msg = 'Certificate verification error: ' +
|
||||
* `The public key of '${cert.subject.CN}' ` +
|
||||
* 'does not match our pinned fingerprint';
|
||||
* return new Error(msg);
|
||||
* }
|
||||
*
|
||||
* // Pin the exact certificate, rather than the pub key
|
||||
* const cert256 = '25:FE:39:32:D9:63:8C:8A:FC:A1:9A:29:87:' +
|
||||
* 'D8:3E:4C:1D:98:DB:71:E4:1A:48:03:98:EA:22:6A:BD:8B:93:16';
|
||||
* if (cert.fingerprint256 !== cert256) {
|
||||
* const msg = 'Certificate verification error: ' +
|
||||
* `The certificate of '${cert.subject.CN}' ` +
|
||||
* 'does not match our pinned fingerprint';
|
||||
* return new Error(msg);
|
||||
* }
|
||||
*
|
||||
* // This loop is informational only.
|
||||
* // Print the certificate and public key fingerprints of all certs in the
|
||||
* // chain. Its common to pin the public key of the issuer on the public
|
||||
* // internet, while pinning the public key of the service in sensitive
|
||||
* // environments.
|
||||
* do {
|
||||
* console.log('Subject Common Name:', cert.subject.CN);
|
||||
* console.log(' Certificate SHA256 fingerprint:', cert.fingerprint256);
|
||||
*
|
||||
* hash = crypto.createHash('sha256');
|
||||
* console.log(' Public key ping-sha256:', sha256(cert.pubkey));
|
||||
*
|
||||
* lastprint256 = cert.fingerprint256;
|
||||
* cert = cert.issuerCertificate;
|
||||
* } while (cert.fingerprint256 !== lastprint256);
|
||||
*
|
||||
* },
|
||||
* };
|
||||
*
|
||||
* options.agent = new https.Agent(options);
|
||||
* const req = https.request(options, (res) => {
|
||||
* console.log('All OK. Server matched our pinned cert or public key');
|
||||
* console.log('statusCode:', res.statusCode);
|
||||
* // Print the HPKP values
|
||||
* console.log('headers:', res.headers['public-key-pins']);
|
||||
*
|
||||
* res.on('data', (d) => {});
|
||||
* });
|
||||
*
|
||||
* req.on('error', (e) => {
|
||||
* console.error(e.message);
|
||||
* });
|
||||
* req.end();
|
||||
* ```
|
||||
*
|
||||
* Outputs for example:
|
||||
*
|
||||
* ```text
|
||||
* Subject Common Name: github.com
|
||||
* Certificate SHA256 fingerprint: 25:FE:39:32:D9:63:8C:8A:FC:A1:9A:29:87:D8:3E:4C:1D:98:DB:71:E4:1A:48:03:98:EA:22:6A:BD:8B:93:16
|
||||
* Public key ping-sha256: pL1+qb9HTMRZJmuC/bB/ZI9d302BYrrqiVuRyW+DGrU=
|
||||
* Subject Common Name: DigiCert SHA2 Extended Validation Server CA
|
||||
* Certificate SHA256 fingerprint: 40:3E:06:2A:26:53:05:91:13:28:5B:AF:80:A0:D4:AE:42:2C:84:8C:9F:78:FA:D0:1F:C9:4B:C5:B8:7F:EF:1A
|
||||
* Public key ping-sha256: RRM1dGqnDFsCJXBTHky16vi1obOlCgFFn/yOhI/y+ho=
|
||||
* Subject Common Name: DigiCert High Assurance EV Root CA
|
||||
* Certificate SHA256 fingerprint: 74:31:E5:F4:C3:C1:CE:46:90:77:4F:0B:61:E0:54:40:88:3B:A9:A0:1E:D0:0B:A6:AB:D7:80:6E:D3:B1:18:CF
|
||||
* Public key ping-sha256: WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18=
|
||||
* All OK. Server matched our pinned cert or public key
|
||||
* statusCode: 200
|
||||
* headers: max-age=0; pin-sha256="WoiWRyIOVNa9ihaBciRSC7XHjliYS9VwUGOIud4PB18="; pin-sha256="RRM1dGqnDFsCJXBTHky16vi1obOlCgFFn/yOhI/y+ho=";
|
||||
* pin-sha256="k2v657xBsOVe1PQRwOsHsw3bsGT2VzIqz5K+59sNQws="; pin-sha256="K87oWBWM9UZfyddvDfoxL+8lpNyoUB2ptGtn0fv6G2Q="; pin-sha256="IQBnNBEiFuhj+8x6X8XLgh01V9Ic5/V3IRQLNFFc7v4=";
|
||||
* pin-sha256="iie1VXtL7HzAMF+/PVPR9xzT80kQxdZeJ+zduCB3uj0="; pin-sha256="LvRiGEjRqfzurezaWuj8Wie2gyHMrW5Q06LspMnox7A="; includeSubDomains
|
||||
* ```
|
||||
* @since v0.3.6
|
||||
* @param options Accepts all `options` from `request`, with some differences in default values:
|
||||
*/
|
||||
function request(options: RequestOptions | string | URL, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
|
||||
function request(url: string | URL, options: RequestOptions, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
|
||||
/**
|
||||
* Like `http.get()` but for HTTPS.
|
||||
*
|
||||
* `options` can be an object, a string, or a `URL` object. If `options` is a
|
||||
* string, it is automatically parsed with `new URL()`. If it is a `URL` object, it will be automatically converted to an ordinary `options` object.
|
||||
*
|
||||
* ```js
|
||||
* const https = require('https');
|
||||
*
|
||||
* https.get('https://encrypted.google.com/', (res) => {
|
||||
* console.log('statusCode:', res.statusCode);
|
||||
* console.log('headers:', res.headers);
|
||||
*
|
||||
* res.on('data', (d) => {
|
||||
* process.stdout.write(d);
|
||||
* });
|
||||
*
|
||||
* }).on('error', (e) => {
|
||||
* console.error(e);
|
||||
* });
|
||||
* ```
|
||||
* @since v0.3.6
|
||||
* @param options Accepts the same `options` as {@link request}, with the `method` always set to `GET`.
|
||||
*/
|
||||
function get(options: RequestOptions | string | URL, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
|
||||
function get(url: string | URL, options: RequestOptions, callback?: (res: http.IncomingMessage) => void): http.ClientRequest;
|
||||
let globalAgent: Agent;
|
||||
}
|
||||
declare module 'node:https' {
|
||||
export * from 'https';
|
||||
}
|
@ -0,0 +1,132 @@
|
||||
// Type definitions for non-npm package Node.js 18.7
|
||||
// Project: https://nodejs.org/
|
||||
// Definitions by: Microsoft TypeScript <https://github.com/Microsoft>
|
||||
// DefinitelyTyped <https://github.com/DefinitelyTyped>
|
||||
// Alberto Schiabel <https://github.com/jkomyno>
|
||||
// Alvis HT Tang <https://github.com/alvis>
|
||||
// Andrew Makarov <https://github.com/r3nya>
|
||||
// Benjamin Toueg <https://github.com/btoueg>
|
||||
// Chigozirim C. <https://github.com/smac89>
|
||||
// David Junger <https://github.com/touffy>
|
||||
// Deividas Bakanas <https://github.com/DeividasBakanas>
|
||||
// Eugene Y. Q. Shen <https://github.com/eyqs>
|
||||
// Hannes Magnusson <https://github.com/Hannes-Magnusson-CK>
|
||||
// Huw <https://github.com/hoo29>
|
||||
// Kelvin Jin <https://github.com/kjin>
|
||||
// Klaus Meinhardt <https://github.com/ajafff>
|
||||
// Lishude <https://github.com/islishude>
|
||||
// Mariusz Wiktorczyk <https://github.com/mwiktorczyk>
|
||||
// Mohsen Azimi <https://github.com/mohsen1>
|
||||
// Nicolas Even <https://github.com/n-e>
|
||||
// Nikita Galkin <https://github.com/galkin>
|
||||
// Parambir Singh <https://github.com/parambirs>
|
||||
// Sebastian Silbermann <https://github.com/eps1lon>
|
||||
// Simon Schick <https://github.com/SimonSchick>
|
||||
// Thomas den Hollander <https://github.com/ThomasdenH>
|
||||
// Wilco Bakker <https://github.com/WilcoBakker>
|
||||
// wwwy3y3 <https://github.com/wwwy3y3>
|
||||
// Samuel Ainsworth <https://github.com/samuela>
|
||||
// Kyle Uehlein <https://github.com/kuehlein>
|
||||
// Thanik Bhongbhibhat <https://github.com/bhongy>
|
||||
// Marcin Kopacz <https://github.com/chyzwar>
|
||||
// Trivikram Kamat <https://github.com/trivikr>
|
||||
// Junxiao Shi <https://github.com/yoursunny>
|
||||
// Ilia Baryshnikov <https://github.com/qwelias>
|
||||
// ExE Boss <https://github.com/ExE-Boss>
|
||||
// Piotr Błażejewicz <https://github.com/peterblazejewicz>
|
||||
// Anna Henningsen <https://github.com/addaleax>
|
||||
// Victor Perin <https://github.com/victorperin>
|
||||
// Yongsheng Zhang <https://github.com/ZYSzys>
|
||||
// NodeJS Contributors <https://github.com/NodeJS>
|
||||
// Linus Unnebäck <https://github.com/LinusU>
|
||||
// wafuwafu13 <https://github.com/wafuwafu13>
|
||||
// Matteo Collina <https://github.com/mcollina>
|
||||
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
|
||||
|
||||
/**
|
||||
* License for programmatically and manually incorporated
|
||||
* documentation aka. `JSDoc` from https://github.com/nodejs/node/tree/master/doc
|
||||
*
|
||||
* Copyright Node.js contributors. All rights reserved.
|
||||
* 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.
|
||||
*/
|
||||
|
||||
// NOTE: These definitions support NodeJS and TypeScript 3.7+.
|
||||
|
||||
// Reference required types from the default lib:
|
||||
/// <reference lib="es2020" />
|
||||
/// <reference lib="esnext.asynciterable" />
|
||||
/// <reference lib="esnext.intl" />
|
||||
/// <reference lib="esnext.bigint" />
|
||||
|
||||
// Base definitions for all NodeJS modules that are not specific to any version of TypeScript:
|
||||
/// <reference path="assert.d.ts" />
|
||||
/// <reference path="assert/strict.d.ts" />
|
||||
/// <reference path="globals.d.ts" />
|
||||
/// <reference path="async_hooks.d.ts" />
|
||||
/// <reference path="buffer.d.ts" />
|
||||
/// <reference path="child_process.d.ts" />
|
||||
/// <reference path="cluster.d.ts" />
|
||||
/// <reference path="console.d.ts" />
|
||||
/// <reference path="constants.d.ts" />
|
||||
/// <reference path="crypto.d.ts" />
|
||||
/// <reference path="dgram.d.ts" />
|
||||
/// <reference path="diagnostics_channel.d.ts" />
|
||||
/// <reference path="dns.d.ts" />
|
||||
/// <reference path="dns/promises.d.ts" />
|
||||
/// <reference path="dns/promises.d.ts" />
|
||||
/// <reference path="domain.d.ts" />
|
||||
/// <reference path="events.d.ts" />
|
||||
/// <reference path="fs.d.ts" />
|
||||
/// <reference path="fs/promises.d.ts" />
|
||||
/// <reference path="http.d.ts" />
|
||||
/// <reference path="http2.d.ts" />
|
||||
/// <reference path="https.d.ts" />
|
||||
/// <reference path="inspector.d.ts" />
|
||||
/// <reference path="module.d.ts" />
|
||||
/// <reference path="net.d.ts" />
|
||||
/// <reference path="os.d.ts" />
|
||||
/// <reference path="path.d.ts" />
|
||||
/// <reference path="perf_hooks.d.ts" />
|
||||
/// <reference path="process.d.ts" />
|
||||
/// <reference path="punycode.d.ts" />
|
||||
/// <reference path="querystring.d.ts" />
|
||||
/// <reference path="readline.d.ts" />
|
||||
/// <reference path="readline/promises.d.ts" />
|
||||
/// <reference path="repl.d.ts" />
|
||||
/// <reference path="stream.d.ts" />
|
||||
/// <reference path="stream/promises.d.ts" />
|
||||
/// <reference path="stream/consumers.d.ts" />
|
||||
/// <reference path="stream/web.d.ts" />
|
||||
/// <reference path="string_decoder.d.ts" />
|
||||
/// <reference path="test.d.ts" />
|
||||
/// <reference path="timers.d.ts" />
|
||||
/// <reference path="timers/promises.d.ts" />
|
||||
/// <reference path="tls.d.ts" />
|
||||
/// <reference path="trace_events.d.ts" />
|
||||
/// <reference path="tty.d.ts" />
|
||||
/// <reference path="url.d.ts" />
|
||||
/// <reference path="util.d.ts" />
|
||||
/// <reference path="v8.d.ts" />
|
||||
/// <reference path="vm.d.ts" />
|
||||
/// <reference path="wasi.d.ts" />
|
||||
/// <reference path="worker_threads.d.ts" />
|
||||
/// <reference path="zlib.d.ts" />
|
||||
|
||||
/// <reference path="globals.global.d.ts" />
|
2741
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/inspector.d.ts
generated
vendored
2741
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/inspector.d.ts
generated
vendored
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,114 @@
|
||||
/**
|
||||
* @since v0.3.7
|
||||
*/
|
||||
declare module 'module' {
|
||||
import { URL } from 'node:url';
|
||||
namespace Module {
|
||||
/**
|
||||
* The `module.syncBuiltinESMExports()` method updates all the live bindings for
|
||||
* builtin `ES Modules` to match the properties of the `CommonJS` exports. It
|
||||
* does not add or remove exported names from the `ES Modules`.
|
||||
*
|
||||
* ```js
|
||||
* const fs = require('fs');
|
||||
* const assert = require('assert');
|
||||
* const { syncBuiltinESMExports } = require('module');
|
||||
*
|
||||
* fs.readFile = newAPI;
|
||||
*
|
||||
* delete fs.readFileSync;
|
||||
*
|
||||
* function newAPI() {
|
||||
* // ...
|
||||
* }
|
||||
*
|
||||
* fs.newAPI = newAPI;
|
||||
*
|
||||
* syncBuiltinESMExports();
|
||||
*
|
||||
* import('fs').then((esmFS) => {
|
||||
* // It syncs the existing readFile property with the new value
|
||||
* assert.strictEqual(esmFS.readFile, newAPI);
|
||||
* // readFileSync has been deleted from the required fs
|
||||
* assert.strictEqual('readFileSync' in fs, false);
|
||||
* // syncBuiltinESMExports() does not remove readFileSync from esmFS
|
||||
* assert.strictEqual('readFileSync' in esmFS, true);
|
||||
* // syncBuiltinESMExports() does not add names
|
||||
* assert.strictEqual(esmFS.newAPI, undefined);
|
||||
* });
|
||||
* ```
|
||||
* @since v12.12.0
|
||||
*/
|
||||
function syncBuiltinESMExports(): void;
|
||||
/**
|
||||
* `path` is the resolved path for the file for which a corresponding source map
|
||||
* should be fetched.
|
||||
* @since v13.7.0, v12.17.0
|
||||
*/
|
||||
function findSourceMap(path: string, error?: Error): SourceMap;
|
||||
interface SourceMapPayload {
|
||||
file: string;
|
||||
version: number;
|
||||
sources: string[];
|
||||
sourcesContent: string[];
|
||||
names: string[];
|
||||
mappings: string;
|
||||
sourceRoot: string;
|
||||
}
|
||||
interface SourceMapping {
|
||||
generatedLine: number;
|
||||
generatedColumn: number;
|
||||
originalSource: string;
|
||||
originalLine: number;
|
||||
originalColumn: number;
|
||||
}
|
||||
/**
|
||||
* @since v13.7.0, v12.17.0
|
||||
*/
|
||||
class SourceMap {
|
||||
/**
|
||||
* Getter for the payload used to construct the `SourceMap` instance.
|
||||
*/
|
||||
readonly payload: SourceMapPayload;
|
||||
constructor(payload: SourceMapPayload);
|
||||
/**
|
||||
* Given a line number and column number in the generated source file, returns
|
||||
* an object representing the position in the original file. The object returned
|
||||
* consists of the following keys:
|
||||
*/
|
||||
findEntry(line: number, column: number): SourceMapping;
|
||||
}
|
||||
}
|
||||
interface Module extends NodeModule {}
|
||||
class Module {
|
||||
static runMain(): void;
|
||||
static wrap(code: string): string;
|
||||
static createRequire(path: string | URL): NodeRequire;
|
||||
static builtinModules: string[];
|
||||
static Module: typeof Module;
|
||||
constructor(id: string, parent?: Module);
|
||||
}
|
||||
global {
|
||||
interface ImportMeta {
|
||||
url: string;
|
||||
/**
|
||||
* @experimental
|
||||
* This feature is only available with the `--experimental-import-meta-resolve`
|
||||
* command flag enabled.
|
||||
*
|
||||
* Provides a module-relative resolution function scoped to each module, returning
|
||||
* the URL string.
|
||||
*
|
||||
* @param specified The module specifier to resolve relative to `parent`.
|
||||
* @param parent The absolute parent module URL to resolve from. If none
|
||||
* is specified, the value of `import.meta.url` is used as the default.
|
||||
*/
|
||||
resolve?(specified: string, parent?: string | URL): Promise<string>;
|
||||
}
|
||||
}
|
||||
export = Module;
|
||||
}
|
||||
declare module 'node:module' {
|
||||
import module = require('module');
|
||||
export = module;
|
||||
}
|
@ -0,0 +1,838 @@
|
||||
/**
|
||||
* > Stability: 2 - Stable
|
||||
*
|
||||
* The `net` module provides an asynchronous network API for creating stream-based
|
||||
* TCP or `IPC` servers ({@link createServer}) and clients
|
||||
* ({@link createConnection}).
|
||||
*
|
||||
* It can be accessed using:
|
||||
*
|
||||
* ```js
|
||||
* const net = require('net');
|
||||
* ```
|
||||
* @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/net.js)
|
||||
*/
|
||||
declare module 'net' {
|
||||
import * as stream from 'node:stream';
|
||||
import { Abortable, EventEmitter } from 'node:events';
|
||||
import * as dns from 'node:dns';
|
||||
type LookupFunction = (hostname: string, options: dns.LookupOneOptions, callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void) => void;
|
||||
interface AddressInfo {
|
||||
address: string;
|
||||
family: string;
|
||||
port: number;
|
||||
}
|
||||
interface SocketConstructorOpts {
|
||||
fd?: number | undefined;
|
||||
allowHalfOpen?: boolean | undefined;
|
||||
readable?: boolean | undefined;
|
||||
writable?: boolean | undefined;
|
||||
signal?: AbortSignal;
|
||||
}
|
||||
interface OnReadOpts {
|
||||
buffer: Uint8Array | (() => Uint8Array);
|
||||
/**
|
||||
* This function is called for every chunk of incoming data.
|
||||
* Two arguments are passed to it: the number of bytes written to buffer and a reference to buffer.
|
||||
* Return false from this function to implicitly pause() the socket.
|
||||
*/
|
||||
callback(bytesWritten: number, buf: Uint8Array): boolean;
|
||||
}
|
||||
interface ConnectOpts {
|
||||
/**
|
||||
* If specified, incoming data is stored in a single buffer and passed to the supplied callback when data arrives on the socket.
|
||||
* Note: this will cause the streaming functionality to not provide any data, however events like 'error', 'end', and 'close' will
|
||||
* still be emitted as normal and methods like pause() and resume() will also behave as expected.
|
||||
*/
|
||||
onread?: OnReadOpts | undefined;
|
||||
}
|
||||
interface TcpSocketConnectOpts extends ConnectOpts {
|
||||
port: number;
|
||||
host?: string | undefined;
|
||||
localAddress?: string | undefined;
|
||||
localPort?: number | undefined;
|
||||
hints?: number | undefined;
|
||||
family?: number | undefined;
|
||||
lookup?: LookupFunction | undefined;
|
||||
noDelay?: boolean | undefined;
|
||||
keepAlive?: boolean | undefined;
|
||||
keepAliveInitialDelay?: number | undefined;
|
||||
}
|
||||
interface IpcSocketConnectOpts extends ConnectOpts {
|
||||
path: string;
|
||||
}
|
||||
type SocketConnectOpts = TcpSocketConnectOpts | IpcSocketConnectOpts;
|
||||
type SocketReadyState = 'opening' | 'open' | 'readOnly' | 'writeOnly' | 'closed';
|
||||
/**
|
||||
* This class is an abstraction of a TCP socket or a streaming `IPC` endpoint
|
||||
* (uses named pipes on Windows, and Unix domain sockets otherwise). It is also
|
||||
* an `EventEmitter`.
|
||||
*
|
||||
* A `net.Socket` can be created by the user and used directly to interact with
|
||||
* a server. For example, it is returned by {@link createConnection},
|
||||
* so the user can use it to talk to the server.
|
||||
*
|
||||
* It can also be created by Node.js and passed to the user when a connection
|
||||
* is received. For example, it is passed to the listeners of a `'connection'` event emitted on a {@link Server}, so the user can use
|
||||
* it to interact with the client.
|
||||
* @since v0.3.4
|
||||
*/
|
||||
class Socket extends stream.Duplex {
|
||||
constructor(options?: SocketConstructorOpts);
|
||||
/**
|
||||
* Sends data on the socket. The second parameter specifies the encoding in the
|
||||
* case of a string. It defaults to UTF8 encoding.
|
||||
*
|
||||
* Returns `true` if the entire data was flushed successfully to the kernel
|
||||
* buffer. Returns `false` if all or part of the data was queued in user memory.`'drain'` will be emitted when the buffer is again free.
|
||||
*
|
||||
* The optional `callback` parameter will be executed when the data is finally
|
||||
* written out, which may not be immediately.
|
||||
*
|
||||
* See `Writable` stream `write()` method for more
|
||||
* information.
|
||||
* @since v0.1.90
|
||||
* @param [encoding='utf8'] Only used when data is `string`.
|
||||
*/
|
||||
write(buffer: Uint8Array | string, cb?: (err?: Error) => void): boolean;
|
||||
write(str: Uint8Array | string, encoding?: BufferEncoding, cb?: (err?: Error) => void): boolean;
|
||||
/**
|
||||
* Initiate a connection on a given socket.
|
||||
*
|
||||
* Possible signatures:
|
||||
*
|
||||
* * `socket.connect(options[, connectListener])`
|
||||
* * `socket.connect(path[, connectListener])` for `IPC` connections.
|
||||
* * `socket.connect(port[, host][, connectListener])` for TCP connections.
|
||||
* * Returns: `net.Socket` The socket itself.
|
||||
*
|
||||
* This function is asynchronous. When the connection is established, the `'connect'` event will be emitted. If there is a problem connecting,
|
||||
* instead of a `'connect'` event, an `'error'` event will be emitted with
|
||||
* the error passed to the `'error'` listener.
|
||||
* The last parameter `connectListener`, if supplied, will be added as a listener
|
||||
* for the `'connect'` event **once**.
|
||||
*
|
||||
* This function should only be used for reconnecting a socket after`'close'` has been emitted or otherwise it may lead to undefined
|
||||
* behavior.
|
||||
*/
|
||||
connect(options: SocketConnectOpts, connectionListener?: () => void): this;
|
||||
connect(port: number, host: string, connectionListener?: () => void): this;
|
||||
connect(port: number, connectionListener?: () => void): this;
|
||||
connect(path: string, connectionListener?: () => void): this;
|
||||
/**
|
||||
* Set the encoding for the socket as a `Readable Stream`. See `readable.setEncoding()` for more information.
|
||||
* @since v0.1.90
|
||||
* @return The socket itself.
|
||||
*/
|
||||
setEncoding(encoding?: BufferEncoding): this;
|
||||
/**
|
||||
* Pauses the reading of data. That is, `'data'` events will not be emitted.
|
||||
* Useful to throttle back an upload.
|
||||
* @return The socket itself.
|
||||
*/
|
||||
pause(): this;
|
||||
/**
|
||||
* Resumes reading after a call to `socket.pause()`.
|
||||
* @return The socket itself.
|
||||
*/
|
||||
resume(): this;
|
||||
/**
|
||||
* Sets the socket to timeout after `timeout` milliseconds of inactivity on
|
||||
* the socket. By default `net.Socket` do not have a timeout.
|
||||
*
|
||||
* When an idle timeout is triggered the socket will receive a `'timeout'` event but the connection will not be severed. The user must manually call `socket.end()` or `socket.destroy()` to
|
||||
* end the connection.
|
||||
*
|
||||
* ```js
|
||||
* socket.setTimeout(3000);
|
||||
* socket.on('timeout', () => {
|
||||
* console.log('socket timeout');
|
||||
* socket.end();
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* If `timeout` is 0, then the existing idle timeout is disabled.
|
||||
*
|
||||
* The optional `callback` parameter will be added as a one-time listener for the `'timeout'` event.
|
||||
* @since v0.1.90
|
||||
* @return The socket itself.
|
||||
*/
|
||||
setTimeout(timeout: number, callback?: () => void): this;
|
||||
/**
|
||||
* Enable/disable the use of Nagle's algorithm.
|
||||
*
|
||||
* When a TCP connection is created, it will have Nagle's algorithm enabled.
|
||||
*
|
||||
* Nagle's algorithm delays data before it is sent via the network. It attempts
|
||||
* to optimize throughput at the expense of latency.
|
||||
*
|
||||
* Passing `true` for `noDelay` or not passing an argument will disable Nagle's
|
||||
* algorithm for the socket. Passing `false` for `noDelay` will enable Nagle's
|
||||
* algorithm.
|
||||
* @since v0.1.90
|
||||
* @param [noDelay=true]
|
||||
* @return The socket itself.
|
||||
*/
|
||||
setNoDelay(noDelay?: boolean): this;
|
||||
/**
|
||||
* Enable/disable keep-alive functionality, and optionally set the initial
|
||||
* delay before the first keepalive probe is sent on an idle socket.
|
||||
*
|
||||
* Set `initialDelay` (in milliseconds) to set the delay between the last
|
||||
* data packet received and the first keepalive probe. Setting `0` for`initialDelay` will leave the value unchanged from the default
|
||||
* (or previous) setting.
|
||||
*
|
||||
* Enabling the keep-alive functionality will set the following socket options:
|
||||
*
|
||||
* * `SO_KEEPALIVE=1`
|
||||
* * `TCP_KEEPIDLE=initialDelay`
|
||||
* * `TCP_KEEPCNT=10`
|
||||
* * `TCP_KEEPINTVL=1`
|
||||
* @since v0.1.92
|
||||
* @param [enable=false]
|
||||
* @param [initialDelay=0]
|
||||
* @return The socket itself.
|
||||
*/
|
||||
setKeepAlive(enable?: boolean, initialDelay?: number): this;
|
||||
/**
|
||||
* Returns the bound `address`, the address `family` name and `port` of the
|
||||
* socket as reported by the operating system:`{ port: 12346, family: 'IPv4', address: '127.0.0.1' }`
|
||||
* @since v0.1.90
|
||||
*/
|
||||
address(): AddressInfo | {};
|
||||
/**
|
||||
* Calling `unref()` on a socket will allow the program to exit if this is the only
|
||||
* active socket in the event system. If the socket is already `unref`ed calling`unref()` again will have no effect.
|
||||
* @since v0.9.1
|
||||
* @return The socket itself.
|
||||
*/
|
||||
unref(): this;
|
||||
/**
|
||||
* Opposite of `unref()`, calling `ref()` on a previously `unref`ed socket will _not_ let the program exit if it's the only socket left (the default behavior).
|
||||
* If the socket is `ref`ed calling `ref` again will have no effect.
|
||||
* @since v0.9.1
|
||||
* @return The socket itself.
|
||||
*/
|
||||
ref(): this;
|
||||
/**
|
||||
* This property shows the number of characters buffered for writing. The buffer
|
||||
* may contain strings whose length after encoding is not yet known. So this number
|
||||
* is only an approximation of the number of bytes in the buffer.
|
||||
*
|
||||
* `net.Socket` has the property that `socket.write()` always works. This is to
|
||||
* help users get up and running quickly. The computer cannot always keep up
|
||||
* with the amount of data that is written to a socket. The network connection
|
||||
* simply might be too slow. Node.js will internally queue up the data written to a
|
||||
* socket and send it out over the wire when it is possible.
|
||||
*
|
||||
* The consequence of this internal buffering is that memory may grow.
|
||||
* Users who experience large or growing `bufferSize` should attempt to
|
||||
* "throttle" the data flows in their program with `socket.pause()` and `socket.resume()`.
|
||||
* @since v0.3.8
|
||||
* @deprecated Since v14.6.0 - Use `writableLength` instead.
|
||||
*/
|
||||
readonly bufferSize: number;
|
||||
/**
|
||||
* The amount of received bytes.
|
||||
* @since v0.5.3
|
||||
*/
|
||||
readonly bytesRead: number;
|
||||
/**
|
||||
* The amount of bytes sent.
|
||||
* @since v0.5.3
|
||||
*/
|
||||
readonly bytesWritten: number;
|
||||
/**
|
||||
* If `true`,`socket.connect(options[, connectListener])` was
|
||||
* called and has not yet finished. It will stay `true` until the socket becomes
|
||||
* connected, then it is set to `false` and the `'connect'` event is emitted. Note
|
||||
* that the `socket.connect(options[, connectListener])` callback is a listener for the `'connect'` event.
|
||||
* @since v6.1.0
|
||||
*/
|
||||
readonly connecting: boolean;
|
||||
/**
|
||||
* See `writable.destroyed` for further details.
|
||||
*/
|
||||
readonly destroyed: boolean;
|
||||
/**
|
||||
* The string representation of the local IP address the remote client is
|
||||
* connecting on. For example, in a server listening on `'0.0.0.0'`, if a client
|
||||
* connects on `'192.168.1.1'`, the value of `socket.localAddress` would be`'192.168.1.1'`.
|
||||
* @since v0.9.6
|
||||
*/
|
||||
readonly localAddress?: string;
|
||||
/**
|
||||
* The numeric representation of the local port. For example, `80` or `21`.
|
||||
* @since v0.9.6
|
||||
*/
|
||||
readonly localPort?: number;
|
||||
/**
|
||||
* This property represents the state of the connection as a string.
|
||||
* @see {https://nodejs.org/api/net.html#socketreadystate}
|
||||
* @since v0.5.0
|
||||
*/
|
||||
readonly readyState: SocketReadyState;
|
||||
/**
|
||||
* The string representation of the remote IP address. For example,`'74.125.127.100'` or `'2001:4860:a005::68'`. Value may be `undefined` if
|
||||
* the socket is destroyed (for example, if the client disconnected).
|
||||
* @since v0.5.10
|
||||
*/
|
||||
readonly remoteAddress?: string | undefined;
|
||||
/**
|
||||
* The string representation of the remote IP family. `'IPv4'` or `'IPv6'`.
|
||||
* @since v0.11.14
|
||||
*/
|
||||
readonly remoteFamily?: string | undefined;
|
||||
/**
|
||||
* The numeric representation of the remote port. For example, `80` or `21`.
|
||||
* @since v0.5.10
|
||||
*/
|
||||
readonly remotePort?: number | undefined;
|
||||
/**
|
||||
* The socket timeout in milliseconds as set by socket.setTimeout(). It is undefined if a timeout has not been set.
|
||||
* @since v10.7.0
|
||||
*/
|
||||
readonly timeout?: number | undefined;
|
||||
/**
|
||||
* Half-closes the socket. i.e., it sends a FIN packet. It is possible the
|
||||
* server will still send some data.
|
||||
*
|
||||
* See `writable.end()` for further details.
|
||||
* @since v0.1.90
|
||||
* @param [encoding='utf8'] Only used when data is `string`.
|
||||
* @param callback Optional callback for when the socket is finished.
|
||||
* @return The socket itself.
|
||||
*/
|
||||
end(callback?: () => void): this;
|
||||
end(buffer: Uint8Array | string, callback?: () => void): this;
|
||||
end(str: Uint8Array | string, encoding?: BufferEncoding, callback?: () => void): this;
|
||||
/**
|
||||
* events.EventEmitter
|
||||
* 1. close
|
||||
* 2. connect
|
||||
* 3. data
|
||||
* 4. drain
|
||||
* 5. end
|
||||
* 6. error
|
||||
* 7. lookup
|
||||
* 8. timeout
|
||||
*/
|
||||
addListener(event: string, listener: (...args: any[]) => void): this;
|
||||
addListener(event: 'close', listener: (hadError: boolean) => void): this;
|
||||
addListener(event: 'connect', listener: () => void): this;
|
||||
addListener(event: 'data', listener: (data: Buffer) => void): this;
|
||||
addListener(event: 'drain', listener: () => void): this;
|
||||
addListener(event: 'end', listener: () => void): this;
|
||||
addListener(event: 'error', listener: (err: Error) => void): this;
|
||||
addListener(event: 'lookup', listener: (err: Error, address: string, family: string | number, host: string) => void): this;
|
||||
addListener(event: 'ready', listener: () => void): this;
|
||||
addListener(event: 'timeout', listener: () => void): this;
|
||||
emit(event: string | symbol, ...args: any[]): boolean;
|
||||
emit(event: 'close', hadError: boolean): boolean;
|
||||
emit(event: 'connect'): boolean;
|
||||
emit(event: 'data', data: Buffer): boolean;
|
||||
emit(event: 'drain'): boolean;
|
||||
emit(event: 'end'): boolean;
|
||||
emit(event: 'error', err: Error): boolean;
|
||||
emit(event: 'lookup', err: Error, address: string, family: string | number, host: string): boolean;
|
||||
emit(event: 'ready'): boolean;
|
||||
emit(event: 'timeout'): boolean;
|
||||
on(event: string, listener: (...args: any[]) => void): this;
|
||||
on(event: 'close', listener: (hadError: boolean) => void): this;
|
||||
on(event: 'connect', listener: () => void): this;
|
||||
on(event: 'data', listener: (data: Buffer) => void): this;
|
||||
on(event: 'drain', listener: () => void): this;
|
||||
on(event: 'end', listener: () => void): this;
|
||||
on(event: 'error', listener: (err: Error) => void): this;
|
||||
on(event: 'lookup', listener: (err: Error, address: string, family: string | number, host: string) => void): this;
|
||||
on(event: 'ready', listener: () => void): this;
|
||||
on(event: 'timeout', listener: () => void): this;
|
||||
once(event: string, listener: (...args: any[]) => void): this;
|
||||
once(event: 'close', listener: (hadError: boolean) => void): this;
|
||||
once(event: 'connect', listener: () => void): this;
|
||||
once(event: 'data', listener: (data: Buffer) => void): this;
|
||||
once(event: 'drain', listener: () => void): this;
|
||||
once(event: 'end', listener: () => void): this;
|
||||
once(event: 'error', listener: (err: Error) => void): this;
|
||||
once(event: 'lookup', listener: (err: Error, address: string, family: string | number, host: string) => void): this;
|
||||
once(event: 'ready', listener: () => void): this;
|
||||
once(event: 'timeout', listener: () => void): this;
|
||||
prependListener(event: string, listener: (...args: any[]) => void): this;
|
||||
prependListener(event: 'close', listener: (hadError: boolean) => void): this;
|
||||
prependListener(event: 'connect', listener: () => void): this;
|
||||
prependListener(event: 'data', listener: (data: Buffer) => void): this;
|
||||
prependListener(event: 'drain', listener: () => void): this;
|
||||
prependListener(event: 'end', listener: () => void): this;
|
||||
prependListener(event: 'error', listener: (err: Error) => void): this;
|
||||
prependListener(event: 'lookup', listener: (err: Error, address: string, family: string | number, host: string) => void): this;
|
||||
prependListener(event: 'ready', listener: () => void): this;
|
||||
prependListener(event: 'timeout', listener: () => void): this;
|
||||
prependOnceListener(event: string, listener: (...args: any[]) => void): this;
|
||||
prependOnceListener(event: 'close', listener: (hadError: boolean) => void): this;
|
||||
prependOnceListener(event: 'connect', listener: () => void): this;
|
||||
prependOnceListener(event: 'data', listener: (data: Buffer) => void): this;
|
||||
prependOnceListener(event: 'drain', listener: () => void): this;
|
||||
prependOnceListener(event: 'end', listener: () => void): this;
|
||||
prependOnceListener(event: 'error', listener: (err: Error) => void): this;
|
||||
prependOnceListener(event: 'lookup', listener: (err: Error, address: string, family: string | number, host: string) => void): this;
|
||||
prependOnceListener(event: 'ready', listener: () => void): this;
|
||||
prependOnceListener(event: 'timeout', listener: () => void): this;
|
||||
}
|
||||
interface ListenOptions extends Abortable {
|
||||
port?: number | undefined;
|
||||
host?: string | undefined;
|
||||
backlog?: number | undefined;
|
||||
path?: string | undefined;
|
||||
exclusive?: boolean | undefined;
|
||||
readableAll?: boolean | undefined;
|
||||
writableAll?: boolean | undefined;
|
||||
/**
|
||||
* @default false
|
||||
*/
|
||||
ipv6Only?: boolean | undefined;
|
||||
}
|
||||
interface ServerOpts {
|
||||
/**
|
||||
* Indicates whether half-opened TCP connections are allowed.
|
||||
* @default false
|
||||
*/
|
||||
allowHalfOpen?: boolean | undefined;
|
||||
/**
|
||||
* Indicates whether the socket should be paused on incoming connections.
|
||||
* @default false
|
||||
*/
|
||||
pauseOnConnect?: boolean | undefined;
|
||||
/**
|
||||
* If set to `true`, it disables the use of Nagle's algorithm immediately after a new incoming connection is received.
|
||||
* @default false
|
||||
* @since v16.5.0
|
||||
*/
|
||||
noDelay?: boolean | undefined;
|
||||
/**
|
||||
* If set to `true`, it enables keep-alive functionality on the socket immediately after a new incoming connection is received,
|
||||
* similarly on what is done in `socket.setKeepAlive([enable][, initialDelay])`.
|
||||
* @default false
|
||||
* @since v16.5.0
|
||||
*/
|
||||
keepAlive?: boolean | undefined;
|
||||
/**
|
||||
* If set to a positive number, it sets the initial delay before the first keepalive probe is sent on an idle socket.
|
||||
* @default 0
|
||||
* @since v16.5.0
|
||||
*/
|
||||
keepAliveInitialDelay?: number | undefined;
|
||||
}
|
||||
/**
|
||||
* This class is used to create a TCP or `IPC` server.
|
||||
* @since v0.1.90
|
||||
*/
|
||||
class Server extends EventEmitter {
|
||||
constructor(connectionListener?: (socket: Socket) => void);
|
||||
constructor(options?: ServerOpts, connectionListener?: (socket: Socket) => void);
|
||||
/**
|
||||
* Start a server listening for connections. A `net.Server` can be a TCP or
|
||||
* an `IPC` server depending on what it listens to.
|
||||
*
|
||||
* Possible signatures:
|
||||
*
|
||||
* * `server.listen(handle[, backlog][, callback])`
|
||||
* * `server.listen(options[, callback])`
|
||||
* * `server.listen(path[, backlog][, callback])` for `IPC` servers
|
||||
* * `server.listen([port[, host[, backlog]]][, callback])` for TCP servers
|
||||
*
|
||||
* This function is asynchronous. When the server starts listening, the `'listening'` event will be emitted. The last parameter `callback`will be added as a listener for the `'listening'`
|
||||
* event.
|
||||
*
|
||||
* All `listen()` methods can take a `backlog` parameter to specify the maximum
|
||||
* length of the queue of pending connections. The actual length will be determined
|
||||
* by the OS through sysctl settings such as `tcp_max_syn_backlog` and `somaxconn`on Linux. The default value of this parameter is 511 (not 512).
|
||||
*
|
||||
* All {@link Socket} are set to `SO_REUSEADDR` (see [`socket(7)`](https://man7.org/linux/man-pages/man7/socket.7.html) for
|
||||
* details).
|
||||
*
|
||||
* The `server.listen()` method can be called again if and only if there was an
|
||||
* error during the first `server.listen()` call or `server.close()` has been
|
||||
* called. Otherwise, an `ERR_SERVER_ALREADY_LISTEN` error will be thrown.
|
||||
*
|
||||
* One of the most common errors raised when listening is `EADDRINUSE`.
|
||||
* This happens when another server is already listening on the requested`port`/`path`/`handle`. One way to handle this would be to retry
|
||||
* after a certain amount of time:
|
||||
*
|
||||
* ```js
|
||||
* server.on('error', (e) => {
|
||||
* if (e.code === 'EADDRINUSE') {
|
||||
* console.log('Address in use, retrying...');
|
||||
* setTimeout(() => {
|
||||
* server.close();
|
||||
* server.listen(PORT, HOST);
|
||||
* }, 1000);
|
||||
* }
|
||||
* });
|
||||
* ```
|
||||
*/
|
||||
listen(port?: number, hostname?: string, backlog?: number, listeningListener?: () => void): this;
|
||||
listen(port?: number, hostname?: string, listeningListener?: () => void): this;
|
||||
listen(port?: number, backlog?: number, listeningListener?: () => void): this;
|
||||
listen(port?: number, listeningListener?: () => void): this;
|
||||
listen(path: string, backlog?: number, listeningListener?: () => void): this;
|
||||
listen(path: string, listeningListener?: () => void): this;
|
||||
listen(options: ListenOptions, listeningListener?: () => void): this;
|
||||
listen(handle: any, backlog?: number, listeningListener?: () => void): this;
|
||||
listen(handle: any, listeningListener?: () => void): this;
|
||||
/**
|
||||
* Stops the server from accepting new connections and keeps existing
|
||||
* connections. This function is asynchronous, the server is finally closed
|
||||
* when all connections are ended and the server emits a `'close'` event.
|
||||
* The optional `callback` will be called once the `'close'` event occurs. Unlike
|
||||
* that event, it will be called with an `Error` as its only argument if the server
|
||||
* was not open when it was closed.
|
||||
* @since v0.1.90
|
||||
* @param callback Called when the server is closed.
|
||||
*/
|
||||
close(callback?: (err?: Error) => void): this;
|
||||
/**
|
||||
* Returns the bound `address`, the address `family` name, and `port` of the server
|
||||
* as reported by the operating system if listening on an IP socket
|
||||
* (useful to find which port was assigned when getting an OS-assigned address):`{ port: 12346, family: 'IPv4', address: '127.0.0.1' }`.
|
||||
*
|
||||
* For a server listening on a pipe or Unix domain socket, the name is returned
|
||||
* as a string.
|
||||
*
|
||||
* ```js
|
||||
* const server = net.createServer((socket) => {
|
||||
* socket.end('goodbye\n');
|
||||
* }).on('error', (err) => {
|
||||
* // Handle errors here.
|
||||
* throw err;
|
||||
* });
|
||||
*
|
||||
* // Grab an arbitrary unused port.
|
||||
* server.listen(() => {
|
||||
* console.log('opened server on', server.address());
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* `server.address()` returns `null` before the `'listening'` event has been
|
||||
* emitted or after calling `server.close()`.
|
||||
* @since v0.1.90
|
||||
*/
|
||||
address(): AddressInfo | string | null;
|
||||
/**
|
||||
* Asynchronously get the number of concurrent connections on the server. Works
|
||||
* when sockets were sent to forks.
|
||||
*
|
||||
* Callback should take two arguments `err` and `count`.
|
||||
* @since v0.9.7
|
||||
*/
|
||||
getConnections(cb: (error: Error | null, count: number) => void): void;
|
||||
/**
|
||||
* Opposite of `unref()`, calling `ref()` on a previously `unref`ed server will _not_ let the program exit if it's the only server left (the default behavior).
|
||||
* If the server is `ref`ed calling `ref()` again will have no effect.
|
||||
* @since v0.9.1
|
||||
*/
|
||||
ref(): this;
|
||||
/**
|
||||
* Calling `unref()` on a server will allow the program to exit if this is the only
|
||||
* active server in the event system. If the server is already `unref`ed calling`unref()` again will have no effect.
|
||||
* @since v0.9.1
|
||||
*/
|
||||
unref(): this;
|
||||
/**
|
||||
* Set this property to reject connections when the server's connection count gets
|
||||
* high.
|
||||
*
|
||||
* It is not recommended to use this option once a socket has been sent to a child
|
||||
* with `child_process.fork()`.
|
||||
* @since v0.2.0
|
||||
*/
|
||||
maxConnections: number;
|
||||
connections: number;
|
||||
/**
|
||||
* Indicates whether or not the server is listening for connections.
|
||||
* @since v5.7.0
|
||||
*/
|
||||
listening: boolean;
|
||||
/**
|
||||
* events.EventEmitter
|
||||
* 1. close
|
||||
* 2. connection
|
||||
* 3. error
|
||||
* 4. listening
|
||||
*/
|
||||
addListener(event: string, listener: (...args: any[]) => void): this;
|
||||
addListener(event: 'close', listener: () => void): this;
|
||||
addListener(event: 'connection', listener: (socket: Socket) => void): this;
|
||||
addListener(event: 'error', listener: (err: Error) => void): this;
|
||||
addListener(event: 'listening', listener: () => void): this;
|
||||
emit(event: string | symbol, ...args: any[]): boolean;
|
||||
emit(event: 'close'): boolean;
|
||||
emit(event: 'connection', socket: Socket): boolean;
|
||||
emit(event: 'error', err: Error): boolean;
|
||||
emit(event: 'listening'): boolean;
|
||||
on(event: string, listener: (...args: any[]) => void): this;
|
||||
on(event: 'close', listener: () => void): this;
|
||||
on(event: 'connection', listener: (socket: Socket) => void): this;
|
||||
on(event: 'error', listener: (err: Error) => void): this;
|
||||
on(event: 'listening', listener: () => void): this;
|
||||
once(event: string, listener: (...args: any[]) => void): this;
|
||||
once(event: 'close', listener: () => void): this;
|
||||
once(event: 'connection', listener: (socket: Socket) => void): this;
|
||||
once(event: 'error', listener: (err: Error) => void): this;
|
||||
once(event: 'listening', listener: () => void): this;
|
||||
prependListener(event: string, listener: (...args: any[]) => void): this;
|
||||
prependListener(event: 'close', listener: () => void): this;
|
||||
prependListener(event: 'connection', listener: (socket: Socket) => void): this;
|
||||
prependListener(event: 'error', listener: (err: Error) => void): this;
|
||||
prependListener(event: 'listening', listener: () => void): this;
|
||||
prependOnceListener(event: string, listener: (...args: any[]) => void): this;
|
||||
prependOnceListener(event: 'close', listener: () => void): this;
|
||||
prependOnceListener(event: 'connection', listener: (socket: Socket) => void): this;
|
||||
prependOnceListener(event: 'error', listener: (err: Error) => void): this;
|
||||
prependOnceListener(event: 'listening', listener: () => void): this;
|
||||
}
|
||||
type IPVersion = 'ipv4' | 'ipv6';
|
||||
/**
|
||||
* The `BlockList` object can be used with some network APIs to specify rules for
|
||||
* disabling inbound or outbound access to specific IP addresses, IP ranges, or
|
||||
* IP subnets.
|
||||
* @since v15.0.0, v14.18.0
|
||||
*/
|
||||
class BlockList {
|
||||
/**
|
||||
* Adds a rule to block the given IP address.
|
||||
* @since v15.0.0, v14.18.0
|
||||
* @param address An IPv4 or IPv6 address.
|
||||
* @param [type='ipv4'] Either `'ipv4'` or `'ipv6'`.
|
||||
*/
|
||||
addAddress(address: string, type?: IPVersion): void;
|
||||
addAddress(address: SocketAddress): void;
|
||||
/**
|
||||
* Adds a rule to block a range of IP addresses from `start` (inclusive) to`end` (inclusive).
|
||||
* @since v15.0.0, v14.18.0
|
||||
* @param start The starting IPv4 or IPv6 address in the range.
|
||||
* @param end The ending IPv4 or IPv6 address in the range.
|
||||
* @param [type='ipv4'] Either `'ipv4'` or `'ipv6'`.
|
||||
*/
|
||||
addRange(start: string, end: string, type?: IPVersion): void;
|
||||
addRange(start: SocketAddress, end: SocketAddress): void;
|
||||
/**
|
||||
* Adds a rule to block a range of IP addresses specified as a subnet mask.
|
||||
* @since v15.0.0, v14.18.0
|
||||
* @param net The network IPv4 or IPv6 address.
|
||||
* @param prefix The number of CIDR prefix bits. For IPv4, this must be a value between `0` and `32`. For IPv6, this must be between `0` and `128`.
|
||||
* @param [type='ipv4'] Either `'ipv4'` or `'ipv6'`.
|
||||
*/
|
||||
addSubnet(net: SocketAddress, prefix: number): void;
|
||||
addSubnet(net: string, prefix: number, type?: IPVersion): void;
|
||||
/**
|
||||
* Returns `true` if the given IP address matches any of the rules added to the`BlockList`.
|
||||
*
|
||||
* ```js
|
||||
* const blockList = new net.BlockList();
|
||||
* blockList.addAddress('123.123.123.123');
|
||||
* blockList.addRange('10.0.0.1', '10.0.0.10');
|
||||
* blockList.addSubnet('8592:757c:efae:4e45::', 64, 'ipv6');
|
||||
*
|
||||
* console.log(blockList.check('123.123.123.123')); // Prints: true
|
||||
* console.log(blockList.check('10.0.0.3')); // Prints: true
|
||||
* console.log(blockList.check('222.111.111.222')); // Prints: false
|
||||
*
|
||||
* // IPv6 notation for IPv4 addresses works:
|
||||
* console.log(blockList.check('::ffff:7b7b:7b7b', 'ipv6')); // Prints: true
|
||||
* console.log(blockList.check('::ffff:123.123.123.123', 'ipv6')); // Prints: true
|
||||
* ```
|
||||
* @since v15.0.0, v14.18.0
|
||||
* @param address The IP address to check
|
||||
* @param [type='ipv4'] Either `'ipv4'` or `'ipv6'`.
|
||||
*/
|
||||
check(address: SocketAddress): boolean;
|
||||
check(address: string, type?: IPVersion): boolean;
|
||||
}
|
||||
interface TcpNetConnectOpts extends TcpSocketConnectOpts, SocketConstructorOpts {
|
||||
timeout?: number | undefined;
|
||||
}
|
||||
interface IpcNetConnectOpts extends IpcSocketConnectOpts, SocketConstructorOpts {
|
||||
timeout?: number | undefined;
|
||||
}
|
||||
type NetConnectOpts = TcpNetConnectOpts | IpcNetConnectOpts;
|
||||
/**
|
||||
* Creates a new TCP or `IPC` server.
|
||||
*
|
||||
* If `allowHalfOpen` is set to `true`, when the other end of the socket
|
||||
* signals the end of transmission, the server will only send back the end of
|
||||
* transmission when `socket.end()` is explicitly called. For example, in the
|
||||
* context of TCP, when a FIN packed is received, a FIN packed is sent
|
||||
* back only when `socket.end()` is explicitly called. Until then the
|
||||
* connection is half-closed (non-readable but still writable). See `'end'` event and [RFC 1122](https://tools.ietf.org/html/rfc1122) (section 4.2.2.13) for more information.
|
||||
*
|
||||
* If `pauseOnConnect` is set to `true`, then the socket associated with each
|
||||
* incoming connection will be paused, and no data will be read from its handle.
|
||||
* This allows connections to be passed between processes without any data being
|
||||
* read by the original process. To begin reading data from a paused socket, call `socket.resume()`.
|
||||
*
|
||||
* The server can be a TCP server or an `IPC` server, depending on what it `listen()` to.
|
||||
*
|
||||
* Here is an example of a TCP echo server which listens for connections
|
||||
* on port 8124:
|
||||
*
|
||||
* ```js
|
||||
* const net = require('net');
|
||||
* const server = net.createServer((c) => {
|
||||
* // 'connection' listener.
|
||||
* console.log('client connected');
|
||||
* c.on('end', () => {
|
||||
* console.log('client disconnected');
|
||||
* });
|
||||
* c.write('hello\r\n');
|
||||
* c.pipe(c);
|
||||
* });
|
||||
* server.on('error', (err) => {
|
||||
* throw err;
|
||||
* });
|
||||
* server.listen(8124, () => {
|
||||
* console.log('server bound');
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* Test this by using `telnet`:
|
||||
*
|
||||
* ```console
|
||||
* $ telnet localhost 8124
|
||||
* ```
|
||||
*
|
||||
* To listen on the socket `/tmp/echo.sock`:
|
||||
*
|
||||
* ```js
|
||||
* server.listen('/tmp/echo.sock', () => {
|
||||
* console.log('server bound');
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* Use `nc` to connect to a Unix domain socket server:
|
||||
*
|
||||
* ```console
|
||||
* $ nc -U /tmp/echo.sock
|
||||
* ```
|
||||
* @since v0.5.0
|
||||
* @param connectionListener Automatically set as a listener for the {@link 'connection'} event.
|
||||
*/
|
||||
function createServer(connectionListener?: (socket: Socket) => void): Server;
|
||||
function createServer(options?: ServerOpts, connectionListener?: (socket: Socket) => void): Server;
|
||||
/**
|
||||
* Aliases to {@link createConnection}.
|
||||
*
|
||||
* Possible signatures:
|
||||
*
|
||||
* * {@link connect}
|
||||
* * {@link connect} for `IPC` connections.
|
||||
* * {@link connect} for TCP connections.
|
||||
*/
|
||||
function connect(options: NetConnectOpts, connectionListener?: () => void): Socket;
|
||||
function connect(port: number, host?: string, connectionListener?: () => void): Socket;
|
||||
function connect(path: string, connectionListener?: () => void): Socket;
|
||||
/**
|
||||
* A factory function, which creates a new {@link Socket},
|
||||
* immediately initiates connection with `socket.connect()`,
|
||||
* then returns the `net.Socket` that starts the connection.
|
||||
*
|
||||
* When the connection is established, a `'connect'` event will be emitted
|
||||
* on the returned socket. The last parameter `connectListener`, if supplied,
|
||||
* will be added as a listener for the `'connect'` event **once**.
|
||||
*
|
||||
* Possible signatures:
|
||||
*
|
||||
* * {@link createConnection}
|
||||
* * {@link createConnection} for `IPC` connections.
|
||||
* * {@link createConnection} for TCP connections.
|
||||
*
|
||||
* The {@link connect} function is an alias to this function.
|
||||
*/
|
||||
function createConnection(options: NetConnectOpts, connectionListener?: () => void): Socket;
|
||||
function createConnection(port: number, host?: string, connectionListener?: () => void): Socket;
|
||||
function createConnection(path: string, connectionListener?: () => void): Socket;
|
||||
/**
|
||||
* Returns `6` if `input` is an IPv6 address. Returns `4` if `input` is an IPv4
|
||||
* address in [dot-decimal notation](https://en.wikipedia.org/wiki/Dot-decimal_notation) with no leading zeroes. Otherwise, returns`0`.
|
||||
*
|
||||
* ```js
|
||||
* net.isIP('::1'); // returns 6
|
||||
* net.isIP('127.0.0.1'); // returns 4
|
||||
* net.isIP('127.000.000.001'); // returns 0
|
||||
* net.isIP('127.0.0.1/24'); // returns 0
|
||||
* net.isIP('fhqwhgads'); // returns 0
|
||||
* ```
|
||||
* @since v0.3.0
|
||||
*/
|
||||
function isIP(input: string): number;
|
||||
/**
|
||||
* Returns `true` if `input` is an IPv4 address in [dot-decimal notation](https://en.wikipedia.org/wiki/Dot-decimal_notation) with no
|
||||
* leading zeroes. Otherwise, returns `false`.
|
||||
*
|
||||
* ```js
|
||||
* net.isIPv4('127.0.0.1'); // returns true
|
||||
* net.isIPv4('127.000.000.001'); // returns false
|
||||
* net.isIPv4('127.0.0.1/24'); // returns false
|
||||
* net.isIPv4('fhqwhgads'); // returns false
|
||||
* ```
|
||||
* @since v0.3.0
|
||||
*/
|
||||
function isIPv4(input: string): boolean;
|
||||
/**
|
||||
* Returns `true` if `input` is an IPv6 address. Otherwise, returns `false`.
|
||||
*
|
||||
* ```js
|
||||
* net.isIPv6('::1'); // returns true
|
||||
* net.isIPv6('fhqwhgads'); // returns false
|
||||
* ```
|
||||
* @since v0.3.0
|
||||
*/
|
||||
function isIPv6(input: string): boolean;
|
||||
interface SocketAddressInitOptions {
|
||||
/**
|
||||
* The network address as either an IPv4 or IPv6 string.
|
||||
* @default 127.0.0.1
|
||||
*/
|
||||
address?: string | undefined;
|
||||
/**
|
||||
* @default `'ipv4'`
|
||||
*/
|
||||
family?: IPVersion | undefined;
|
||||
/**
|
||||
* An IPv6 flow-label used only if `family` is `'ipv6'`.
|
||||
* @default 0
|
||||
*/
|
||||
flowlabel?: number | undefined;
|
||||
/**
|
||||
* An IP port.
|
||||
* @default 0
|
||||
*/
|
||||
port?: number | undefined;
|
||||
}
|
||||
/**
|
||||
* @since v15.14.0, v14.18.0
|
||||
*/
|
||||
class SocketAddress {
|
||||
constructor(options: SocketAddressInitOptions);
|
||||
/**
|
||||
* Either \`'ipv4'\` or \`'ipv6'\`.
|
||||
* @since v15.14.0, v14.18.0
|
||||
*/
|
||||
readonly address: string;
|
||||
/**
|
||||
* Either \`'ipv4'\` or \`'ipv6'\`.
|
||||
* @since v15.14.0, v14.18.0
|
||||
*/
|
||||
readonly family: IPVersion;
|
||||
/**
|
||||
* @since v15.14.0, v14.18.0
|
||||
*/
|
||||
readonly port: number;
|
||||
/**
|
||||
* @since v15.14.0, v14.18.0
|
||||
*/
|
||||
readonly flowlabel: number;
|
||||
}
|
||||
}
|
||||
declare module 'node:net' {
|
||||
export * from 'net';
|
||||
}
|
@ -0,0 +1,456 @@
|
||||
/**
|
||||
* The `os` module provides operating system-related utility methods and
|
||||
* properties. It can be accessed using:
|
||||
*
|
||||
* ```js
|
||||
* const os = require('os');
|
||||
* ```
|
||||
* @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/os.js)
|
||||
*/
|
||||
declare module 'os' {
|
||||
interface CpuInfo {
|
||||
model: string;
|
||||
speed: number;
|
||||
times: {
|
||||
user: number;
|
||||
nice: number;
|
||||
sys: number;
|
||||
idle: number;
|
||||
irq: number;
|
||||
};
|
||||
}
|
||||
interface NetworkInterfaceBase {
|
||||
address: string;
|
||||
netmask: string;
|
||||
mac: string;
|
||||
internal: boolean;
|
||||
cidr: string | null;
|
||||
}
|
||||
interface NetworkInterfaceInfoIPv4 extends NetworkInterfaceBase {
|
||||
family: 'IPv4';
|
||||
}
|
||||
interface NetworkInterfaceInfoIPv6 extends NetworkInterfaceBase {
|
||||
family: 'IPv6';
|
||||
scopeid: number;
|
||||
}
|
||||
interface UserInfo<T> {
|
||||
username: T;
|
||||
uid: number;
|
||||
gid: number;
|
||||
shell: T;
|
||||
homedir: T;
|
||||
}
|
||||
type NetworkInterfaceInfo = NetworkInterfaceInfoIPv4 | NetworkInterfaceInfoIPv6;
|
||||
/**
|
||||
* Returns the host name of the operating system as a string.
|
||||
* @since v0.3.3
|
||||
*/
|
||||
function hostname(): string;
|
||||
/**
|
||||
* Returns an array containing the 1, 5, and 15 minute load averages.
|
||||
*
|
||||
* The load average is a measure of system activity calculated by the operating
|
||||
* system and expressed as a fractional number.
|
||||
*
|
||||
* The load average is a Unix-specific concept. On Windows, the return value is
|
||||
* always `[0, 0, 0]`.
|
||||
* @since v0.3.3
|
||||
*/
|
||||
function loadavg(): number[];
|
||||
/**
|
||||
* Returns the system uptime in number of seconds.
|
||||
* @since v0.3.3
|
||||
*/
|
||||
function uptime(): number;
|
||||
/**
|
||||
* Returns the amount of free system memory in bytes as an integer.
|
||||
* @since v0.3.3
|
||||
*/
|
||||
function freemem(): number;
|
||||
/**
|
||||
* Returns the total amount of system memory in bytes as an integer.
|
||||
* @since v0.3.3
|
||||
*/
|
||||
function totalmem(): number;
|
||||
/**
|
||||
* Returns an array of objects containing information about each logical CPU core.
|
||||
*
|
||||
* The properties included on each object include:
|
||||
*
|
||||
* ```js
|
||||
* [
|
||||
* {
|
||||
* model: 'Intel(R) Core(TM) i7 CPU 860 @ 2.80GHz',
|
||||
* speed: 2926,
|
||||
* times: {
|
||||
* user: 252020,
|
||||
* nice: 0,
|
||||
* sys: 30340,
|
||||
* idle: 1070356870,
|
||||
* irq: 0
|
||||
* }
|
||||
* },
|
||||
* {
|
||||
* model: 'Intel(R) Core(TM) i7 CPU 860 @ 2.80GHz',
|
||||
* speed: 2926,
|
||||
* times: {
|
||||
* user: 306960,
|
||||
* nice: 0,
|
||||
* sys: 26980,
|
||||
* idle: 1071569080,
|
||||
* irq: 0
|
||||
* }
|
||||
* },
|
||||
* {
|
||||
* model: 'Intel(R) Core(TM) i7 CPU 860 @ 2.80GHz',
|
||||
* speed: 2926,
|
||||
* times: {
|
||||
* user: 248450,
|
||||
* nice: 0,
|
||||
* sys: 21750,
|
||||
* idle: 1070919370,
|
||||
* irq: 0
|
||||
* }
|
||||
* },
|
||||
* {
|
||||
* model: 'Intel(R) Core(TM) i7 CPU 860 @ 2.80GHz',
|
||||
* speed: 2926,
|
||||
* times: {
|
||||
* user: 256880,
|
||||
* nice: 0,
|
||||
* sys: 19430,
|
||||
* idle: 1070905480,
|
||||
* irq: 20
|
||||
* }
|
||||
* },
|
||||
* ]
|
||||
* ```
|
||||
*
|
||||
* `nice` values are POSIX-only. On Windows, the `nice` values of all processors
|
||||
* are always 0.
|
||||
* @since v0.3.3
|
||||
*/
|
||||
function cpus(): CpuInfo[];
|
||||
/**
|
||||
* Returns the operating system name as returned by [`uname(3)`](https://linux.die.net/man/3/uname). For example, it
|
||||
* returns `'Linux'` on Linux, `'Darwin'` on macOS, and `'Windows_NT'` on Windows.
|
||||
*
|
||||
* See [https://en.wikipedia.org/wiki/Uname#Examples](https://en.wikipedia.org/wiki/Uname#Examples) for additional information
|
||||
* about the output of running [`uname(3)`](https://linux.die.net/man/3/uname) on various operating systems.
|
||||
* @since v0.3.3
|
||||
*/
|
||||
function type(): string;
|
||||
/**
|
||||
* Returns the operating system as a string.
|
||||
*
|
||||
* On POSIX systems, the operating system release is determined by calling [`uname(3)`](https://linux.die.net/man/3/uname). On Windows, `GetVersionExW()` is used. See
|
||||
* [https://en.wikipedia.org/wiki/Uname#Examples](https://en.wikipedia.org/wiki/Uname#Examples) for more information.
|
||||
* @since v0.3.3
|
||||
*/
|
||||
function release(): string;
|
||||
/**
|
||||
* Returns an object containing network interfaces that have been assigned a
|
||||
* network address.
|
||||
*
|
||||
* Each key on the returned object identifies a network interface. The associated
|
||||
* value is an array of objects that each describe an assigned network address.
|
||||
*
|
||||
* The properties available on the assigned network address object include:
|
||||
*
|
||||
* ```js
|
||||
* {
|
||||
* lo: [
|
||||
* {
|
||||
* address: '127.0.0.1',
|
||||
* netmask: '255.0.0.0',
|
||||
* family: 'IPv4',
|
||||
* mac: '00:00:00:00:00:00',
|
||||
* internal: true,
|
||||
* cidr: '127.0.0.1/8'
|
||||
* },
|
||||
* {
|
||||
* address: '::1',
|
||||
* netmask: 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff',
|
||||
* family: 'IPv6',
|
||||
* mac: '00:00:00:00:00:00',
|
||||
* scopeid: 0,
|
||||
* internal: true,
|
||||
* cidr: '::1/128'
|
||||
* }
|
||||
* ],
|
||||
* eth0: [
|
||||
* {
|
||||
* address: '192.168.1.108',
|
||||
* netmask: '255.255.255.0',
|
||||
* family: 'IPv4',
|
||||
* mac: '01:02:03:0a:0b:0c',
|
||||
* internal: false,
|
||||
* cidr: '192.168.1.108/24'
|
||||
* },
|
||||
* {
|
||||
* address: 'fe80::a00:27ff:fe4e:66a1',
|
||||
* netmask: 'ffff:ffff:ffff:ffff::',
|
||||
* family: 'IPv6',
|
||||
* mac: '01:02:03:0a:0b:0c',
|
||||
* scopeid: 1,
|
||||
* internal: false,
|
||||
* cidr: 'fe80::a00:27ff:fe4e:66a1/64'
|
||||
* }
|
||||
* ]
|
||||
* }
|
||||
* ```
|
||||
* @since v0.6.0
|
||||
*/
|
||||
function networkInterfaces(): NodeJS.Dict<NetworkInterfaceInfo[]>;
|
||||
/**
|
||||
* Returns the string path of the current user's home directory.
|
||||
*
|
||||
* On POSIX, it uses the `$HOME` environment variable if defined. Otherwise it
|
||||
* uses the [effective UID](https://en.wikipedia.org/wiki/User_identifier#Effective_user_ID) to look up the user's home directory.
|
||||
*
|
||||
* On Windows, it uses the `USERPROFILE` environment variable if defined.
|
||||
* Otherwise it uses the path to the profile directory of the current user.
|
||||
* @since v2.3.0
|
||||
*/
|
||||
function homedir(): string;
|
||||
/**
|
||||
* Returns information about the currently effective user. On POSIX platforms,
|
||||
* this is typically a subset of the password file. The returned object includes
|
||||
* the `username`, `uid`, `gid`, `shell`, and `homedir`. On Windows, the `uid` and`gid` fields are `-1`, and `shell` is `null`.
|
||||
*
|
||||
* The value of `homedir` returned by `os.userInfo()` is provided by the operating
|
||||
* system. This differs from the result of `os.homedir()`, which queries
|
||||
* environment variables for the home directory before falling back to the
|
||||
* operating system response.
|
||||
*
|
||||
* Throws a `SystemError` if a user has no `username` or `homedir`.
|
||||
* @since v6.0.0
|
||||
*/
|
||||
function userInfo(options: { encoding: 'buffer' }): UserInfo<Buffer>;
|
||||
function userInfo(options?: { encoding: BufferEncoding }): UserInfo<string>;
|
||||
type SignalConstants = {
|
||||
[key in NodeJS.Signals]: number;
|
||||
};
|
||||
namespace constants {
|
||||
const UV_UDP_REUSEADDR: number;
|
||||
namespace signals {}
|
||||
const signals: SignalConstants;
|
||||
namespace errno {
|
||||
const E2BIG: number;
|
||||
const EACCES: number;
|
||||
const EADDRINUSE: number;
|
||||
const EADDRNOTAVAIL: number;
|
||||
const EAFNOSUPPORT: number;
|
||||
const EAGAIN: number;
|
||||
const EALREADY: number;
|
||||
const EBADF: number;
|
||||
const EBADMSG: number;
|
||||
const EBUSY: number;
|
||||
const ECANCELED: number;
|
||||
const ECHILD: number;
|
||||
const ECONNABORTED: number;
|
||||
const ECONNREFUSED: number;
|
||||
const ECONNRESET: number;
|
||||
const EDEADLK: number;
|
||||
const EDESTADDRREQ: number;
|
||||
const EDOM: number;
|
||||
const EDQUOT: number;
|
||||
const EEXIST: number;
|
||||
const EFAULT: number;
|
||||
const EFBIG: number;
|
||||
const EHOSTUNREACH: number;
|
||||
const EIDRM: number;
|
||||
const EILSEQ: number;
|
||||
const EINPROGRESS: number;
|
||||
const EINTR: number;
|
||||
const EINVAL: number;
|
||||
const EIO: number;
|
||||
const EISCONN: number;
|
||||
const EISDIR: number;
|
||||
const ELOOP: number;
|
||||
const EMFILE: number;
|
||||
const EMLINK: number;
|
||||
const EMSGSIZE: number;
|
||||
const EMULTIHOP: number;
|
||||
const ENAMETOOLONG: number;
|
||||
const ENETDOWN: number;
|
||||
const ENETRESET: number;
|
||||
const ENETUNREACH: number;
|
||||
const ENFILE: number;
|
||||
const ENOBUFS: number;
|
||||
const ENODATA: number;
|
||||
const ENODEV: number;
|
||||
const ENOENT: number;
|
||||
const ENOEXEC: number;
|
||||
const ENOLCK: number;
|
||||
const ENOLINK: number;
|
||||
const ENOMEM: number;
|
||||
const ENOMSG: number;
|
||||
const ENOPROTOOPT: number;
|
||||
const ENOSPC: number;
|
||||
const ENOSR: number;
|
||||
const ENOSTR: number;
|
||||
const ENOSYS: number;
|
||||
const ENOTCONN: number;
|
||||
const ENOTDIR: number;
|
||||
const ENOTEMPTY: number;
|
||||
const ENOTSOCK: number;
|
||||
const ENOTSUP: number;
|
||||
const ENOTTY: number;
|
||||
const ENXIO: number;
|
||||
const EOPNOTSUPP: number;
|
||||
const EOVERFLOW: number;
|
||||
const EPERM: number;
|
||||
const EPIPE: number;
|
||||
const EPROTO: number;
|
||||
const EPROTONOSUPPORT: number;
|
||||
const EPROTOTYPE: number;
|
||||
const ERANGE: number;
|
||||
const EROFS: number;
|
||||
const ESPIPE: number;
|
||||
const ESRCH: number;
|
||||
const ESTALE: number;
|
||||
const ETIME: number;
|
||||
const ETIMEDOUT: number;
|
||||
const ETXTBSY: number;
|
||||
const EWOULDBLOCK: number;
|
||||
const EXDEV: number;
|
||||
const WSAEINTR: number;
|
||||
const WSAEBADF: number;
|
||||
const WSAEACCES: number;
|
||||
const WSAEFAULT: number;
|
||||
const WSAEINVAL: number;
|
||||
const WSAEMFILE: number;
|
||||
const WSAEWOULDBLOCK: number;
|
||||
const WSAEINPROGRESS: number;
|
||||
const WSAEALREADY: number;
|
||||
const WSAENOTSOCK: number;
|
||||
const WSAEDESTADDRREQ: number;
|
||||
const WSAEMSGSIZE: number;
|
||||
const WSAEPROTOTYPE: number;
|
||||
const WSAENOPROTOOPT: number;
|
||||
const WSAEPROTONOSUPPORT: number;
|
||||
const WSAESOCKTNOSUPPORT: number;
|
||||
const WSAEOPNOTSUPP: number;
|
||||
const WSAEPFNOSUPPORT: number;
|
||||
const WSAEAFNOSUPPORT: number;
|
||||
const WSAEADDRINUSE: number;
|
||||
const WSAEADDRNOTAVAIL: number;
|
||||
const WSAENETDOWN: number;
|
||||
const WSAENETUNREACH: number;
|
||||
const WSAENETRESET: number;
|
||||
const WSAECONNABORTED: number;
|
||||
const WSAECONNRESET: number;
|
||||
const WSAENOBUFS: number;
|
||||
const WSAEISCONN: number;
|
||||
const WSAENOTCONN: number;
|
||||
const WSAESHUTDOWN: number;
|
||||
const WSAETOOMANYREFS: number;
|
||||
const WSAETIMEDOUT: number;
|
||||
const WSAECONNREFUSED: number;
|
||||
const WSAELOOP: number;
|
||||
const WSAENAMETOOLONG: number;
|
||||
const WSAEHOSTDOWN: number;
|
||||
const WSAEHOSTUNREACH: number;
|
||||
const WSAENOTEMPTY: number;
|
||||
const WSAEPROCLIM: number;
|
||||
const WSAEUSERS: number;
|
||||
const WSAEDQUOT: number;
|
||||
const WSAESTALE: number;
|
||||
const WSAEREMOTE: number;
|
||||
const WSASYSNOTREADY: number;
|
||||
const WSAVERNOTSUPPORTED: number;
|
||||
const WSANOTINITIALISED: number;
|
||||
const WSAEDISCON: number;
|
||||
const WSAENOMORE: number;
|
||||
const WSAECANCELLED: number;
|
||||
const WSAEINVALIDPROCTABLE: number;
|
||||
const WSAEINVALIDPROVIDER: number;
|
||||
const WSAEPROVIDERFAILEDINIT: number;
|
||||
const WSASYSCALLFAILURE: number;
|
||||
const WSASERVICE_NOT_FOUND: number;
|
||||
const WSATYPE_NOT_FOUND: number;
|
||||
const WSA_E_NO_MORE: number;
|
||||
const WSA_E_CANCELLED: number;
|
||||
const WSAEREFUSED: number;
|
||||
}
|
||||
namespace priority {
|
||||
const PRIORITY_LOW: number;
|
||||
const PRIORITY_BELOW_NORMAL: number;
|
||||
const PRIORITY_NORMAL: number;
|
||||
const PRIORITY_ABOVE_NORMAL: number;
|
||||
const PRIORITY_HIGH: number;
|
||||
const PRIORITY_HIGHEST: number;
|
||||
}
|
||||
}
|
||||
const devNull: string;
|
||||
const EOL: string;
|
||||
/**
|
||||
* Returns the operating system CPU architecture for which the Node.js binary was
|
||||
* compiled. Possible values are `'arm'`, `'arm64'`, `'ia32'`, `'mips'`,`'mipsel'`, `'ppc'`, `'ppc64'`, `'s390'`, `'s390x'`, and `'x64'`.
|
||||
*
|
||||
* The return value is equivalent to `process.arch`.
|
||||
* @since v0.5.0
|
||||
*/
|
||||
function arch(): string;
|
||||
/**
|
||||
* Returns a string identifying the kernel version.
|
||||
*
|
||||
* On POSIX systems, the operating system release is determined by calling [`uname(3)`](https://linux.die.net/man/3/uname). On Windows, `RtlGetVersion()` is used, and if it is not
|
||||
* available, `GetVersionExW()` will be used. See [https://en.wikipedia.org/wiki/Uname#Examples](https://en.wikipedia.org/wiki/Uname#Examples) for more information.
|
||||
* @since v13.11.0, v12.17.0
|
||||
*/
|
||||
function version(): string;
|
||||
/**
|
||||
* Returns a string identifying the operating system platform for which
|
||||
* the Node.js binary was compiled. The value is set at compile time.
|
||||
* Possible values are `'aix'`, `'darwin'`, `'freebsd'`,`'linux'`,`'openbsd'`, `'sunos'`, and `'win32'`.
|
||||
*
|
||||
* The return value is equivalent to `process.platform`.
|
||||
*
|
||||
* The value `'android'` may also be returned if Node.js is built on the Android
|
||||
* operating system. [Android support is experimental](https://github.com/nodejs/node/blob/HEAD/BUILDING.md#androidandroid-based-devices-eg-firefox-os).
|
||||
* @since v0.5.0
|
||||
*/
|
||||
function platform(): NodeJS.Platform;
|
||||
/**
|
||||
* Returns the operating system's default directory for temporary files as a
|
||||
* string.
|
||||
* @since v0.9.9
|
||||
*/
|
||||
function tmpdir(): string;
|
||||
/**
|
||||
* Returns a string identifying the endianness of the CPU for which the Node.js
|
||||
* binary was compiled.
|
||||
*
|
||||
* Possible values are `'BE'` for big endian and `'LE'` for little endian.
|
||||
* @since v0.9.4
|
||||
*/
|
||||
function endianness(): 'BE' | 'LE';
|
||||
/**
|
||||
* Returns the scheduling priority for the process specified by `pid`. If `pid` is
|
||||
* not provided or is `0`, the priority of the current process is returned.
|
||||
* @since v10.10.0
|
||||
* @param [pid=0] The process ID to retrieve scheduling priority for.
|
||||
*/
|
||||
function getPriority(pid?: number): number;
|
||||
/**
|
||||
* Attempts to set the scheduling priority for the process specified by `pid`. If`pid` is not provided or is `0`, the process ID of the current process is used.
|
||||
*
|
||||
* The `priority` input must be an integer between `-20` (high priority) and `19`(low priority). Due to differences between Unix priority levels and Windows
|
||||
* priority classes, `priority` is mapped to one of six priority constants in`os.constants.priority`. When retrieving a process priority level, this range
|
||||
* mapping may cause the return value to be slightly different on Windows. To avoid
|
||||
* confusion, set `priority` to one of the priority constants.
|
||||
*
|
||||
* On Windows, setting priority to `PRIORITY_HIGHEST` requires elevated user
|
||||
* privileges. Otherwise the set priority will be silently reduced to`PRIORITY_HIGH`.
|
||||
* @since v10.10.0
|
||||
* @param [pid=0] The process ID to set scheduling priority for.
|
||||
* @param priority The scheduling priority to assign to the process.
|
||||
*/
|
||||
function setPriority(priority: number): void;
|
||||
function setPriority(pid: number, priority: number): void;
|
||||
}
|
||||
declare module 'node:os' {
|
||||
export * from 'os';
|
||||
}
|
@ -0,0 +1,225 @@
|
||||
{
|
||||
"name": "@types/node",
|
||||
"version": "18.7.13",
|
||||
"description": "TypeScript definitions for Node.js",
|
||||
"homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
|
||||
"license": "MIT",
|
||||
"contributors": [
|
||||
{
|
||||
"name": "Microsoft TypeScript",
|
||||
"url": "https://github.com/Microsoft",
|
||||
"githubUsername": "Microsoft"
|
||||
},
|
||||
{
|
||||
"name": "DefinitelyTyped",
|
||||
"url": "https://github.com/DefinitelyTyped",
|
||||
"githubUsername": "DefinitelyTyped"
|
||||
},
|
||||
{
|
||||
"name": "Alberto Schiabel",
|
||||
"url": "https://github.com/jkomyno",
|
||||
"githubUsername": "jkomyno"
|
||||
},
|
||||
{
|
||||
"name": "Alvis HT Tang",
|
||||
"url": "https://github.com/alvis",
|
||||
"githubUsername": "alvis"
|
||||
},
|
||||
{
|
||||
"name": "Andrew Makarov",
|
||||
"url": "https://github.com/r3nya",
|
||||
"githubUsername": "r3nya"
|
||||
},
|
||||
{
|
||||
"name": "Benjamin Toueg",
|
||||
"url": "https://github.com/btoueg",
|
||||
"githubUsername": "btoueg"
|
||||
},
|
||||
{
|
||||
"name": "Chigozirim C.",
|
||||
"url": "https://github.com/smac89",
|
||||
"githubUsername": "smac89"
|
||||
},
|
||||
{
|
||||
"name": "David Junger",
|
||||
"url": "https://github.com/touffy",
|
||||
"githubUsername": "touffy"
|
||||
},
|
||||
{
|
||||
"name": "Deividas Bakanas",
|
||||
"url": "https://github.com/DeividasBakanas",
|
||||
"githubUsername": "DeividasBakanas"
|
||||
},
|
||||
{
|
||||
"name": "Eugene Y. Q. Shen",
|
||||
"url": "https://github.com/eyqs",
|
||||
"githubUsername": "eyqs"
|
||||
},
|
||||
{
|
||||
"name": "Hannes Magnusson",
|
||||
"url": "https://github.com/Hannes-Magnusson-CK",
|
||||
"githubUsername": "Hannes-Magnusson-CK"
|
||||
},
|
||||
{
|
||||
"name": "Huw",
|
||||
"url": "https://github.com/hoo29",
|
||||
"githubUsername": "hoo29"
|
||||
},
|
||||
{
|
||||
"name": "Kelvin Jin",
|
||||
"url": "https://github.com/kjin",
|
||||
"githubUsername": "kjin"
|
||||
},
|
||||
{
|
||||
"name": "Klaus Meinhardt",
|
||||
"url": "https://github.com/ajafff",
|
||||
"githubUsername": "ajafff"
|
||||
},
|
||||
{
|
||||
"name": "Lishude",
|
||||
"url": "https://github.com/islishude",
|
||||
"githubUsername": "islishude"
|
||||
},
|
||||
{
|
||||
"name": "Mariusz Wiktorczyk",
|
||||
"url": "https://github.com/mwiktorczyk",
|
||||
"githubUsername": "mwiktorczyk"
|
||||
},
|
||||
{
|
||||
"name": "Mohsen Azimi",
|
||||
"url": "https://github.com/mohsen1",
|
||||
"githubUsername": "mohsen1"
|
||||
},
|
||||
{
|
||||
"name": "Nicolas Even",
|
||||
"url": "https://github.com/n-e",
|
||||
"githubUsername": "n-e"
|
||||
},
|
||||
{
|
||||
"name": "Nikita Galkin",
|
||||
"url": "https://github.com/galkin",
|
||||
"githubUsername": "galkin"
|
||||
},
|
||||
{
|
||||
"name": "Parambir Singh",
|
||||
"url": "https://github.com/parambirs",
|
||||
"githubUsername": "parambirs"
|
||||
},
|
||||
{
|
||||
"name": "Sebastian Silbermann",
|
||||
"url": "https://github.com/eps1lon",
|
||||
"githubUsername": "eps1lon"
|
||||
},
|
||||
{
|
||||
"name": "Simon Schick",
|
||||
"url": "https://github.com/SimonSchick",
|
||||
"githubUsername": "SimonSchick"
|
||||
},
|
||||
{
|
||||
"name": "Thomas den Hollander",
|
||||
"url": "https://github.com/ThomasdenH",
|
||||
"githubUsername": "ThomasdenH"
|
||||
},
|
||||
{
|
||||
"name": "Wilco Bakker",
|
||||
"url": "https://github.com/WilcoBakker",
|
||||
"githubUsername": "WilcoBakker"
|
||||
},
|
||||
{
|
||||
"name": "wwwy3y3",
|
||||
"url": "https://github.com/wwwy3y3",
|
||||
"githubUsername": "wwwy3y3"
|
||||
},
|
||||
{
|
||||
"name": "Samuel Ainsworth",
|
||||
"url": "https://github.com/samuela",
|
||||
"githubUsername": "samuela"
|
||||
},
|
||||
{
|
||||
"name": "Kyle Uehlein",
|
||||
"url": "https://github.com/kuehlein",
|
||||
"githubUsername": "kuehlein"
|
||||
},
|
||||
{
|
||||
"name": "Thanik Bhongbhibhat",
|
||||
"url": "https://github.com/bhongy",
|
||||
"githubUsername": "bhongy"
|
||||
},
|
||||
{
|
||||
"name": "Marcin Kopacz",
|
||||
"url": "https://github.com/chyzwar",
|
||||
"githubUsername": "chyzwar"
|
||||
},
|
||||
{
|
||||
"name": "Trivikram Kamat",
|
||||
"url": "https://github.com/trivikr",
|
||||
"githubUsername": "trivikr"
|
||||
},
|
||||
{
|
||||
"name": "Junxiao Shi",
|
||||
"url": "https://github.com/yoursunny",
|
||||
"githubUsername": "yoursunny"
|
||||
},
|
||||
{
|
||||
"name": "Ilia Baryshnikov",
|
||||
"url": "https://github.com/qwelias",
|
||||
"githubUsername": "qwelias"
|
||||
},
|
||||
{
|
||||
"name": "ExE Boss",
|
||||
"url": "https://github.com/ExE-Boss",
|
||||
"githubUsername": "ExE-Boss"
|
||||
},
|
||||
{
|
||||
"name": "Piotr Błażejewicz",
|
||||
"url": "https://github.com/peterblazejewicz",
|
||||
"githubUsername": "peterblazejewicz"
|
||||
},
|
||||
{
|
||||
"name": "Anna Henningsen",
|
||||
"url": "https://github.com/addaleax",
|
||||
"githubUsername": "addaleax"
|
||||
},
|
||||
{
|
||||
"name": "Victor Perin",
|
||||
"url": "https://github.com/victorperin",
|
||||
"githubUsername": "victorperin"
|
||||
},
|
||||
{
|
||||
"name": "Yongsheng Zhang",
|
||||
"url": "https://github.com/ZYSzys",
|
||||
"githubUsername": "ZYSzys"
|
||||
},
|
||||
{
|
||||
"name": "NodeJS Contributors",
|
||||
"url": "https://github.com/NodeJS",
|
||||
"githubUsername": "NodeJS"
|
||||
},
|
||||
{
|
||||
"name": "Linus Unnebäck",
|
||||
"url": "https://github.com/LinusU",
|
||||
"githubUsername": "LinusU"
|
||||
},
|
||||
{
|
||||
"name": "wafuwafu13",
|
||||
"url": "https://github.com/wafuwafu13",
|
||||
"githubUsername": "wafuwafu13"
|
||||
},
|
||||
{
|
||||
"name": "Matteo Collina",
|
||||
"url": "https://github.com/mcollina",
|
||||
"githubUsername": "mcollina"
|
||||
}
|
||||
],
|
||||
"main": "",
|
||||
"types": "index.d.ts",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
|
||||
"directory": "types/node"
|
||||
},
|
||||
"scripts": {},
|
||||
"dependencies": {},
|
||||
"typesPublisherContentHash": "25486c39271d0972bf5cd93fe21ef2423a533efc749c47d5f39973be04d2f89a",
|
||||
"typeScriptVersion": "4.0"
|
||||
}
|
@ -0,0 +1,191 @@
|
||||
declare module 'path/posix' {
|
||||
import path = require('path');
|
||||
export = path;
|
||||
}
|
||||
declare module 'path/win32' {
|
||||
import path = require('path');
|
||||
export = path;
|
||||
}
|
||||
/**
|
||||
* The `path` module provides utilities for working with file and directory paths.
|
||||
* It can be accessed using:
|
||||
*
|
||||
* ```js
|
||||
* const path = require('path');
|
||||
* ```
|
||||
* @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/path.js)
|
||||
*/
|
||||
declare module 'path' {
|
||||
namespace path {
|
||||
/**
|
||||
* A parsed path object generated by path.parse() or consumed by path.format().
|
||||
*/
|
||||
interface ParsedPath {
|
||||
/**
|
||||
* The root of the path such as '/' or 'c:\'
|
||||
*/
|
||||
root: string;
|
||||
/**
|
||||
* The full directory path such as '/home/user/dir' or 'c:\path\dir'
|
||||
*/
|
||||
dir: string;
|
||||
/**
|
||||
* The file name including extension (if any) such as 'index.html'
|
||||
*/
|
||||
base: string;
|
||||
/**
|
||||
* The file extension (if any) such as '.html'
|
||||
*/
|
||||
ext: string;
|
||||
/**
|
||||
* The file name without extension (if any) such as 'index'
|
||||
*/
|
||||
name: string;
|
||||
}
|
||||
interface FormatInputPathObject {
|
||||
/**
|
||||
* The root of the path such as '/' or 'c:\'
|
||||
*/
|
||||
root?: string | undefined;
|
||||
/**
|
||||
* The full directory path such as '/home/user/dir' or 'c:\path\dir'
|
||||
*/
|
||||
dir?: string | undefined;
|
||||
/**
|
||||
* The file name including extension (if any) such as 'index.html'
|
||||
*/
|
||||
base?: string | undefined;
|
||||
/**
|
||||
* The file extension (if any) such as '.html'
|
||||
*/
|
||||
ext?: string | undefined;
|
||||
/**
|
||||
* The file name without extension (if any) such as 'index'
|
||||
*/
|
||||
name?: string | undefined;
|
||||
}
|
||||
interface PlatformPath {
|
||||
/**
|
||||
* Normalize a string path, reducing '..' and '.' parts.
|
||||
* When multiple slashes are found, they're replaced by a single one; when the path contains a trailing slash, it is preserved. On Windows backslashes are used.
|
||||
*
|
||||
* @param path string path to normalize.
|
||||
* @throws {TypeError} if `path` is not a string.
|
||||
*/
|
||||
normalize(path: string): string;
|
||||
/**
|
||||
* Join all arguments together and normalize the resulting path.
|
||||
*
|
||||
* @param paths paths to join.
|
||||
* @throws {TypeError} if any of the path segments is not a string.
|
||||
*/
|
||||
join(...paths: string[]): string;
|
||||
/**
|
||||
* The right-most parameter is considered {to}. Other parameters are considered an array of {from}.
|
||||
*
|
||||
* Starting from leftmost {from} parameter, resolves {to} to an absolute path.
|
||||
*
|
||||
* If {to} isn't already absolute, {from} arguments are prepended in right to left order,
|
||||
* until an absolute path is found. If after using all {from} paths still no absolute path is found,
|
||||
* the current working directory is used as well. The resulting path is normalized,
|
||||
* and trailing slashes are removed unless the path gets resolved to the root directory.
|
||||
*
|
||||
* @param paths A sequence of paths or path segments.
|
||||
* @throws {TypeError} if any of the arguments is not a string.
|
||||
*/
|
||||
resolve(...paths: string[]): string;
|
||||
/**
|
||||
* Determines whether {path} is an absolute path. An absolute path will always resolve to the same location, regardless of the working directory.
|
||||
*
|
||||
* If the given {path} is a zero-length string, `false` will be returned.
|
||||
*
|
||||
* @param path path to test.
|
||||
* @throws {TypeError} if `path` is not a string.
|
||||
*/
|
||||
isAbsolute(path: string): boolean;
|
||||
/**
|
||||
* Solve the relative path from {from} to {to} based on the current working directory.
|
||||
* At times we have two absolute paths, and we need to derive the relative path from one to the other. This is actually the reverse transform of path.resolve.
|
||||
*
|
||||
* @throws {TypeError} if either `from` or `to` is not a string.
|
||||
*/
|
||||
relative(from: string, to: string): string;
|
||||
/**
|
||||
* Return the directory name of a path. Similar to the Unix dirname command.
|
||||
*
|
||||
* @param path the path to evaluate.
|
||||
* @throws {TypeError} if `path` is not a string.
|
||||
*/
|
||||
dirname(path: string): string;
|
||||
/**
|
||||
* Return the last portion of a path. Similar to the Unix basename command.
|
||||
* Often used to extract the file name from a fully qualified path.
|
||||
*
|
||||
* @param path the path to evaluate.
|
||||
* @param ext optionally, an extension to remove from the result.
|
||||
* @throws {TypeError} if `path` is not a string or if `ext` is given and is not a string.
|
||||
*/
|
||||
basename(path: string, ext?: string): string;
|
||||
/**
|
||||
* Return the extension of the path, from the last '.' to end of string in the last portion of the path.
|
||||
* If there is no '.' in the last portion of the path or the first character of it is '.', then it returns an empty string.
|
||||
*
|
||||
* @param path the path to evaluate.
|
||||
* @throws {TypeError} if `path` is not a string.
|
||||
*/
|
||||
extname(path: string): string;
|
||||
/**
|
||||
* The platform-specific file separator. '\\' or '/'.
|
||||
*/
|
||||
readonly sep: string;
|
||||
/**
|
||||
* The platform-specific file delimiter. ';' or ':'.
|
||||
*/
|
||||
readonly delimiter: string;
|
||||
/**
|
||||
* Returns an object from a path string - the opposite of format().
|
||||
*
|
||||
* @param path path to evaluate.
|
||||
* @throws {TypeError} if `path` is not a string.
|
||||
*/
|
||||
parse(path: string): ParsedPath;
|
||||
/**
|
||||
* Returns a path string from an object - the opposite of parse().
|
||||
*
|
||||
* @param pathObject path to evaluate.
|
||||
*/
|
||||
format(pathObject: FormatInputPathObject): string;
|
||||
/**
|
||||
* On Windows systems only, returns an equivalent namespace-prefixed path for the given path.
|
||||
* If path is not a string, path will be returned without modifications.
|
||||
* This method is meaningful only on Windows system.
|
||||
* On POSIX systems, the method is non-operational and always returns path without modifications.
|
||||
*/
|
||||
toNamespacedPath(path: string): string;
|
||||
/**
|
||||
* Posix specific pathing.
|
||||
* Same as parent object on posix.
|
||||
*/
|
||||
readonly posix: PlatformPath;
|
||||
/**
|
||||
* Windows specific pathing.
|
||||
* Same as parent object on windows
|
||||
*/
|
||||
readonly win32: PlatformPath;
|
||||
}
|
||||
}
|
||||
const path: path.PlatformPath;
|
||||
export = path;
|
||||
}
|
||||
declare module 'node:path' {
|
||||
import path = require('path');
|
||||
export = path;
|
||||
}
|
||||
declare module 'node:path/posix' {
|
||||
import path = require('path/posix');
|
||||
export = path;
|
||||
}
|
||||
declare module 'node:path/win32' {
|
||||
import path = require('path/win32');
|
||||
export = path;
|
||||
}
|
610
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/perf_hooks.d.ts
generated
vendored
610
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/perf_hooks.d.ts
generated
vendored
@ -0,0 +1,610 @@
|
||||
/**
|
||||
* This module provides an implementation of a subset of the W3C [Web Performance APIs](https://w3c.github.io/perf-timing-primer/) as well as additional APIs for
|
||||
* Node.js-specific performance measurements.
|
||||
*
|
||||
* Node.js supports the following [Web Performance APIs](https://w3c.github.io/perf-timing-primer/):
|
||||
*
|
||||
* * [High Resolution Time](https://www.w3.org/TR/hr-time-2)
|
||||
* * [Performance Timeline](https://w3c.github.io/performance-timeline/)
|
||||
* * [User Timing](https://www.w3.org/TR/user-timing/)
|
||||
*
|
||||
* ```js
|
||||
* const { PerformanceObserver, performance } = require('perf_hooks');
|
||||
*
|
||||
* const obs = new PerformanceObserver((items) => {
|
||||
* console.log(items.getEntries()[0].duration);
|
||||
* performance.clearMarks();
|
||||
* });
|
||||
* obs.observe({ type: 'measure' });
|
||||
* performance.measure('Start to Now');
|
||||
*
|
||||
* performance.mark('A');
|
||||
* doSomeLongRunningProcess(() => {
|
||||
* performance.measure('A to Now', 'A');
|
||||
*
|
||||
* performance.mark('B');
|
||||
* performance.measure('A to B', 'A', 'B');
|
||||
* });
|
||||
* ```
|
||||
* @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/perf_hooks.js)
|
||||
*/
|
||||
declare module 'perf_hooks' {
|
||||
import { AsyncResource } from 'node:async_hooks';
|
||||
type EntryType = 'node' | 'mark' | 'measure' | 'gc' | 'function' | 'http2' | 'http';
|
||||
interface NodeGCPerformanceDetail {
|
||||
/**
|
||||
* When `performanceEntry.entryType` is equal to 'gc', `the performance.kind` property identifies
|
||||
* the type of garbage collection operation that occurred.
|
||||
* See perf_hooks.constants for valid values.
|
||||
*/
|
||||
readonly kind?: number | undefined;
|
||||
/**
|
||||
* When `performanceEntry.entryType` is equal to 'gc', the `performance.flags`
|
||||
* property contains additional information about garbage collection operation.
|
||||
* See perf_hooks.constants for valid values.
|
||||
*/
|
||||
readonly flags?: number | undefined;
|
||||
}
|
||||
/**
|
||||
* @since v8.5.0
|
||||
*/
|
||||
class PerformanceEntry {
|
||||
protected constructor();
|
||||
/**
|
||||
* The total number of milliseconds elapsed for this entry. This value will not
|
||||
* be meaningful for all Performance Entry types.
|
||||
* @since v8.5.0
|
||||
*/
|
||||
readonly duration: number;
|
||||
/**
|
||||
* The name of the performance entry.
|
||||
* @since v8.5.0
|
||||
*/
|
||||
readonly name: string;
|
||||
/**
|
||||
* The high resolution millisecond timestamp marking the starting time of the
|
||||
* Performance Entry.
|
||||
* @since v8.5.0
|
||||
*/
|
||||
readonly startTime: number;
|
||||
/**
|
||||
* The type of the performance entry. It may be one of:
|
||||
*
|
||||
* * `'node'` (Node.js only)
|
||||
* * `'mark'` (available on the Web)
|
||||
* * `'measure'` (available on the Web)
|
||||
* * `'gc'` (Node.js only)
|
||||
* * `'function'` (Node.js only)
|
||||
* * `'http2'` (Node.js only)
|
||||
* * `'http'` (Node.js only)
|
||||
* @since v8.5.0
|
||||
*/
|
||||
readonly entryType: EntryType;
|
||||
/**
|
||||
* Additional detail specific to the `entryType`.
|
||||
* @since v16.0.0
|
||||
*/
|
||||
readonly detail?: NodeGCPerformanceDetail | unknown | undefined; // TODO: Narrow this based on entry type.
|
||||
toJSON(): any;
|
||||
}
|
||||
class PerformanceMark extends PerformanceEntry {
|
||||
readonly duration: 0;
|
||||
readonly entryType: 'mark';
|
||||
}
|
||||
class PerformanceMeasure extends PerformanceEntry {
|
||||
readonly entryType: 'measure';
|
||||
}
|
||||
/**
|
||||
* _This property is an extension by Node.js. It is not available in Web browsers._
|
||||
*
|
||||
* Provides timing details for Node.js itself. The constructor of this class
|
||||
* is not exposed to users.
|
||||
* @since v8.5.0
|
||||
*/
|
||||
class PerformanceNodeTiming extends PerformanceEntry {
|
||||
/**
|
||||
* The high resolution millisecond timestamp at which the Node.js process
|
||||
* completed bootstrapping. If bootstrapping has not yet finished, the property
|
||||
* has the value of -1.
|
||||
* @since v8.5.0
|
||||
*/
|
||||
readonly bootstrapComplete: number;
|
||||
/**
|
||||
* The high resolution millisecond timestamp at which the Node.js environment was
|
||||
* initialized.
|
||||
* @since v8.5.0
|
||||
*/
|
||||
readonly environment: number;
|
||||
/**
|
||||
* The high resolution millisecond timestamp of the amount of time the event loop
|
||||
* has been idle within the event loop's event provider (e.g. `epoll_wait`). This
|
||||
* does not take CPU usage into consideration. If the event loop has not yet
|
||||
* started (e.g., in the first tick of the main script), the property has the
|
||||
* value of 0.
|
||||
* @since v14.10.0, v12.19.0
|
||||
*/
|
||||
readonly idleTime: number;
|
||||
/**
|
||||
* The high resolution millisecond timestamp at which the Node.js event loop
|
||||
* exited. If the event loop has not yet exited, the property has the value of -1\.
|
||||
* It can only have a value of not -1 in a handler of the `'exit'` event.
|
||||
* @since v8.5.0
|
||||
*/
|
||||
readonly loopExit: number;
|
||||
/**
|
||||
* The high resolution millisecond timestamp at which the Node.js event loop
|
||||
* started. If the event loop has not yet started (e.g., in the first tick of the
|
||||
* main script), the property has the value of -1.
|
||||
* @since v8.5.0
|
||||
*/
|
||||
readonly loopStart: number;
|
||||
/**
|
||||
* The high resolution millisecond timestamp at which the V8 platform was
|
||||
* initialized.
|
||||
* @since v8.5.0
|
||||
*/
|
||||
readonly v8Start: number;
|
||||
}
|
||||
interface EventLoopUtilization {
|
||||
idle: number;
|
||||
active: number;
|
||||
utilization: number;
|
||||
}
|
||||
/**
|
||||
* @param util1 The result of a previous call to eventLoopUtilization()
|
||||
* @param util2 The result of a previous call to eventLoopUtilization() prior to util1
|
||||
*/
|
||||
type EventLoopUtilityFunction = (util1?: EventLoopUtilization, util2?: EventLoopUtilization) => EventLoopUtilization;
|
||||
interface MarkOptions {
|
||||
/**
|
||||
* Additional optional detail to include with the mark.
|
||||
*/
|
||||
detail?: unknown | undefined;
|
||||
/**
|
||||
* An optional timestamp to be used as the mark time.
|
||||
* @default `performance.now()`.
|
||||
*/
|
||||
startTime?: number | undefined;
|
||||
}
|
||||
interface MeasureOptions {
|
||||
/**
|
||||
* Additional optional detail to include with the mark.
|
||||
*/
|
||||
detail?: unknown | undefined;
|
||||
/**
|
||||
* Duration between start and end times.
|
||||
*/
|
||||
duration?: number | undefined;
|
||||
/**
|
||||
* Timestamp to be used as the end time, or a string identifying a previously recorded mark.
|
||||
*/
|
||||
end?: number | string | undefined;
|
||||
/**
|
||||
* Timestamp to be used as the start time, or a string identifying a previously recorded mark.
|
||||
*/
|
||||
start?: number | string | undefined;
|
||||
}
|
||||
interface TimerifyOptions {
|
||||
/**
|
||||
* A histogram object created using
|
||||
* `perf_hooks.createHistogram()` that will record runtime durations in
|
||||
* nanoseconds.
|
||||
*/
|
||||
histogram?: RecordableHistogram | undefined;
|
||||
}
|
||||
interface Performance {
|
||||
/**
|
||||
* If name is not provided, removes all PerformanceMark objects from the Performance Timeline.
|
||||
* If name is provided, removes only the named mark.
|
||||
* @param name
|
||||
*/
|
||||
clearMarks(name?: string): void;
|
||||
/**
|
||||
* If name is not provided, removes all PerformanceMeasure objects from the Performance Timeline.
|
||||
* If name is provided, removes only the named measure.
|
||||
* @param name
|
||||
* @since v16.7.0
|
||||
*/
|
||||
clearMeasures(name?: string): void;
|
||||
/**
|
||||
* 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
|
||||
* `performance.getEntriesByType()` and `performance.getEntriesByName()`.
|
||||
* @since v16.7.0
|
||||
*/
|
||||
getEntries(): PerformanceEntry[];
|
||||
/**
|
||||
* Returns a list of `PerformanceEntry` objects in chronological order with respect to `performanceEntry.startTime`
|
||||
* whose `performanceEntry.name` is equal to `name`, and optionally, whose `performanceEntry.entryType` is equal to `type`.
|
||||
* @param name
|
||||
* @param type
|
||||
* @since v16.7.0
|
||||
*/
|
||||
getEntriesByName(name: string, type?: EntryType): PerformanceEntry[];
|
||||
/**
|
||||
* Returns a list of `PerformanceEntry` objects in chronological order with respect to `performanceEntry.startTime`
|
||||
* whose `performanceEntry.entryType` is equal to `type`.
|
||||
* @param type
|
||||
* @since v16.7.0
|
||||
*/
|
||||
getEntriesByType(type: EntryType): PerformanceEntry[];
|
||||
/**
|
||||
* Creates a new PerformanceMark entry in the Performance Timeline.
|
||||
* A PerformanceMark is a subclass of PerformanceEntry whose performanceEntry.entryType is always 'mark',
|
||||
* and whose performanceEntry.duration is always 0.
|
||||
* Performance marks are used to mark specific significant moments in the Performance Timeline.
|
||||
* @param name
|
||||
* @return The PerformanceMark entry that was created
|
||||
*/
|
||||
mark(name?: string, options?: MarkOptions): PerformanceMark;
|
||||
/**
|
||||
* Creates a new PerformanceMeasure entry in the Performance Timeline.
|
||||
* A PerformanceMeasure is a subclass of PerformanceEntry whose performanceEntry.entryType is always 'measure',
|
||||
* and whose performanceEntry.duration measures the number of milliseconds elapsed since startMark and endMark.
|
||||
*
|
||||
* The startMark argument may identify any existing PerformanceMark in the the Performance Timeline, or may identify
|
||||
* any of the timestamp properties provided by the PerformanceNodeTiming class. If the named startMark does not exist,
|
||||
* then startMark is set to timeOrigin by default.
|
||||
*
|
||||
* The endMark argument must identify any existing PerformanceMark in the the Performance Timeline or any of the timestamp
|
||||
* properties provided by the PerformanceNodeTiming class. If the named endMark does not exist, an error will be thrown.
|
||||
* @param name
|
||||
* @param startMark
|
||||
* @param endMark
|
||||
* @return The PerformanceMeasure entry that was created
|
||||
*/
|
||||
measure(name: string, startMark?: string, endMark?: string): PerformanceMeasure;
|
||||
measure(name: string, options: MeasureOptions): PerformanceMeasure;
|
||||
/**
|
||||
* An instance of the PerformanceNodeTiming class that provides performance metrics for specific Node.js operational milestones.
|
||||
*/
|
||||
readonly nodeTiming: PerformanceNodeTiming;
|
||||
/**
|
||||
* @return the current high resolution millisecond timestamp
|
||||
*/
|
||||
now(): number;
|
||||
/**
|
||||
* The timeOrigin specifies the high resolution millisecond timestamp from which all performance metric durations are measured.
|
||||
*/
|
||||
readonly timeOrigin: number;
|
||||
/**
|
||||
* 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.
|
||||
* @param fn
|
||||
*/
|
||||
timerify<T extends (...params: any[]) => any>(fn: T, options?: TimerifyOptions): T;
|
||||
/**
|
||||
* 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: EventLoopUtilityFunction;
|
||||
}
|
||||
interface PerformanceObserverEntryList {
|
||||
/**
|
||||
* Returns a list of `PerformanceEntry` objects in chronological order
|
||||
* with respect to `performanceEntry.startTime`.
|
||||
*
|
||||
* ```js
|
||||
* const {
|
||||
* performance,
|
||||
* PerformanceObserver
|
||||
* } = require('perf_hooks');
|
||||
*
|
||||
* const obs = new PerformanceObserver((perfObserverList, observer) => {
|
||||
* console.log(perfObserverList.getEntries());
|
||||
*
|
||||
* * [
|
||||
* * PerformanceEntry {
|
||||
* * name: 'test',
|
||||
* * entryType: 'mark',
|
||||
* * startTime: 81.465639,
|
||||
* * duration: 0
|
||||
* * },
|
||||
* * PerformanceEntry {
|
||||
* * name: 'meow',
|
||||
* * entryType: 'mark',
|
||||
* * startTime: 81.860064,
|
||||
* * duration: 0
|
||||
* * }
|
||||
* * ]
|
||||
*
|
||||
*
|
||||
* performance.clearMarks();
|
||||
* performance.clearMeasures();
|
||||
* observer.disconnect();
|
||||
* });
|
||||
* obs.observe({ type: 'mark' });
|
||||
*
|
||||
* performance.mark('test');
|
||||
* performance.mark('meow');
|
||||
* ```
|
||||
* @since v8.5.0
|
||||
*/
|
||||
getEntries(): PerformanceEntry[];
|
||||
/**
|
||||
* Returns a list of `PerformanceEntry` objects in chronological order
|
||||
* with respect to `performanceEntry.startTime` whose `performanceEntry.name` is
|
||||
* equal to `name`, and optionally, whose `performanceEntry.entryType` is equal to`type`.
|
||||
*
|
||||
* ```js
|
||||
* const {
|
||||
* performance,
|
||||
* PerformanceObserver
|
||||
* } = require('perf_hooks');
|
||||
*
|
||||
* const obs = new PerformanceObserver((perfObserverList, observer) => {
|
||||
* console.log(perfObserverList.getEntriesByName('meow'));
|
||||
*
|
||||
* * [
|
||||
* * PerformanceEntry {
|
||||
* * name: 'meow',
|
||||
* * entryType: 'mark',
|
||||
* * startTime: 98.545991,
|
||||
* * duration: 0
|
||||
* * }
|
||||
* * ]
|
||||
*
|
||||
* console.log(perfObserverList.getEntriesByName('nope')); // []
|
||||
*
|
||||
* console.log(perfObserverList.getEntriesByName('test', 'mark'));
|
||||
*
|
||||
* * [
|
||||
* * PerformanceEntry {
|
||||
* * name: 'test',
|
||||
* * entryType: 'mark',
|
||||
* * startTime: 63.518931,
|
||||
* * duration: 0
|
||||
* * }
|
||||
* * ]
|
||||
*
|
||||
* console.log(perfObserverList.getEntriesByName('test', 'measure')); // []
|
||||
*
|
||||
* performance.clearMarks();
|
||||
* performance.clearMeasures();
|
||||
* observer.disconnect();
|
||||
* });
|
||||
* obs.observe({ entryTypes: ['mark', 'measure'] });
|
||||
*
|
||||
* performance.mark('test');
|
||||
* performance.mark('meow');
|
||||
* ```
|
||||
* @since v8.5.0
|
||||
*/
|
||||
getEntriesByName(name: string, type?: EntryType): PerformanceEntry[];
|
||||
/**
|
||||
* Returns a list of `PerformanceEntry` objects in chronological order
|
||||
* with respect to `performanceEntry.startTime` whose `performanceEntry.entryType`is equal to `type`.
|
||||
*
|
||||
* ```js
|
||||
* const {
|
||||
* performance,
|
||||
* PerformanceObserver
|
||||
* } = require('perf_hooks');
|
||||
*
|
||||
* const obs = new PerformanceObserver((perfObserverList, observer) => {
|
||||
* console.log(perfObserverList.getEntriesByType('mark'));
|
||||
*
|
||||
* * [
|
||||
* * PerformanceEntry {
|
||||
* * name: 'test',
|
||||
* * entryType: 'mark',
|
||||
* * startTime: 55.897834,
|
||||
* * duration: 0
|
||||
* * },
|
||||
* * PerformanceEntry {
|
||||
* * name: 'meow',
|
||||
* * entryType: 'mark',
|
||||
* * startTime: 56.350146,
|
||||
* * duration: 0
|
||||
* * }
|
||||
* * ]
|
||||
*
|
||||
* performance.clearMarks();
|
||||
* performance.clearMeasures();
|
||||
* observer.disconnect();
|
||||
* });
|
||||
* obs.observe({ type: 'mark' });
|
||||
*
|
||||
* performance.mark('test');
|
||||
* performance.mark('meow');
|
||||
* ```
|
||||
* @since v8.5.0
|
||||
*/
|
||||
getEntriesByType(type: EntryType): PerformanceEntry[];
|
||||
}
|
||||
type PerformanceObserverCallback = (list: PerformanceObserverEntryList, observer: PerformanceObserver) => void;
|
||||
class PerformanceObserver extends AsyncResource {
|
||||
constructor(callback: PerformanceObserverCallback);
|
||||
/**
|
||||
* Disconnects the `PerformanceObserver` instance from all notifications.
|
||||
* @since v8.5.0
|
||||
*/
|
||||
disconnect(): void;
|
||||
/**
|
||||
* Subscribes the `PerformanceObserver` instance to notifications of new `PerformanceEntry` instances identified either by `options.entryTypes`or `options.type`:
|
||||
*
|
||||
* ```js
|
||||
* const {
|
||||
* performance,
|
||||
* PerformanceObserver
|
||||
* } = require('perf_hooks');
|
||||
*
|
||||
* const obs = new PerformanceObserver((list, observer) => {
|
||||
* // Called once asynchronously. `list` contains three items.
|
||||
* });
|
||||
* obs.observe({ type: 'mark' });
|
||||
*
|
||||
* for (let n = 0; n < 3; n++)
|
||||
* performance.mark(`test${n}`);
|
||||
* ```
|
||||
* @since v8.5.0
|
||||
*/
|
||||
observe(
|
||||
options:
|
||||
| {
|
||||
entryTypes: ReadonlyArray<EntryType>;
|
||||
buffered?: boolean | undefined;
|
||||
}
|
||||
| {
|
||||
type: EntryType;
|
||||
buffered?: boolean | undefined;
|
||||
}
|
||||
): void;
|
||||
}
|
||||
namespace constants {
|
||||
const NODE_PERFORMANCE_GC_MAJOR: number;
|
||||
const NODE_PERFORMANCE_GC_MINOR: number;
|
||||
const NODE_PERFORMANCE_GC_INCREMENTAL: number;
|
||||
const NODE_PERFORMANCE_GC_WEAKCB: number;
|
||||
const NODE_PERFORMANCE_GC_FLAGS_NO: number;
|
||||
const NODE_PERFORMANCE_GC_FLAGS_CONSTRUCT_RETAINED: number;
|
||||
const NODE_PERFORMANCE_GC_FLAGS_FORCED: number;
|
||||
const NODE_PERFORMANCE_GC_FLAGS_SYNCHRONOUS_PHANTOM_PROCESSING: number;
|
||||
const NODE_PERFORMANCE_GC_FLAGS_ALL_AVAILABLE_GARBAGE: number;
|
||||
const NODE_PERFORMANCE_GC_FLAGS_ALL_EXTERNAL_MEMORY: number;
|
||||
const NODE_PERFORMANCE_GC_FLAGS_SCHEDULE_IDLE: number;
|
||||
}
|
||||
const performance: Performance;
|
||||
interface EventLoopMonitorOptions {
|
||||
/**
|
||||
* The sampling rate in milliseconds.
|
||||
* Must be greater than zero.
|
||||
* @default 10
|
||||
*/
|
||||
resolution?: number | undefined;
|
||||
}
|
||||
interface Histogram {
|
||||
/**
|
||||
* Returns a `Map` object detailing the accumulated percentile distribution.
|
||||
* @since v11.10.0
|
||||
*/
|
||||
readonly percentiles: Map<number, number>;
|
||||
/**
|
||||
* The number of times the event loop delay exceeded the maximum 1 hour event
|
||||
* loop delay threshold.
|
||||
* @since v11.10.0
|
||||
*/
|
||||
readonly exceeds: number;
|
||||
/**
|
||||
* The minimum recorded event loop delay.
|
||||
* @since v11.10.0
|
||||
*/
|
||||
readonly min: number;
|
||||
/**
|
||||
* The maximum recorded event loop delay.
|
||||
* @since v11.10.0
|
||||
*/
|
||||
readonly max: number;
|
||||
/**
|
||||
* The mean of the recorded event loop delays.
|
||||
* @since v11.10.0
|
||||
*/
|
||||
readonly mean: number;
|
||||
/**
|
||||
* The standard deviation of the recorded event loop delays.
|
||||
* @since v11.10.0
|
||||
*/
|
||||
readonly stddev: number;
|
||||
/**
|
||||
* Resets the collected histogram data.
|
||||
* @since v11.10.0
|
||||
*/
|
||||
reset(): void;
|
||||
/**
|
||||
* Returns the value at the given percentile.
|
||||
* @since v11.10.0
|
||||
* @param percentile A percentile value in the range (0, 100].
|
||||
*/
|
||||
percentile(percentile: number): number;
|
||||
}
|
||||
interface IntervalHistogram extends Histogram {
|
||||
/**
|
||||
* Enables the update interval timer. Returns `true` if the timer was
|
||||
* started, `false` if it was already started.
|
||||
* @since v11.10.0
|
||||
*/
|
||||
enable(): boolean;
|
||||
/**
|
||||
* Disables the update interval timer. Returns `true` if the timer was
|
||||
* stopped, `false` if it was already stopped.
|
||||
* @since v11.10.0
|
||||
*/
|
||||
disable(): boolean;
|
||||
}
|
||||
interface RecordableHistogram extends Histogram {
|
||||
/**
|
||||
* @since v15.9.0, v14.18.0
|
||||
* @param val The amount to record in the histogram.
|
||||
*/
|
||||
record(val: number | bigint): void;
|
||||
/**
|
||||
* Calculates the amount of time (in nanoseconds) that has passed since the
|
||||
* previous call to `recordDelta()` and records that amount in the histogram.
|
||||
*
|
||||
* ## Examples
|
||||
* @since v15.9.0, v14.18.0
|
||||
*/
|
||||
recordDelta(): void;
|
||||
/**
|
||||
* Adds the values from other to this histogram.
|
||||
* @since v17.4.0, v16.14.0
|
||||
* @param other Recordable Histogram to combine with
|
||||
*/
|
||||
add(other: RecordableHistogram): void;
|
||||
}
|
||||
/**
|
||||
* _This property is an extension by Node.js. It is not available in Web browsers._
|
||||
*
|
||||
* Creates an `IntervalHistogram` object that samples and reports the event loop
|
||||
* delay over time. The delays will be reported in nanoseconds.
|
||||
*
|
||||
* Using a timer to detect approximate event loop delay works because the
|
||||
* execution of timers is tied specifically to the lifecycle of the libuv
|
||||
* event loop. That is, a delay in the loop will cause a delay in the execution
|
||||
* of the timer, and those delays are specifically what this API is intended to
|
||||
* detect.
|
||||
*
|
||||
* ```js
|
||||
* const { monitorEventLoopDelay } = require('perf_hooks');
|
||||
* const h = monitorEventLoopDelay({ resolution: 20 });
|
||||
* h.enable();
|
||||
* // Do something.
|
||||
* h.disable();
|
||||
* console.log(h.min);
|
||||
* console.log(h.max);
|
||||
* console.log(h.mean);
|
||||
* console.log(h.stddev);
|
||||
* console.log(h.percentiles);
|
||||
* console.log(h.percentile(50));
|
||||
* console.log(h.percentile(99));
|
||||
* ```
|
||||
* @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
|
||||
*/
|
||||
min?: number | bigint | undefined;
|
||||
/**
|
||||
* The maximum recordable value. Must be an integer value greater than min.
|
||||
* @default Number.MAX_SAFE_INTEGER
|
||||
*/
|
||||
max?: number | bigint | undefined;
|
||||
/**
|
||||
* The number of accuracy digits. Must be a number between 1 and 5.
|
||||
* @default 3
|
||||
*/
|
||||
figures?: number | undefined;
|
||||
}
|
||||
/**
|
||||
* Returns a `RecordableHistogram`.
|
||||
* @since v15.9.0, v14.18.0
|
||||
*/
|
||||
function createHistogram(options?: CreateHistogramOptions): RecordableHistogram;
|
||||
}
|
||||
declare module 'node:perf_hooks' {
|
||||
export * from 'perf_hooks';
|
||||
}
|
1482
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/process.d.ts
generated
vendored
1482
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/process.d.ts
generated
vendored
File diff suppressed because it is too large
Load Diff
117
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/punycode.d.ts
generated
vendored
117
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/punycode.d.ts
generated
vendored
@ -0,0 +1,117 @@
|
||||
/**
|
||||
* **The version of the punycode module bundled in Node.js is being deprecated.**In a future major version of Node.js this module will be removed. Users
|
||||
* currently depending on the `punycode` module should switch to using the
|
||||
* userland-provided [Punycode.js](https://github.com/bestiejs/punycode.js) module instead. For punycode-based URL
|
||||
* encoding, see `url.domainToASCII` or, more generally, the `WHATWG URL API`.
|
||||
*
|
||||
* The `punycode` module is a bundled version of the [Punycode.js](https://github.com/bestiejs/punycode.js) module. It
|
||||
* can be accessed using:
|
||||
*
|
||||
* ```js
|
||||
* const punycode = require('punycode');
|
||||
* ```
|
||||
*
|
||||
* [Punycode](https://tools.ietf.org/html/rfc3492) is a character encoding scheme defined by RFC 3492 that is
|
||||
* primarily intended for use in Internationalized Domain Names. Because host
|
||||
* names in URLs are limited to ASCII characters only, Domain Names that contain
|
||||
* non-ASCII characters must be converted into ASCII using the Punycode scheme.
|
||||
* For instance, the Japanese character that translates into the English word,`'example'` is `'例'`. The Internationalized Domain Name, `'例.com'` (equivalent
|
||||
* to `'example.com'`) is represented by Punycode as the ASCII string`'xn--fsq.com'`.
|
||||
*
|
||||
* The `punycode` module provides a simple implementation of the Punycode standard.
|
||||
*
|
||||
* The `punycode` module is a third-party dependency used by Node.js and
|
||||
* made available to developers as a convenience. Fixes or other modifications to
|
||||
* the module must be directed to the [Punycode.js](https://github.com/bestiejs/punycode.js) project.
|
||||
* @deprecated Since v7.0.0 - Deprecated
|
||||
* @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/punycode.js)
|
||||
*/
|
||||
declare module 'punycode' {
|
||||
/**
|
||||
* The `punycode.decode()` method converts a [Punycode](https://tools.ietf.org/html/rfc3492) string of ASCII-only
|
||||
* characters to the equivalent string of Unicode codepoints.
|
||||
*
|
||||
* ```js
|
||||
* punycode.decode('maana-pta'); // 'mañana'
|
||||
* punycode.decode('--dqo34k'); // '☃-⌘'
|
||||
* ```
|
||||
* @since v0.5.1
|
||||
*/
|
||||
function decode(string: string): string;
|
||||
/**
|
||||
* The `punycode.encode()` method converts a string of Unicode codepoints to a [Punycode](https://tools.ietf.org/html/rfc3492) string of ASCII-only characters.
|
||||
*
|
||||
* ```js
|
||||
* punycode.encode('mañana'); // 'maana-pta'
|
||||
* punycode.encode('☃-⌘'); // '--dqo34k'
|
||||
* ```
|
||||
* @since v0.5.1
|
||||
*/
|
||||
function encode(string: string): string;
|
||||
/**
|
||||
* The `punycode.toUnicode()` method converts a string representing a domain name
|
||||
* containing [Punycode](https://tools.ietf.org/html/rfc3492) encoded characters into Unicode. Only the [Punycode](https://tools.ietf.org/html/rfc3492) encoded parts of the domain name are be
|
||||
* converted.
|
||||
*
|
||||
* ```js
|
||||
* // decode domain names
|
||||
* punycode.toUnicode('xn--maana-pta.com'); // 'mañana.com'
|
||||
* punycode.toUnicode('xn----dqo34k.com'); // '☃-⌘.com'
|
||||
* punycode.toUnicode('example.com'); // 'example.com'
|
||||
* ```
|
||||
* @since v0.6.1
|
||||
*/
|
||||
function toUnicode(domain: string): string;
|
||||
/**
|
||||
* The `punycode.toASCII()` method converts a Unicode string representing an
|
||||
* Internationalized Domain Name to [Punycode](https://tools.ietf.org/html/rfc3492). Only the non-ASCII parts of the
|
||||
* domain name will be converted. Calling `punycode.toASCII()` on a string that
|
||||
* already only contains ASCII characters will have no effect.
|
||||
*
|
||||
* ```js
|
||||
* // encode domain names
|
||||
* punycode.toASCII('mañana.com'); // 'xn--maana-pta.com'
|
||||
* punycode.toASCII('☃-⌘.com'); // 'xn----dqo34k.com'
|
||||
* punycode.toASCII('example.com'); // 'example.com'
|
||||
* ```
|
||||
* @since v0.6.1
|
||||
*/
|
||||
function toASCII(domain: string): string;
|
||||
/**
|
||||
* @deprecated since v7.0.0
|
||||
* The version of the punycode module bundled in Node.js is being deprecated.
|
||||
* In a future major version of Node.js this module will be removed.
|
||||
* Users currently depending on the punycode module should switch to using
|
||||
* the userland-provided Punycode.js module instead.
|
||||
*/
|
||||
const ucs2: ucs2;
|
||||
interface ucs2 {
|
||||
/**
|
||||
* @deprecated since v7.0.0
|
||||
* The version of the punycode module bundled in Node.js is being deprecated.
|
||||
* In a future major version of Node.js this module will be removed.
|
||||
* Users currently depending on the punycode module should switch to using
|
||||
* the userland-provided Punycode.js module instead.
|
||||
*/
|
||||
decode(string: string): number[];
|
||||
/**
|
||||
* @deprecated since v7.0.0
|
||||
* The version of the punycode module bundled in Node.js is being deprecated.
|
||||
* In a future major version of Node.js this module will be removed.
|
||||
* Users currently depending on the punycode module should switch to using
|
||||
* the userland-provided Punycode.js module instead.
|
||||
*/
|
||||
encode(codePoints: ReadonlyArray<number>): string;
|
||||
}
|
||||
/**
|
||||
* @deprecated since v7.0.0
|
||||
* The version of the punycode module bundled in Node.js is being deprecated.
|
||||
* In a future major version of Node.js this module will be removed.
|
||||
* Users currently depending on the punycode module should switch to using
|
||||
* the userland-provided Punycode.js module instead.
|
||||
*/
|
||||
const version: string;
|
||||
}
|
||||
declare module 'node:punycode' {
|
||||
export * from 'punycode';
|
||||
}
|
131
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/querystring.d.ts
generated
vendored
131
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/querystring.d.ts
generated
vendored
@ -0,0 +1,131 @@
|
||||
/**
|
||||
* The `querystring` module provides utilities for parsing and formatting URL
|
||||
* query strings. It can be accessed using:
|
||||
*
|
||||
* ```js
|
||||
* const querystring = require('querystring');
|
||||
* ```
|
||||
*
|
||||
* The `querystring` API is considered Legacy. While it is still maintained,
|
||||
* new code should use the `URLSearchParams` API instead.
|
||||
* @deprecated Legacy
|
||||
* @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/querystring.js)
|
||||
*/
|
||||
declare module 'querystring' {
|
||||
interface StringifyOptions {
|
||||
encodeURIComponent?: ((str: string) => string) | undefined;
|
||||
}
|
||||
interface ParseOptions {
|
||||
maxKeys?: number | undefined;
|
||||
decodeURIComponent?: ((str: string) => string) | undefined;
|
||||
}
|
||||
interface ParsedUrlQuery extends NodeJS.Dict<string | string[]> {}
|
||||
interface ParsedUrlQueryInput extends NodeJS.Dict<string | number | boolean | ReadonlyArray<string> | ReadonlyArray<number> | ReadonlyArray<boolean> | null> {}
|
||||
/**
|
||||
* The `querystring.stringify()` method produces a URL query string from a
|
||||
* given `obj` by iterating through the object's "own properties".
|
||||
*
|
||||
* It serializes the following types of values passed in `obj`:[string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) |
|
||||
* [number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type) |
|
||||
* [bigint](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt) |
|
||||
* [boolean](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type) |
|
||||
* [string\[\]](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#String_type) |
|
||||
* [number\[\]](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Number_type) |
|
||||
* [bigint\[\]](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt) |
|
||||
* [boolean\[\]](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures#Boolean_type) The numeric values must be finite. Any other input values will be coerced to
|
||||
* empty strings.
|
||||
*
|
||||
* ```js
|
||||
* querystring.stringify({ foo: 'bar', baz: ['qux', 'quux'], corge: '' });
|
||||
* // Returns 'foo=bar&baz=qux&baz=quux&corge='
|
||||
*
|
||||
* querystring.stringify({ foo: 'bar', baz: 'qux' }, ';', ':');
|
||||
* // Returns 'foo:bar;baz:qux'
|
||||
* ```
|
||||
*
|
||||
* By default, characters requiring percent-encoding within the query string will
|
||||
* be encoded as UTF-8\. If an alternative encoding is required, then an alternative`encodeURIComponent` option will need to be specified:
|
||||
*
|
||||
* ```js
|
||||
* // Assuming gbkEncodeURIComponent function already exists,
|
||||
*
|
||||
* querystring.stringify({ w: '中文', foo: 'bar' }, null, null,
|
||||
* { encodeURIComponent: gbkEncodeURIComponent });
|
||||
* ```
|
||||
* @since v0.1.25
|
||||
* @param obj The object to serialize into a URL query string
|
||||
* @param [sep='&'] The substring used to delimit key and value pairs in the query string.
|
||||
* @param [eq='='] . The substring used to delimit keys and values in the query string.
|
||||
*/
|
||||
function stringify(obj?: ParsedUrlQueryInput, sep?: string, eq?: string, options?: StringifyOptions): string;
|
||||
/**
|
||||
* The `querystring.parse()` method parses a URL query string (`str`) into a
|
||||
* collection of key and value pairs.
|
||||
*
|
||||
* For example, the query string `'foo=bar&abc=xyz&abc=123'` is parsed into:
|
||||
*
|
||||
* ```js
|
||||
* {
|
||||
* foo: 'bar',
|
||||
* abc: ['xyz', '123']
|
||||
* }
|
||||
* ```
|
||||
*
|
||||
* The object returned by the `querystring.parse()` method _does not_prototypically inherit from the JavaScript `Object`. This means that typical`Object` methods such as `obj.toString()`,
|
||||
* `obj.hasOwnProperty()`, and others
|
||||
* are not defined and _will not work_.
|
||||
*
|
||||
* By default, percent-encoded characters within the query string will be assumed
|
||||
* to use UTF-8 encoding. If an alternative character encoding is used, then an
|
||||
* alternative `decodeURIComponent` option will need to be specified:
|
||||
*
|
||||
* ```js
|
||||
* // Assuming gbkDecodeURIComponent function already exists...
|
||||
*
|
||||
* querystring.parse('w=%D6%D0%CE%C4&foo=bar', null, null,
|
||||
* { decodeURIComponent: gbkDecodeURIComponent });
|
||||
* ```
|
||||
* @since v0.1.25
|
||||
* @param str The URL query string to parse
|
||||
* @param [sep='&'] The substring used to delimit key and value pairs in the query string.
|
||||
* @param [eq='='] . The substring used to delimit keys and values in the query string.
|
||||
*/
|
||||
function parse(str: string, sep?: string, eq?: string, options?: ParseOptions): ParsedUrlQuery;
|
||||
/**
|
||||
* The querystring.encode() function is an alias for querystring.stringify().
|
||||
*/
|
||||
const encode: typeof stringify;
|
||||
/**
|
||||
* The querystring.decode() function is an alias for querystring.parse().
|
||||
*/
|
||||
const decode: typeof parse;
|
||||
/**
|
||||
* The `querystring.escape()` method performs URL percent-encoding on the given`str` in a manner that is optimized for the specific requirements of URL
|
||||
* query strings.
|
||||
*
|
||||
* The `querystring.escape()` method is used by `querystring.stringify()` and is
|
||||
* generally not expected to be used directly. It is exported primarily to allow
|
||||
* application code to provide a replacement percent-encoding implementation if
|
||||
* necessary by assigning `querystring.escape` to an alternative function.
|
||||
* @since v0.1.25
|
||||
*/
|
||||
function escape(str: string): string;
|
||||
/**
|
||||
* The `querystring.unescape()` method performs decoding of URL percent-encoded
|
||||
* characters on the given `str`.
|
||||
*
|
||||
* The `querystring.unescape()` method is used by `querystring.parse()` and is
|
||||
* generally not expected to be used directly. It is exported primarily to allow
|
||||
* application code to provide a replacement decoding implementation if
|
||||
* necessary by assigning `querystring.unescape` to an alternative function.
|
||||
*
|
||||
* By default, the `querystring.unescape()` method will attempt to use the
|
||||
* JavaScript built-in `decodeURIComponent()` method to decode. If that fails,
|
||||
* a safer equivalent that does not throw on malformed URLs will be used.
|
||||
* @since v0.1.25
|
||||
*/
|
||||
function unescape(str: string): string;
|
||||
}
|
||||
declare module 'node:querystring' {
|
||||
export * from 'querystring';
|
||||
}
|
653
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/readline.d.ts
generated
vendored
653
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/readline.d.ts
generated
vendored
@ -0,0 +1,653 @@
|
||||
/**
|
||||
* The `readline` module provides an interface for reading data from a `Readable` stream (such as `process.stdin`) one line at a time.
|
||||
*
|
||||
* To use the promise-based APIs:
|
||||
*
|
||||
* ```js
|
||||
* import * as readline from 'node:readline/promises';
|
||||
* ```
|
||||
*
|
||||
* To use the callback and sync APIs:
|
||||
*
|
||||
* ```js
|
||||
* import * as readline from 'node:readline';
|
||||
* ```
|
||||
*
|
||||
* The following simple example illustrates the basic use of the `readline` module.
|
||||
*
|
||||
* ```js
|
||||
* import * as readline from 'node:readline/promises';
|
||||
* import { stdin as input, stdout as output } from 'node:process';
|
||||
*
|
||||
* const rl = readline.createInterface({ input, output });
|
||||
*
|
||||
* const answer = await rl.question('What do you think of Node.js? ');
|
||||
*
|
||||
* console.log(`Thank you for your valuable feedback: ${answer}`);
|
||||
*
|
||||
* rl.close();
|
||||
* ```
|
||||
*
|
||||
* Once this code is invoked, the Node.js application will not terminate until the`readline.Interface` is closed because the interface waits for data to be
|
||||
* received on the `input` stream.
|
||||
* @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/readline.js)
|
||||
*/
|
||||
declare module 'readline' {
|
||||
import { Abortable, EventEmitter } from 'node:events';
|
||||
import * as promises from 'node:readline/promises';
|
||||
|
||||
export { promises };
|
||||
export interface Key {
|
||||
sequence?: string | undefined;
|
||||
name?: string | undefined;
|
||||
ctrl?: boolean | undefined;
|
||||
meta?: boolean | undefined;
|
||||
shift?: boolean | undefined;
|
||||
}
|
||||
/**
|
||||
* Instances of the `readline.Interface` class are constructed using the`readline.createInterface()` method. Every instance is associated with a
|
||||
* single `input` `Readable` stream and a single `output` `Writable` stream.
|
||||
* The `output` stream is used to print prompts for user input that arrives on,
|
||||
* and is read from, the `input` stream.
|
||||
* @since v0.1.104
|
||||
*/
|
||||
export class Interface extends EventEmitter {
|
||||
readonly terminal: boolean;
|
||||
/**
|
||||
* The current input data being processed by node.
|
||||
*
|
||||
* This can be used when collecting input from a TTY stream to retrieve the
|
||||
* current value that has been processed thus far, prior to the `line` event
|
||||
* being emitted. Once the `line` event has been emitted, this property will
|
||||
* be an empty string.
|
||||
*
|
||||
* Be aware that modifying the value during the instance runtime may have
|
||||
* unintended consequences if `rl.cursor` is not also controlled.
|
||||
*
|
||||
* **If not using a TTY stream for input, use the `'line'` event.**
|
||||
*
|
||||
* One possible use case would be as follows:
|
||||
*
|
||||
* ```js
|
||||
* const values = ['lorem ipsum', 'dolor sit amet'];
|
||||
* const rl = readline.createInterface(process.stdin);
|
||||
* const showResults = debounce(() => {
|
||||
* console.log(
|
||||
* '\n',
|
||||
* values.filter((val) => val.startsWith(rl.line)).join(' ')
|
||||
* );
|
||||
* }, 300);
|
||||
* process.stdin.on('keypress', (c, k) => {
|
||||
* showResults();
|
||||
* });
|
||||
* ```
|
||||
* @since v0.1.98
|
||||
*/
|
||||
readonly line: string;
|
||||
/**
|
||||
* The cursor position relative to `rl.line`.
|
||||
*
|
||||
* This will track where the current cursor lands in the input string, when
|
||||
* reading input from a TTY stream. The position of cursor determines the
|
||||
* portion of the input string that will be modified as input is processed,
|
||||
* as well as the column where the terminal caret will be rendered.
|
||||
* @since v0.1.98
|
||||
*/
|
||||
readonly cursor: number;
|
||||
/**
|
||||
* NOTE: According to the documentation:
|
||||
*
|
||||
* > Instances of the `readline.Interface` class are constructed using the
|
||||
* > `readline.createInterface()` method.
|
||||
*
|
||||
* @see https://nodejs.org/dist/latest-v10.x/docs/api/readline.html#readline_class_interface
|
||||
*/
|
||||
protected constructor(input: NodeJS.ReadableStream, output?: NodeJS.WritableStream, completer?: Completer | AsyncCompleter, terminal?: boolean);
|
||||
/**
|
||||
* NOTE: According to the documentation:
|
||||
*
|
||||
* > Instances of the `readline.Interface` class are constructed using the
|
||||
* > `readline.createInterface()` method.
|
||||
*
|
||||
* @see https://nodejs.org/dist/latest-v10.x/docs/api/readline.html#readline_class_interface
|
||||
*/
|
||||
protected constructor(options: ReadLineOptions);
|
||||
/**
|
||||
* The `rl.getPrompt()` method returns the current prompt used by `rl.prompt()`.
|
||||
* @since v15.3.0
|
||||
* @return the current prompt string
|
||||
*/
|
||||
getPrompt(): string;
|
||||
/**
|
||||
* The `rl.setPrompt()` method sets the prompt that will be written to `output`whenever `rl.prompt()` is called.
|
||||
* @since v0.1.98
|
||||
*/
|
||||
setPrompt(prompt: string): void;
|
||||
/**
|
||||
* The `rl.prompt()` method writes the `readline.Interface` instances configured`prompt` to a new line in `output` in order to provide a user with a new
|
||||
* location at which to provide input.
|
||||
*
|
||||
* When called, `rl.prompt()` will resume the `input` stream if it has been
|
||||
* paused.
|
||||
*
|
||||
* If the `readline.Interface` was created with `output` set to `null` or`undefined` the prompt is not written.
|
||||
* @since v0.1.98
|
||||
* @param preserveCursor If `true`, prevents the cursor placement from being reset to `0`.
|
||||
*/
|
||||
prompt(preserveCursor?: boolean): void;
|
||||
/**
|
||||
* The `rl.question()` method displays the `query` by writing it to the `output`,
|
||||
* waits for user input to be provided on `input`, then invokes the `callback`function passing the provided input as the first argument.
|
||||
*
|
||||
* When called, `rl.question()` will resume the `input` stream if it has been
|
||||
* paused.
|
||||
*
|
||||
* If the `readline.Interface` was created with `output` set to `null` or`undefined` the `query` is not written.
|
||||
*
|
||||
* The `callback` function passed to `rl.question()` does not follow the typical
|
||||
* pattern of accepting an `Error` object or `null` as the first argument.
|
||||
* The `callback` is called with the provided answer as the only argument.
|
||||
*
|
||||
* Example usage:
|
||||
*
|
||||
* ```js
|
||||
* rl.question('What is your favorite food? ', (answer) => {
|
||||
* console.log(`Oh, so your favorite food is ${answer}`);
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* Using an `AbortController` to cancel a question.
|
||||
*
|
||||
* ```js
|
||||
* const ac = new AbortController();
|
||||
* const signal = ac.signal;
|
||||
*
|
||||
* rl.question('What is your favorite food? ', { signal }, (answer) => {
|
||||
* console.log(`Oh, so your favorite food is ${answer}`);
|
||||
* });
|
||||
*
|
||||
* signal.addEventListener('abort', () => {
|
||||
* console.log('The food question timed out');
|
||||
* }, { once: true });
|
||||
*
|
||||
* setTimeout(() => ac.abort(), 10000);
|
||||
* ```
|
||||
*
|
||||
* If this method is invoked as it's util.promisify()ed version, it returns a
|
||||
* Promise that fulfills with the answer. If the question is canceled using
|
||||
* an `AbortController` it will reject with an `AbortError`.
|
||||
*
|
||||
* ```js
|
||||
* const util = require('util');
|
||||
* const question = util.promisify(rl.question).bind(rl);
|
||||
*
|
||||
* async function questionExample() {
|
||||
* try {
|
||||
* const answer = await question('What is you favorite food? ');
|
||||
* console.log(`Oh, so your favorite food is ${answer}`);
|
||||
* } catch (err) {
|
||||
* console.error('Question rejected', err);
|
||||
* }
|
||||
* }
|
||||
* questionExample();
|
||||
* ```
|
||||
* @since v0.3.3
|
||||
* @param query A statement or query to write to `output`, prepended to the prompt.
|
||||
* @param callback A callback function that is invoked with the user's input in response to the `query`.
|
||||
*/
|
||||
question(query: string, callback: (answer: string) => void): void;
|
||||
question(query: string, options: Abortable, callback: (answer: string) => void): void;
|
||||
/**
|
||||
* The `rl.pause()` method pauses the `input` stream, allowing it to be resumed
|
||||
* later if necessary.
|
||||
*
|
||||
* Calling `rl.pause()` does not immediately pause other events (including`'line'`) from being emitted by the `readline.Interface` instance.
|
||||
* @since v0.3.4
|
||||
*/
|
||||
pause(): this;
|
||||
/**
|
||||
* The `rl.resume()` method resumes the `input` stream if it has been paused.
|
||||
* @since v0.3.4
|
||||
*/
|
||||
resume(): this;
|
||||
/**
|
||||
* The `rl.close()` method closes the `readline.Interface` instance and
|
||||
* relinquishes control over the `input` and `output` streams. When called,
|
||||
* the `'close'` event will be emitted.
|
||||
*
|
||||
* Calling `rl.close()` does not immediately stop other events (including `'line'`)
|
||||
* from being emitted by the `readline.Interface` instance.
|
||||
* @since v0.1.98
|
||||
*/
|
||||
close(): void;
|
||||
/**
|
||||
* The `rl.write()` method will write either `data` or a key sequence identified
|
||||
* by `key` to the `output`. The `key` argument is supported only if `output` is
|
||||
* a `TTY` text terminal. See `TTY keybindings` for a list of key
|
||||
* combinations.
|
||||
*
|
||||
* If `key` is specified, `data` is ignored.
|
||||
*
|
||||
* When called, `rl.write()` will resume the `input` stream if it has been
|
||||
* paused.
|
||||
*
|
||||
* If the `readline.Interface` was created with `output` set to `null` or`undefined` the `data` and `key` are not written.
|
||||
*
|
||||
* ```js
|
||||
* rl.write('Delete this!');
|
||||
* // Simulate Ctrl+U to delete the line written previously
|
||||
* rl.write(null, { ctrl: true, name: 'u' });
|
||||
* ```
|
||||
*
|
||||
* The `rl.write()` method will write the data to the `readline` `Interface`'s`input`_as if it were provided by the user_.
|
||||
* @since v0.1.98
|
||||
*/
|
||||
write(data: string | Buffer, key?: Key): void;
|
||||
write(data: undefined | null | string | Buffer, key: Key): void;
|
||||
/**
|
||||
* Returns the real position of the cursor in relation to the input
|
||||
* prompt + string. Long input (wrapping) strings, as well as multiple
|
||||
* line prompts are included in the calculations.
|
||||
* @since v13.5.0, v12.16.0
|
||||
*/
|
||||
getCursorPos(): CursorPos;
|
||||
/**
|
||||
* events.EventEmitter
|
||||
* 1. close
|
||||
* 2. line
|
||||
* 3. pause
|
||||
* 4. resume
|
||||
* 5. SIGCONT
|
||||
* 6. SIGINT
|
||||
* 7. SIGTSTP
|
||||
* 8. history
|
||||
*/
|
||||
addListener(event: string, listener: (...args: any[]) => void): this;
|
||||
addListener(event: 'close', listener: () => void): this;
|
||||
addListener(event: 'line', listener: (input: string) => void): this;
|
||||
addListener(event: 'pause', listener: () => void): this;
|
||||
addListener(event: 'resume', listener: () => void): this;
|
||||
addListener(event: 'SIGCONT', listener: () => void): this;
|
||||
addListener(event: 'SIGINT', listener: () => void): this;
|
||||
addListener(event: 'SIGTSTP', listener: () => void): this;
|
||||
addListener(event: 'history', listener: (history: string[]) => void): this;
|
||||
emit(event: string | symbol, ...args: any[]): boolean;
|
||||
emit(event: 'close'): boolean;
|
||||
emit(event: 'line', input: string): boolean;
|
||||
emit(event: 'pause'): boolean;
|
||||
emit(event: 'resume'): boolean;
|
||||
emit(event: 'SIGCONT'): boolean;
|
||||
emit(event: 'SIGINT'): boolean;
|
||||
emit(event: 'SIGTSTP'): boolean;
|
||||
emit(event: 'history', history: string[]): boolean;
|
||||
on(event: string, listener: (...args: any[]) => void): this;
|
||||
on(event: 'close', listener: () => void): this;
|
||||
on(event: 'line', listener: (input: string) => void): this;
|
||||
on(event: 'pause', listener: () => void): this;
|
||||
on(event: 'resume', listener: () => void): this;
|
||||
on(event: 'SIGCONT', listener: () => void): this;
|
||||
on(event: 'SIGINT', listener: () => void): this;
|
||||
on(event: 'SIGTSTP', listener: () => void): this;
|
||||
on(event: 'history', listener: (history: string[]) => void): this;
|
||||
once(event: string, listener: (...args: any[]) => void): this;
|
||||
once(event: 'close', listener: () => void): this;
|
||||
once(event: 'line', listener: (input: string) => void): this;
|
||||
once(event: 'pause', listener: () => void): this;
|
||||
once(event: 'resume', listener: () => void): this;
|
||||
once(event: 'SIGCONT', listener: () => void): this;
|
||||
once(event: 'SIGINT', listener: () => void): this;
|
||||
once(event: 'SIGTSTP', listener: () => void): this;
|
||||
once(event: 'history', listener: (history: string[]) => void): this;
|
||||
prependListener(event: string, listener: (...args: any[]) => void): this;
|
||||
prependListener(event: 'close', listener: () => void): this;
|
||||
prependListener(event: 'line', listener: (input: string) => void): this;
|
||||
prependListener(event: 'pause', listener: () => void): this;
|
||||
prependListener(event: 'resume', listener: () => void): this;
|
||||
prependListener(event: 'SIGCONT', listener: () => void): this;
|
||||
prependListener(event: 'SIGINT', listener: () => void): this;
|
||||
prependListener(event: 'SIGTSTP', listener: () => void): this;
|
||||
prependListener(event: 'history', listener: (history: string[]) => void): this;
|
||||
prependOnceListener(event: string, listener: (...args: any[]) => void): this;
|
||||
prependOnceListener(event: 'close', listener: () => void): this;
|
||||
prependOnceListener(event: 'line', listener: (input: string) => void): this;
|
||||
prependOnceListener(event: 'pause', listener: () => void): this;
|
||||
prependOnceListener(event: 'resume', listener: () => void): this;
|
||||
prependOnceListener(event: 'SIGCONT', listener: () => void): this;
|
||||
prependOnceListener(event: 'SIGINT', listener: () => void): this;
|
||||
prependOnceListener(event: 'SIGTSTP', listener: () => void): this;
|
||||
prependOnceListener(event: 'history', listener: (history: string[]) => void): this;
|
||||
[Symbol.asyncIterator](): AsyncIterableIterator<string>;
|
||||
}
|
||||
export type ReadLine = Interface; // type forwarded for backwards compatibility
|
||||
export type Completer = (line: string) => CompleterResult;
|
||||
export type AsyncCompleter = (line: string, callback: (err?: null | Error, result?: CompleterResult) => void) => void;
|
||||
export type CompleterResult = [string[], string];
|
||||
export interface ReadLineOptions {
|
||||
input: NodeJS.ReadableStream;
|
||||
output?: NodeJS.WritableStream | undefined;
|
||||
completer?: Completer | AsyncCompleter | undefined;
|
||||
terminal?: boolean | undefined;
|
||||
/**
|
||||
* Initial list of history lines. This option makes sense
|
||||
* only if `terminal` is set to `true` by the user or by an internal `output`
|
||||
* check, otherwise the history caching mechanism is not initialized at all.
|
||||
* @default []
|
||||
*/
|
||||
history?: string[] | undefined;
|
||||
historySize?: number | undefined;
|
||||
prompt?: string | undefined;
|
||||
crlfDelay?: number | undefined;
|
||||
/**
|
||||
* If `true`, when a new input line added
|
||||
* to the history list duplicates an older one, this removes the older line
|
||||
* from the list.
|
||||
* @default false
|
||||
*/
|
||||
removeHistoryDuplicates?: boolean | undefined;
|
||||
escapeCodeTimeout?: number | undefined;
|
||||
tabSize?: number | undefined;
|
||||
}
|
||||
/**
|
||||
* The `readline.createInterface()` method creates a new `readline.Interface`instance.
|
||||
*
|
||||
* ```js
|
||||
* const readline = require('readline');
|
||||
* const rl = readline.createInterface({
|
||||
* input: process.stdin,
|
||||
* output: process.stdout
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* Once the `readline.Interface` instance is created, the most common case is to
|
||||
* listen for the `'line'` event:
|
||||
*
|
||||
* ```js
|
||||
* rl.on('line', (line) => {
|
||||
* console.log(`Received: ${line}`);
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* If `terminal` is `true` for this instance then the `output` stream will get
|
||||
* the best compatibility if it defines an `output.columns` property and emits
|
||||
* a `'resize'` event on the `output` if or when the columns ever change
|
||||
* (`process.stdout` does this automatically when it is a TTY).
|
||||
*
|
||||
* When creating a `readline.Interface` using `stdin` as input, the program
|
||||
* will not terminate until it receives `EOF` (Ctrl+D on
|
||||
* Linux/macOS, Ctrl+Z followed by Return on
|
||||
* Windows).
|
||||
* If you want your application to exit without waiting for user input, you can `unref()` the standard input stream:
|
||||
*
|
||||
* ```js
|
||||
* process.stdin.unref();
|
||||
* ```
|
||||
* @since v0.1.98
|
||||
*/
|
||||
export function createInterface(input: NodeJS.ReadableStream, output?: NodeJS.WritableStream, completer?: Completer | AsyncCompleter, terminal?: boolean): Interface;
|
||||
export function createInterface(options: ReadLineOptions): Interface;
|
||||
/**
|
||||
* The `readline.emitKeypressEvents()` method causes the given `Readable` stream to begin emitting `'keypress'` events corresponding to received input.
|
||||
*
|
||||
* Optionally, `interface` specifies a `readline.Interface` instance for which
|
||||
* autocompletion is disabled when copy-pasted input is detected.
|
||||
*
|
||||
* If the `stream` is a `TTY`, then it must be in raw mode.
|
||||
*
|
||||
* This is automatically called by any readline instance on its `input` if the`input` is a terminal. Closing the `readline` instance does not stop
|
||||
* the `input` from emitting `'keypress'` events.
|
||||
*
|
||||
* ```js
|
||||
* readline.emitKeypressEvents(process.stdin);
|
||||
* if (process.stdin.isTTY)
|
||||
* process.stdin.setRawMode(true);
|
||||
* ```
|
||||
*
|
||||
* ## Example: Tiny CLI
|
||||
*
|
||||
* The following example illustrates the use of `readline.Interface` class to
|
||||
* implement a small command-line interface:
|
||||
*
|
||||
* ```js
|
||||
* const readline = require('readline');
|
||||
* const rl = readline.createInterface({
|
||||
* input: process.stdin,
|
||||
* output: process.stdout,
|
||||
* prompt: 'OHAI> '
|
||||
* });
|
||||
*
|
||||
* rl.prompt();
|
||||
*
|
||||
* rl.on('line', (line) => {
|
||||
* switch (line.trim()) {
|
||||
* case 'hello':
|
||||
* console.log('world!');
|
||||
* break;
|
||||
* default:
|
||||
* console.log(`Say what? I might have heard '${line.trim()}'`);
|
||||
* break;
|
||||
* }
|
||||
* rl.prompt();
|
||||
* }).on('close', () => {
|
||||
* console.log('Have a great day!');
|
||||
* process.exit(0);
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* ## Example: Read file stream line-by-Line
|
||||
*
|
||||
* A common use case for `readline` is to consume an input file one line at a
|
||||
* time. The easiest way to do so is leveraging the `fs.ReadStream` API as
|
||||
* well as a `for await...of` loop:
|
||||
*
|
||||
* ```js
|
||||
* const fs = require('fs');
|
||||
* const readline = require('readline');
|
||||
*
|
||||
* async function processLineByLine() {
|
||||
* const fileStream = fs.createReadStream('input.txt');
|
||||
*
|
||||
* const rl = readline.createInterface({
|
||||
* input: fileStream,
|
||||
* crlfDelay: Infinity
|
||||
* });
|
||||
* // Note: we use the crlfDelay option to recognize all instances of CR LF
|
||||
* // ('\r\n') in input.txt as a single line break.
|
||||
*
|
||||
* for await (const line of rl) {
|
||||
* // Each line in input.txt will be successively available here as `line`.
|
||||
* console.log(`Line from file: ${line}`);
|
||||
* }
|
||||
* }
|
||||
*
|
||||
* processLineByLine();
|
||||
* ```
|
||||
*
|
||||
* Alternatively, one could use the `'line'` event:
|
||||
*
|
||||
* ```js
|
||||
* const fs = require('fs');
|
||||
* const readline = require('readline');
|
||||
*
|
||||
* const rl = readline.createInterface({
|
||||
* input: fs.createReadStream('sample.txt'),
|
||||
* crlfDelay: Infinity
|
||||
* });
|
||||
*
|
||||
* rl.on('line', (line) => {
|
||||
* console.log(`Line from file: ${line}`);
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* Currently, `for await...of` loop can be a bit slower. If `async` / `await`flow and speed are both essential, a mixed approach can be applied:
|
||||
*
|
||||
* ```js
|
||||
* const { once } = require('events');
|
||||
* const { createReadStream } = require('fs');
|
||||
* const { createInterface } = require('readline');
|
||||
*
|
||||
* (async function processLineByLine() {
|
||||
* try {
|
||||
* const rl = createInterface({
|
||||
* input: createReadStream('big-file.txt'),
|
||||
* crlfDelay: Infinity
|
||||
* });
|
||||
*
|
||||
* rl.on('line', (line) => {
|
||||
* // Process the line.
|
||||
* });
|
||||
*
|
||||
* await once(rl, 'close');
|
||||
*
|
||||
* console.log('File processed.');
|
||||
* } catch (err) {
|
||||
* console.error(err);
|
||||
* }
|
||||
* })();
|
||||
* ```
|
||||
* @since v0.7.7
|
||||
*/
|
||||
export function emitKeypressEvents(stream: NodeJS.ReadableStream, readlineInterface?: Interface): void;
|
||||
export type Direction = -1 | 0 | 1;
|
||||
export interface CursorPos {
|
||||
rows: number;
|
||||
cols: number;
|
||||
}
|
||||
/**
|
||||
* The `readline.clearLine()` method clears current line of given `TTY` stream
|
||||
* in a specified direction identified by `dir`.
|
||||
* @since v0.7.7
|
||||
* @param callback Invoked once the operation completes.
|
||||
* @return `false` if `stream` wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
|
||||
*/
|
||||
export function clearLine(stream: NodeJS.WritableStream, dir: Direction, callback?: () => void): boolean;
|
||||
/**
|
||||
* The `readline.clearScreenDown()` method clears the given `TTY` stream from
|
||||
* the current position of the cursor down.
|
||||
* @since v0.7.7
|
||||
* @param callback Invoked once the operation completes.
|
||||
* @return `false` if `stream` wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
|
||||
*/
|
||||
export function clearScreenDown(stream: NodeJS.WritableStream, callback?: () => void): boolean;
|
||||
/**
|
||||
* The `readline.cursorTo()` method moves cursor to the specified position in a
|
||||
* given `TTY` `stream`.
|
||||
* @since v0.7.7
|
||||
* @param callback Invoked once the operation completes.
|
||||
* @return `false` if `stream` wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
|
||||
*/
|
||||
export function cursorTo(stream: NodeJS.WritableStream, x: number, y?: number, callback?: () => void): boolean;
|
||||
/**
|
||||
* The `readline.moveCursor()` method moves the cursor _relative_ to its current
|
||||
* position in a given `TTY` `stream`.
|
||||
*
|
||||
* ## Example: Tiny CLI
|
||||
*
|
||||
* The following example illustrates the use of `readline.Interface` class to
|
||||
* implement a small command-line interface:
|
||||
*
|
||||
* ```js
|
||||
* const readline = require('readline');
|
||||
* const rl = readline.createInterface({
|
||||
* input: process.stdin,
|
||||
* output: process.stdout,
|
||||
* prompt: 'OHAI> '
|
||||
* });
|
||||
*
|
||||
* rl.prompt();
|
||||
*
|
||||
* rl.on('line', (line) => {
|
||||
* switch (line.trim()) {
|
||||
* case 'hello':
|
||||
* console.log('world!');
|
||||
* break;
|
||||
* default:
|
||||
* console.log(`Say what? I might have heard '${line.trim()}'`);
|
||||
* break;
|
||||
* }
|
||||
* rl.prompt();
|
||||
* }).on('close', () => {
|
||||
* console.log('Have a great day!');
|
||||
* process.exit(0);
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* ## Example: Read file stream line-by-Line
|
||||
*
|
||||
* A common use case for `readline` is to consume an input file one line at a
|
||||
* time. The easiest way to do so is leveraging the `fs.ReadStream` API as
|
||||
* well as a `for await...of` loop:
|
||||
*
|
||||
* ```js
|
||||
* const fs = require('fs');
|
||||
* const readline = require('readline');
|
||||
*
|
||||
* async function processLineByLine() {
|
||||
* const fileStream = fs.createReadStream('input.txt');
|
||||
*
|
||||
* const rl = readline.createInterface({
|
||||
* input: fileStream,
|
||||
* crlfDelay: Infinity
|
||||
* });
|
||||
* // Note: we use the crlfDelay option to recognize all instances of CR LF
|
||||
* // ('\r\n') in input.txt as a single line break.
|
||||
*
|
||||
* for await (const line of rl) {
|
||||
* // Each line in input.txt will be successively available here as `line`.
|
||||
* console.log(`Line from file: ${line}`);
|
||||
* }
|
||||
* }
|
||||
*
|
||||
* processLineByLine();
|
||||
* ```
|
||||
*
|
||||
* Alternatively, one could use the `'line'` event:
|
||||
*
|
||||
* ```js
|
||||
* const fs = require('fs');
|
||||
* const readline = require('readline');
|
||||
*
|
||||
* const rl = readline.createInterface({
|
||||
* input: fs.createReadStream('sample.txt'),
|
||||
* crlfDelay: Infinity
|
||||
* });
|
||||
*
|
||||
* rl.on('line', (line) => {
|
||||
* console.log(`Line from file: ${line}`);
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* Currently, `for await...of` loop can be a bit slower. If `async` / `await`flow and speed are both essential, a mixed approach can be applied:
|
||||
*
|
||||
* ```js
|
||||
* const { once } = require('events');
|
||||
* const { createReadStream } = require('fs');
|
||||
* const { createInterface } = require('readline');
|
||||
*
|
||||
* (async function processLineByLine() {
|
||||
* try {
|
||||
* const rl = createInterface({
|
||||
* input: createReadStream('big-file.txt'),
|
||||
* crlfDelay: Infinity
|
||||
* });
|
||||
*
|
||||
* rl.on('line', (line) => {
|
||||
* // Process the line.
|
||||
* });
|
||||
*
|
||||
* await once(rl, 'close');
|
||||
*
|
||||
* console.log('File processed.');
|
||||
* } catch (err) {
|
||||
* console.error(err);
|
||||
* }
|
||||
* })();
|
||||
* ```
|
||||
* @since v0.7.7
|
||||
* @param callback Invoked once the operation completes.
|
||||
* @return `false` if `stream` wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
|
||||
*/
|
||||
export function moveCursor(stream: NodeJS.WritableStream, dx: number, dy: number, callback?: () => void): boolean;
|
||||
}
|
||||
declare module 'node:readline' {
|
||||
export * from 'readline';
|
||||
}
|
143
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/readline/promises.d.ts
generated
vendored
143
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/readline/promises.d.ts
generated
vendored
@ -0,0 +1,143 @@
|
||||
/**
|
||||
* The `readline/promise` module provides an API for reading lines of input from a Readable stream one line at a time.
|
||||
*
|
||||
* @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/readline/promises.js)
|
||||
* @since v17.0.0
|
||||
*/
|
||||
declare module 'readline/promises' {
|
||||
import { Interface as _Interface, ReadLineOptions, Completer, AsyncCompleter, Direction } from 'node:readline';
|
||||
import { Abortable } from 'node:events';
|
||||
|
||||
class Interface extends _Interface {
|
||||
/**
|
||||
* The rl.question() method displays the query by writing it to the output, waits for user input to be provided on input,
|
||||
* then invokes the callback function passing the provided input as the first argument.
|
||||
*
|
||||
* When called, rl.question() will resume the input stream if it has been paused.
|
||||
*
|
||||
* If the readlinePromises.Interface was created with output set to null or undefined the query is not written.
|
||||
*
|
||||
* If the question is called after rl.close(), it returns a rejected promise.
|
||||
*
|
||||
* Example usage:
|
||||
*
|
||||
* ```js
|
||||
* const answer = await rl.question('What is your favorite food? ');
|
||||
* console.log(`Oh, so your favorite food is ${answer}`);
|
||||
* ```
|
||||
*
|
||||
* Using an AbortSignal to cancel a question.
|
||||
*
|
||||
* ```js
|
||||
* const signal = AbortSignal.timeout(10_000);
|
||||
*
|
||||
* signal.addEventListener('abort', () => {
|
||||
* console.log('The food question timed out');
|
||||
* }, { once: true });
|
||||
*
|
||||
* const answer = await rl.question('What is your favorite food? ', { signal });
|
||||
* console.log(`Oh, so your favorite food is ${answer}`);
|
||||
* ```
|
||||
*
|
||||
* @since v17.0.0
|
||||
* @param query A statement or query to write to output, prepended to the prompt.
|
||||
*/
|
||||
question(query: string): Promise<string>;
|
||||
question(query: string, options: Abortable): Promise<string>;
|
||||
}
|
||||
|
||||
class Readline {
|
||||
/**
|
||||
* @param stream A TTY stream.
|
||||
*/
|
||||
constructor(stream: NodeJS.WritableStream, options?: { autoCommit?: boolean });
|
||||
/**
|
||||
* The `rl.clearLine()` method adds to the internal list of pending action an action that clears current line of the associated `stream` in a specified direction identified by `dir`.
|
||||
* Call `rl.commit()` to see the effect of this method, unless `autoCommit: true` was passed to the constructor.
|
||||
*/
|
||||
clearLine(dir: Direction): this;
|
||||
/**
|
||||
* The `rl.clearScreenDown()` method adds to the internal list of pending action an action that clears the associated `stream` from the current position of the cursor down.
|
||||
* Call `rl.commit()` to see the effect of this method, unless `autoCommit: true` was passed to the constructor.
|
||||
*/
|
||||
clearScreenDown(): this;
|
||||
/**
|
||||
* The `rl.commit()` method sends all the pending actions to the associated `stream` and clears the internal list of pending actions.
|
||||
*/
|
||||
commit(): Promise<void>;
|
||||
/**
|
||||
* The `rl.cursorTo()` method adds to the internal list of pending action an action that moves cursor to the specified position in the associated `stream`.
|
||||
* Call `rl.commit()` to see the effect of this method, unless `autoCommit: true` was passed to the constructor.
|
||||
*/
|
||||
cursorTo(x: number, y?: number): this;
|
||||
/**
|
||||
* The `rl.moveCursor()` method adds to the internal list of pending action an action that moves the cursor relative to its current position in the associated `stream`.
|
||||
* Call `rl.commit()` to see the effect of this method, unless autoCommit: true was passed to the constructor.
|
||||
*/
|
||||
moveCursor(dx: number, dy: number): this;
|
||||
/**
|
||||
* The `rl.rollback()` method clears the internal list of pending actions without sending it to the associated `stream`.
|
||||
*/
|
||||
rollback(): this;
|
||||
}
|
||||
|
||||
/**
|
||||
* The `readlinePromises.createInterface()` method creates a new `readlinePromises.Interface` instance.
|
||||
*
|
||||
* ```js
|
||||
* const readlinePromises = require('node:readline/promises');
|
||||
* const rl = readlinePromises.createInterface({
|
||||
* input: process.stdin,
|
||||
* output: process.stdout
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* Once the `readlinePromises.Interface` instance is created, the most common case is to listen for the `'line'` event:
|
||||
*
|
||||
* ```js
|
||||
* rl.on('line', (line) => {
|
||||
* console.log(`Received: ${line}`);
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* If `terminal` is `true` for this instance then the `output` stream will get the best compatibility if it defines an `output.columns` property,
|
||||
* and emits a `'resize'` event on the `output`, if or when the columns ever change (`process.stdout` does this automatically when it is a TTY).
|
||||
*
|
||||
* ## Use of the `completer` function
|
||||
*
|
||||
* The `completer` function takes the current line entered by the user as an argument, and returns an `Array` with 2 entries:
|
||||
*
|
||||
* - An Array with matching entries for the completion.
|
||||
* - The substring that was used for the matching.
|
||||
*
|
||||
* For instance: `[[substr1, substr2, ...], originalsubstring]`.
|
||||
*
|
||||
* ```js
|
||||
* function completer(line) {
|
||||
* const completions = '.help .error .exit .quit .q'.split(' ');
|
||||
* const hits = completions.filter((c) => c.startsWith(line));
|
||||
* // Show all completions if none found
|
||||
* return [hits.length ? hits : completions, line];
|
||||
* }
|
||||
* ```
|
||||
*
|
||||
* The `completer` function can also returns a `Promise`, or be asynchronous:
|
||||
*
|
||||
* ```js
|
||||
* async function completer(linePartial) {
|
||||
* await someAsyncWork();
|
||||
* return [['123'], linePartial];
|
||||
* }
|
||||
* ```
|
||||
*/
|
||||
function createInterface(
|
||||
input: NodeJS.ReadableStream,
|
||||
output?: NodeJS.WritableStream,
|
||||
completer?: Completer | AsyncCompleter,
|
||||
terminal?: boolean,
|
||||
): Interface;
|
||||
function createInterface(options: ReadLineOptions): Interface;
|
||||
}
|
||||
declare module 'node:readline/promises' {
|
||||
export * from 'readline/promises';
|
||||
}
|
@ -0,0 +1,424 @@
|
||||
/**
|
||||
* The `repl` module provides a Read-Eval-Print-Loop (REPL) implementation that
|
||||
* is available both as a standalone program or includible in other applications.
|
||||
* It can be accessed using:
|
||||
*
|
||||
* ```js
|
||||
* const repl = require('repl');
|
||||
* ```
|
||||
* @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/repl.js)
|
||||
*/
|
||||
declare module 'repl' {
|
||||
import { Interface, Completer, AsyncCompleter } from 'node:readline';
|
||||
import { Context } from 'node:vm';
|
||||
import { InspectOptions } from 'node:util';
|
||||
interface ReplOptions {
|
||||
/**
|
||||
* The input prompt to display.
|
||||
* @default "> "
|
||||
*/
|
||||
prompt?: string | undefined;
|
||||
/**
|
||||
* The `Readable` stream from which REPL input will be read.
|
||||
* @default process.stdin
|
||||
*/
|
||||
input?: NodeJS.ReadableStream | undefined;
|
||||
/**
|
||||
* The `Writable` stream to which REPL output will be written.
|
||||
* @default process.stdout
|
||||
*/
|
||||
output?: NodeJS.WritableStream | undefined;
|
||||
/**
|
||||
* If `true`, specifies that the output should be treated as a TTY terminal, and have
|
||||
* ANSI/VT100 escape codes written to it.
|
||||
* Default: checking the value of the `isTTY` property on the output stream upon
|
||||
* instantiation.
|
||||
*/
|
||||
terminal?: boolean | undefined;
|
||||
/**
|
||||
* The function to be used when evaluating each given line of input.
|
||||
* Default: an async wrapper for the JavaScript `eval()` function. An `eval` function can
|
||||
* error with `repl.Recoverable` to indicate the input was incomplete and prompt for
|
||||
* additional lines.
|
||||
*
|
||||
* @see https://nodejs.org/dist/latest-v10.x/docs/api/repl.html#repl_default_evaluation
|
||||
* @see https://nodejs.org/dist/latest-v10.x/docs/api/repl.html#repl_custom_evaluation_functions
|
||||
*/
|
||||
eval?: REPLEval | undefined;
|
||||
/**
|
||||
* Defines if the repl prints output previews or not.
|
||||
* @default `true` Always `false` in case `terminal` is falsy.
|
||||
*/
|
||||
preview?: boolean | undefined;
|
||||
/**
|
||||
* If `true`, specifies that the default `writer` function should include ANSI color
|
||||
* styling to REPL output. If a custom `writer` function is provided then this has no
|
||||
* effect.
|
||||
* Default: the REPL instance's `terminal` value.
|
||||
*/
|
||||
useColors?: boolean | undefined;
|
||||
/**
|
||||
* If `true`, specifies that the default evaluation function will use the JavaScript
|
||||
* `global` as the context as opposed to creating a new separate context for the REPL
|
||||
* instance. The node CLI REPL sets this value to `true`.
|
||||
* Default: `false`.
|
||||
*/
|
||||
useGlobal?: boolean | undefined;
|
||||
/**
|
||||
* If `true`, specifies that the default writer will not output the return value of a
|
||||
* command if it evaluates to `undefined`.
|
||||
* Default: `false`.
|
||||
*/
|
||||
ignoreUndefined?: boolean | undefined;
|
||||
/**
|
||||
* The function to invoke to format the output of each command before writing to `output`.
|
||||
* Default: a wrapper for `util.inspect`.
|
||||
*
|
||||
* @see https://nodejs.org/dist/latest-v10.x/docs/api/repl.html#repl_customizing_repl_output
|
||||
*/
|
||||
writer?: REPLWriter | undefined;
|
||||
/**
|
||||
* An optional function used for custom Tab auto completion.
|
||||
*
|
||||
* @see https://nodejs.org/dist/latest-v11.x/docs/api/readline.html#readline_use_of_the_completer_function
|
||||
*/
|
||||
completer?: Completer | AsyncCompleter | undefined;
|
||||
/**
|
||||
* A flag that specifies whether the default evaluator executes all JavaScript commands in
|
||||
* strict mode or default (sloppy) mode.
|
||||
* Accepted values are:
|
||||
* - `repl.REPL_MODE_SLOPPY` - evaluates expressions in sloppy mode.
|
||||
* - `repl.REPL_MODE_STRICT` - evaluates expressions in strict mode. This is equivalent to
|
||||
* prefacing every repl statement with `'use strict'`.
|
||||
*/
|
||||
replMode?: typeof REPL_MODE_SLOPPY | typeof REPL_MODE_STRICT | undefined;
|
||||
/**
|
||||
* Stop evaluating the current piece of code when `SIGINT` is received, i.e. `Ctrl+C` is
|
||||
* pressed. This cannot be used together with a custom `eval` function.
|
||||
* Default: `false`.
|
||||
*/
|
||||
breakEvalOnSigint?: boolean | undefined;
|
||||
}
|
||||
type REPLEval = (this: REPLServer, evalCmd: string, context: Context, file: string, cb: (err: Error | null, result: any) => void) => void;
|
||||
type REPLWriter = (this: REPLServer, obj: any) => string;
|
||||
/**
|
||||
* This is the default "writer" value, if none is passed in the REPL options,
|
||||
* and it can be overridden by custom print functions.
|
||||
*/
|
||||
const writer: REPLWriter & {
|
||||
options: InspectOptions;
|
||||
};
|
||||
type REPLCommandAction = (this: REPLServer, text: string) => void;
|
||||
interface REPLCommand {
|
||||
/**
|
||||
* Help text to be displayed when `.help` is entered.
|
||||
*/
|
||||
help?: string | undefined;
|
||||
/**
|
||||
* The function to execute, optionally accepting a single string argument.
|
||||
*/
|
||||
action: REPLCommandAction;
|
||||
}
|
||||
/**
|
||||
* Instances of `repl.REPLServer` are created using the {@link start} method
|
||||
* or directly using the JavaScript `new` keyword.
|
||||
*
|
||||
* ```js
|
||||
* const repl = require('repl');
|
||||
*
|
||||
* const options = { useColors: true };
|
||||
*
|
||||
* const firstInstance = repl.start(options);
|
||||
* const secondInstance = new repl.REPLServer(options);
|
||||
* ```
|
||||
* @since v0.1.91
|
||||
*/
|
||||
class REPLServer extends Interface {
|
||||
/**
|
||||
* The `vm.Context` provided to the `eval` function to be used for JavaScript
|
||||
* evaluation.
|
||||
*/
|
||||
readonly context: Context;
|
||||
/**
|
||||
* @deprecated since v14.3.0 - Use `input` instead.
|
||||
*/
|
||||
readonly inputStream: NodeJS.ReadableStream;
|
||||
/**
|
||||
* @deprecated since v14.3.0 - Use `output` instead.
|
||||
*/
|
||||
readonly outputStream: NodeJS.WritableStream;
|
||||
/**
|
||||
* The `Readable` stream from which REPL input will be read.
|
||||
*/
|
||||
readonly input: NodeJS.ReadableStream;
|
||||
/**
|
||||
* The `Writable` stream to which REPL output will be written.
|
||||
*/
|
||||
readonly output: NodeJS.WritableStream;
|
||||
/**
|
||||
* The commands registered via `replServer.defineCommand()`.
|
||||
*/
|
||||
readonly commands: NodeJS.ReadOnlyDict<REPLCommand>;
|
||||
/**
|
||||
* A value indicating whether the REPL is currently in "editor mode".
|
||||
*
|
||||
* @see https://nodejs.org/dist/latest-v10.x/docs/api/repl.html#repl_commands_and_special_keys
|
||||
*/
|
||||
readonly editorMode: boolean;
|
||||
/**
|
||||
* A value indicating whether the `_` variable has been assigned.
|
||||
*
|
||||
* @see https://nodejs.org/dist/latest-v10.x/docs/api/repl.html#repl_assignment_of_the_underscore_variable
|
||||
*/
|
||||
readonly underscoreAssigned: boolean;
|
||||
/**
|
||||
* The last evaluation result from the REPL (assigned to the `_` variable inside of the REPL).
|
||||
*
|
||||
* @see https://nodejs.org/dist/latest-v10.x/docs/api/repl.html#repl_assignment_of_the_underscore_variable
|
||||
*/
|
||||
readonly last: any;
|
||||
/**
|
||||
* A value indicating whether the `_error` variable has been assigned.
|
||||
*
|
||||
* @since v9.8.0
|
||||
* @see https://nodejs.org/dist/latest-v10.x/docs/api/repl.html#repl_assignment_of_the_underscore_variable
|
||||
*/
|
||||
readonly underscoreErrAssigned: boolean;
|
||||
/**
|
||||
* The last error raised inside the REPL (assigned to the `_error` variable inside of the REPL).
|
||||
*
|
||||
* @since v9.8.0
|
||||
* @see https://nodejs.org/dist/latest-v10.x/docs/api/repl.html#repl_assignment_of_the_underscore_variable
|
||||
*/
|
||||
readonly lastError: any;
|
||||
/**
|
||||
* Specified in the REPL options, this is the function to be used when evaluating each
|
||||
* given line of input. If not specified in the REPL options, this is an async wrapper
|
||||
* for the JavaScript `eval()` function.
|
||||
*/
|
||||
readonly eval: REPLEval;
|
||||
/**
|
||||
* Specified in the REPL options, this is a value indicating whether the default
|
||||
* `writer` function should include ANSI color styling to REPL output.
|
||||
*/
|
||||
readonly useColors: boolean;
|
||||
/**
|
||||
* Specified in the REPL options, this is a value indicating whether the default `eval`
|
||||
* function will use the JavaScript `global` as the context as opposed to creating a new
|
||||
* separate context for the REPL instance.
|
||||
*/
|
||||
readonly useGlobal: boolean;
|
||||
/**
|
||||
* Specified in the REPL options, this is a value indicating whether the default `writer`
|
||||
* function should output the result of a command if it evaluates to `undefined`.
|
||||
*/
|
||||
readonly ignoreUndefined: boolean;
|
||||
/**
|
||||
* Specified in the REPL options, this is the function to invoke to format the output of
|
||||
* each command before writing to `outputStream`. If not specified in the REPL options,
|
||||
* this will be a wrapper for `util.inspect`.
|
||||
*/
|
||||
readonly writer: REPLWriter;
|
||||
/**
|
||||
* Specified in the REPL options, this is the function to use for custom Tab auto-completion.
|
||||
*/
|
||||
readonly completer: Completer | AsyncCompleter;
|
||||
/**
|
||||
* Specified in the REPL options, this is a flag that specifies whether the default `eval`
|
||||
* function should execute all JavaScript commands in strict mode or default (sloppy) mode.
|
||||
* Possible values are:
|
||||
* - `repl.REPL_MODE_SLOPPY` - evaluates expressions in sloppy mode.
|
||||
* - `repl.REPL_MODE_STRICT` - evaluates expressions in strict mode. This is equivalent to
|
||||
* prefacing every repl statement with `'use strict'`.
|
||||
*/
|
||||
readonly replMode: typeof REPL_MODE_SLOPPY | typeof REPL_MODE_STRICT;
|
||||
/**
|
||||
* NOTE: According to the documentation:
|
||||
*
|
||||
* > Instances of `repl.REPLServer` are created using the `repl.start()` method and
|
||||
* > _should not_ be created directly using the JavaScript `new` keyword.
|
||||
*
|
||||
* `REPLServer` cannot be subclassed due to implementation specifics in NodeJS.
|
||||
*
|
||||
* @see https://nodejs.org/dist/latest-v10.x/docs/api/repl.html#repl_class_replserver
|
||||
*/
|
||||
private constructor();
|
||||
/**
|
||||
* The `replServer.defineCommand()` method is used to add new `.`\-prefixed commands
|
||||
* to the REPL instance. Such commands are invoked by typing a `.` followed by the`keyword`. The `cmd` is either a `Function` or an `Object` with the following
|
||||
* properties:
|
||||
*
|
||||
* The following example shows two new commands added to the REPL instance:
|
||||
*
|
||||
* ```js
|
||||
* const repl = require('repl');
|
||||
*
|
||||
* const replServer = repl.start({ prompt: '> ' });
|
||||
* replServer.defineCommand('sayhello', {
|
||||
* help: 'Say hello',
|
||||
* action(name) {
|
||||
* this.clearBufferedCommand();
|
||||
* console.log(`Hello, ${name}!`);
|
||||
* this.displayPrompt();
|
||||
* }
|
||||
* });
|
||||
* replServer.defineCommand('saybye', function saybye() {
|
||||
* console.log('Goodbye!');
|
||||
* this.close();
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* The new commands can then be used from within the REPL instance:
|
||||
*
|
||||
* ```console
|
||||
* > .sayhello Node.js User
|
||||
* Hello, Node.js User!
|
||||
* > .saybye
|
||||
* Goodbye!
|
||||
* ```
|
||||
* @since v0.3.0
|
||||
* @param keyword The command keyword (_without_ a leading `.` character).
|
||||
* @param cmd The function to invoke when the command is processed.
|
||||
*/
|
||||
defineCommand(keyword: string, cmd: REPLCommandAction | REPLCommand): void;
|
||||
/**
|
||||
* The `replServer.displayPrompt()` method readies the REPL instance for input
|
||||
* from the user, printing the configured `prompt` to a new line in the `output`and resuming the `input` to accept new input.
|
||||
*
|
||||
* When multi-line input is being entered, an ellipsis is printed rather than the
|
||||
* 'prompt'.
|
||||
*
|
||||
* When `preserveCursor` is `true`, the cursor placement will not be reset to `0`.
|
||||
*
|
||||
* The `replServer.displayPrompt` method is primarily intended to be called from
|
||||
* within the action function for commands registered using the`replServer.defineCommand()` method.
|
||||
* @since v0.1.91
|
||||
*/
|
||||
displayPrompt(preserveCursor?: boolean): void;
|
||||
/**
|
||||
* The `replServer.clearBufferedCommand()` method clears any command that has been
|
||||
* buffered but not yet executed. This method is primarily intended to be
|
||||
* called from within the action function for commands registered using the`replServer.defineCommand()` method.
|
||||
* @since v9.0.0
|
||||
*/
|
||||
clearBufferedCommand(): void;
|
||||
/**
|
||||
* Initializes a history log file for the REPL instance. When executing the
|
||||
* Node.js binary and using the command-line REPL, a history file is initialized
|
||||
* by default. However, this is not the case when creating a REPL
|
||||
* programmatically. Use this method to initialize a history log file when working
|
||||
* with REPL instances programmatically.
|
||||
* @since v11.10.0
|
||||
* @param historyPath the path to the history file
|
||||
* @param callback called when history writes are ready or upon error
|
||||
*/
|
||||
setupHistory(path: string, callback: (err: Error | null, repl: this) => void): void;
|
||||
/**
|
||||
* events.EventEmitter
|
||||
* 1. close - inherited from `readline.Interface`
|
||||
* 2. line - inherited from `readline.Interface`
|
||||
* 3. pause - inherited from `readline.Interface`
|
||||
* 4. resume - inherited from `readline.Interface`
|
||||
* 5. SIGCONT - inherited from `readline.Interface`
|
||||
* 6. SIGINT - inherited from `readline.Interface`
|
||||
* 7. SIGTSTP - inherited from `readline.Interface`
|
||||
* 8. exit
|
||||
* 9. reset
|
||||
*/
|
||||
addListener(event: string, listener: (...args: any[]) => void): this;
|
||||
addListener(event: 'close', listener: () => void): this;
|
||||
addListener(event: 'line', listener: (input: string) => void): this;
|
||||
addListener(event: 'pause', listener: () => void): this;
|
||||
addListener(event: 'resume', listener: () => void): this;
|
||||
addListener(event: 'SIGCONT', listener: () => void): this;
|
||||
addListener(event: 'SIGINT', listener: () => void): this;
|
||||
addListener(event: 'SIGTSTP', listener: () => void): this;
|
||||
addListener(event: 'exit', listener: () => void): this;
|
||||
addListener(event: 'reset', listener: (context: Context) => void): this;
|
||||
emit(event: string | symbol, ...args: any[]): boolean;
|
||||
emit(event: 'close'): boolean;
|
||||
emit(event: 'line', input: string): boolean;
|
||||
emit(event: 'pause'): boolean;
|
||||
emit(event: 'resume'): boolean;
|
||||
emit(event: 'SIGCONT'): boolean;
|
||||
emit(event: 'SIGINT'): boolean;
|
||||
emit(event: 'SIGTSTP'): boolean;
|
||||
emit(event: 'exit'): boolean;
|
||||
emit(event: 'reset', context: Context): boolean;
|
||||
on(event: string, listener: (...args: any[]) => void): this;
|
||||
on(event: 'close', listener: () => void): this;
|
||||
on(event: 'line', listener: (input: string) => void): this;
|
||||
on(event: 'pause', listener: () => void): this;
|
||||
on(event: 'resume', listener: () => void): this;
|
||||
on(event: 'SIGCONT', listener: () => void): this;
|
||||
on(event: 'SIGINT', listener: () => void): this;
|
||||
on(event: 'SIGTSTP', listener: () => void): this;
|
||||
on(event: 'exit', listener: () => void): this;
|
||||
on(event: 'reset', listener: (context: Context) => void): this;
|
||||
once(event: string, listener: (...args: any[]) => void): this;
|
||||
once(event: 'close', listener: () => void): this;
|
||||
once(event: 'line', listener: (input: string) => void): this;
|
||||
once(event: 'pause', listener: () => void): this;
|
||||
once(event: 'resume', listener: () => void): this;
|
||||
once(event: 'SIGCONT', listener: () => void): this;
|
||||
once(event: 'SIGINT', listener: () => void): this;
|
||||
once(event: 'SIGTSTP', listener: () => void): this;
|
||||
once(event: 'exit', listener: () => void): this;
|
||||
once(event: 'reset', listener: (context: Context) => void): this;
|
||||
prependListener(event: string, listener: (...args: any[]) => void): this;
|
||||
prependListener(event: 'close', listener: () => void): this;
|
||||
prependListener(event: 'line', listener: (input: string) => void): this;
|
||||
prependListener(event: 'pause', listener: () => void): this;
|
||||
prependListener(event: 'resume', listener: () => void): this;
|
||||
prependListener(event: 'SIGCONT', listener: () => void): this;
|
||||
prependListener(event: 'SIGINT', listener: () => void): this;
|
||||
prependListener(event: 'SIGTSTP', listener: () => void): this;
|
||||
prependListener(event: 'exit', listener: () => void): this;
|
||||
prependListener(event: 'reset', listener: (context: Context) => void): this;
|
||||
prependOnceListener(event: string, listener: (...args: any[]) => void): this;
|
||||
prependOnceListener(event: 'close', listener: () => void): this;
|
||||
prependOnceListener(event: 'line', listener: (input: string) => void): this;
|
||||
prependOnceListener(event: 'pause', listener: () => void): this;
|
||||
prependOnceListener(event: 'resume', listener: () => void): this;
|
||||
prependOnceListener(event: 'SIGCONT', listener: () => void): this;
|
||||
prependOnceListener(event: 'SIGINT', listener: () => void): this;
|
||||
prependOnceListener(event: 'SIGTSTP', listener: () => void): this;
|
||||
prependOnceListener(event: 'exit', listener: () => void): this;
|
||||
prependOnceListener(event: 'reset', listener: (context: Context) => void): this;
|
||||
}
|
||||
/**
|
||||
* A flag passed in the REPL options. Evaluates expressions in sloppy mode.
|
||||
*/
|
||||
const REPL_MODE_SLOPPY: unique symbol;
|
||||
/**
|
||||
* A flag passed in the REPL options. Evaluates expressions in strict mode.
|
||||
* This is equivalent to prefacing every repl statement with `'use strict'`.
|
||||
*/
|
||||
const REPL_MODE_STRICT: unique symbol;
|
||||
/**
|
||||
* The `repl.start()` method creates and starts a {@link REPLServer} instance.
|
||||
*
|
||||
* If `options` is a string, then it specifies the input prompt:
|
||||
*
|
||||
* ```js
|
||||
* const repl = require('repl');
|
||||
*
|
||||
* // a Unix style prompt
|
||||
* repl.start('$ ');
|
||||
* ```
|
||||
* @since v0.1.91
|
||||
*/
|
||||
function start(options?: string | ReplOptions): REPLServer;
|
||||
/**
|
||||
* Indicates a recoverable error that a `REPLServer` can use to support multi-line input.
|
||||
*
|
||||
* @see https://nodejs.org/dist/latest-v10.x/docs/api/repl.html#repl_recoverable_errors
|
||||
*/
|
||||
class Recoverable extends SyntaxError {
|
||||
err: Error;
|
||||
constructor(err: Error);
|
||||
}
|
||||
}
|
||||
declare module 'node:repl' {
|
||||
export * from 'repl';
|
||||
}
|
File diff suppressed because it is too large
Load Diff
24
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/stream/consumers.d.ts
generated
vendored
24
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/stream/consumers.d.ts
generated
vendored
@ -0,0 +1,24 @@
|
||||
// Duplicates of interface in lib.dom.ts.
|
||||
// Duplicated here rather than referencing lib.dom.ts because doing so causes lib.dom.ts to be loaded for "test-all"
|
||||
// Which in turn causes tests to pass that shouldn't pass.
|
||||
//
|
||||
// This interface is not, and should not be, exported.
|
||||
interface Blob {
|
||||
readonly size: number;
|
||||
readonly type: string;
|
||||
arrayBuffer(): Promise<ArrayBuffer>;
|
||||
slice(start?: number, end?: number, contentType?: string): Blob;
|
||||
stream(): NodeJS.ReadableStream;
|
||||
text(): Promise<string>;
|
||||
}
|
||||
declare module 'stream/consumers' {
|
||||
import { Readable } from 'node:stream';
|
||||
function buffer(stream: NodeJS.ReadableStream | Readable | AsyncIterator<any>): Promise<Buffer>;
|
||||
function text(stream: NodeJS.ReadableStream | Readable | AsyncIterator<any>): Promise<string>;
|
||||
function arrayBuffer(stream: NodeJS.ReadableStream | Readable | AsyncIterator<any>): Promise<ArrayBuffer>;
|
||||
function blob(stream: NodeJS.ReadableStream | Readable | AsyncIterator<any>): Promise<Blob>;
|
||||
function json(stream: NodeJS.ReadableStream | Readable | AsyncIterator<any>): Promise<unknown>;
|
||||
}
|
||||
declare module 'node:stream/consumers' {
|
||||
export * from 'stream/consumers';
|
||||
}
|
42
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/stream/promises.d.ts
generated
vendored
42
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/stream/promises.d.ts
generated
vendored
@ -0,0 +1,42 @@
|
||||
declare module 'stream/promises' {
|
||||
import { FinishedOptions, PipelineSource, PipelineTransform, PipelineDestination, PipelinePromise, PipelineOptions } from 'node:stream';
|
||||
function finished(stream: NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream, options?: FinishedOptions): Promise<void>;
|
||||
function pipeline<A extends PipelineSource<any>, B extends PipelineDestination<A, any>>(source: A, destination: B, options?: PipelineOptions): PipelinePromise<B>;
|
||||
function pipeline<A extends PipelineSource<any>, T1 extends PipelineTransform<A, any>, B extends PipelineDestination<T1, any>>(
|
||||
source: A,
|
||||
transform1: T1,
|
||||
destination: B,
|
||||
options?: PipelineOptions
|
||||
): PipelinePromise<B>;
|
||||
function pipeline<A extends PipelineSource<any>, T1 extends PipelineTransform<A, any>, T2 extends PipelineTransform<T1, any>, B extends PipelineDestination<T2, any>>(
|
||||
source: A,
|
||||
transform1: T1,
|
||||
transform2: T2,
|
||||
destination: B,
|
||||
options?: PipelineOptions
|
||||
): PipelinePromise<B>;
|
||||
function pipeline<
|
||||
A extends PipelineSource<any>,
|
||||
T1 extends PipelineTransform<A, any>,
|
||||
T2 extends PipelineTransform<T1, any>,
|
||||
T3 extends PipelineTransform<T2, any>,
|
||||
B extends PipelineDestination<T3, any>
|
||||
>(source: A, transform1: T1, transform2: T2, transform3: T3, destination: B, options?: PipelineOptions): PipelinePromise<B>;
|
||||
function pipeline<
|
||||
A extends PipelineSource<any>,
|
||||
T1 extends PipelineTransform<A, any>,
|
||||
T2 extends PipelineTransform<T1, any>,
|
||||
T3 extends PipelineTransform<T2, any>,
|
||||
T4 extends PipelineTransform<T3, any>,
|
||||
B extends PipelineDestination<T4, any>
|
||||
>(source: A, transform1: T1, transform2: T2, transform3: T3, transform4: T4, destination: B, options?: PipelineOptions): PipelinePromise<B>;
|
||||
function pipeline(streams: ReadonlyArray<NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream>, options?: PipelineOptions): Promise<void>;
|
||||
function pipeline(
|
||||
stream1: NodeJS.ReadableStream,
|
||||
stream2: NodeJS.ReadWriteStream | NodeJS.WritableStream,
|
||||
...streams: Array<NodeJS.ReadWriteStream | NodeJS.WritableStream | PipelineOptions>
|
||||
): Promise<void>;
|
||||
}
|
||||
declare module 'node:stream/promises' {
|
||||
export * from 'stream/promises';
|
||||
}
|
330
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/stream/web.d.ts
generated
vendored
330
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/stream/web.d.ts
generated
vendored
@ -0,0 +1,330 @@
|
||||
declare module 'stream/web' {
|
||||
// stub module, pending copy&paste from .d.ts or manual impl
|
||||
// copy from lib.dom.d.ts
|
||||
interface ReadableWritablePair<R = any, W = any> {
|
||||
readable: ReadableStream<R>;
|
||||
/**
|
||||
* Provides a convenient, chainable way of piping this readable stream
|
||||
* through a transform stream (or any other { writable, readable }
|
||||
* pair). It simply pipes the stream into the writable side of the
|
||||
* supplied pair, and returns the readable side for further use.
|
||||
*
|
||||
* Piping a stream will lock it for the duration of the pipe, preventing
|
||||
* any other consumer from acquiring a reader.
|
||||
*/
|
||||
writable: WritableStream<W>;
|
||||
}
|
||||
interface StreamPipeOptions {
|
||||
preventAbort?: boolean;
|
||||
preventCancel?: boolean;
|
||||
/**
|
||||
* Pipes this readable stream to a given writable stream destination.
|
||||
* The way in which the piping process behaves under various error
|
||||
* conditions can be customized with a number of passed options. It
|
||||
* returns a promise that fulfills when the piping process completes
|
||||
* successfully, or rejects if any errors were encountered.
|
||||
*
|
||||
* Piping a stream will lock it for the duration of the pipe, preventing
|
||||
* any other consumer from acquiring a reader.
|
||||
*
|
||||
* Errors and closures of the source and destination streams propagate
|
||||
* as follows:
|
||||
*
|
||||
* An error in this source readable stream will abort destination,
|
||||
* unless preventAbort is truthy. The returned promise will be rejected
|
||||
* with the source's error, or with any error that occurs during
|
||||
* aborting the destination.
|
||||
*
|
||||
* An error in destination will cancel this source readable stream,
|
||||
* unless preventCancel is truthy. The returned promise will be rejected
|
||||
* with the destination's error, or with any error that occurs during
|
||||
* canceling the source.
|
||||
*
|
||||
* When this source readable stream closes, destination will be closed,
|
||||
* unless preventClose is truthy. The returned promise will be fulfilled
|
||||
* once this process completes, unless an error is encountered while
|
||||
* closing the destination, in which case it will be rejected with that
|
||||
* error.
|
||||
*
|
||||
* If destination starts out closed or closing, this source readable
|
||||
* stream will be canceled, unless preventCancel is true. The returned
|
||||
* promise will be rejected with an error indicating piping to a closed
|
||||
* stream failed, or with any error that occurs during canceling the
|
||||
* source.
|
||||
*
|
||||
* The signal option can be set to an AbortSignal to allow aborting an
|
||||
* ongoing pipe operation via the corresponding AbortController. In this
|
||||
* case, this source readable stream will be canceled, and destination
|
||||
* aborted, unless the respective options preventCancel or preventAbort
|
||||
* are set.
|
||||
*/
|
||||
preventClose?: boolean;
|
||||
signal?: AbortSignal;
|
||||
}
|
||||
interface ReadableStreamGenericReader {
|
||||
readonly closed: Promise<undefined>;
|
||||
cancel(reason?: any): Promise<void>;
|
||||
}
|
||||
interface ReadableStreamDefaultReadValueResult<T> {
|
||||
done: false;
|
||||
value: T;
|
||||
}
|
||||
interface ReadableStreamDefaultReadDoneResult {
|
||||
done: true;
|
||||
value?: undefined;
|
||||
}
|
||||
type ReadableStreamController<T> = ReadableStreamDefaultController<T>;
|
||||
type ReadableStreamDefaultReadResult<T> = ReadableStreamDefaultReadValueResult<T> | ReadableStreamDefaultReadDoneResult;
|
||||
interface ReadableByteStreamControllerCallback {
|
||||
(controller: ReadableByteStreamController): void | PromiseLike<void>;
|
||||
}
|
||||
interface UnderlyingSinkAbortCallback {
|
||||
(reason?: any): void | PromiseLike<void>;
|
||||
}
|
||||
interface UnderlyingSinkCloseCallback {
|
||||
(): void | PromiseLike<void>;
|
||||
}
|
||||
interface UnderlyingSinkStartCallback {
|
||||
(controller: WritableStreamDefaultController): any;
|
||||
}
|
||||
interface UnderlyingSinkWriteCallback<W> {
|
||||
(chunk: W, controller: WritableStreamDefaultController): void | PromiseLike<void>;
|
||||
}
|
||||
interface UnderlyingSourceCancelCallback {
|
||||
(reason?: any): void | PromiseLike<void>;
|
||||
}
|
||||
interface UnderlyingSourcePullCallback<R> {
|
||||
(controller: ReadableStreamController<R>): void | PromiseLike<void>;
|
||||
}
|
||||
interface UnderlyingSourceStartCallback<R> {
|
||||
(controller: ReadableStreamController<R>): any;
|
||||
}
|
||||
interface TransformerFlushCallback<O> {
|
||||
(controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
|
||||
}
|
||||
interface TransformerStartCallback<O> {
|
||||
(controller: TransformStreamDefaultController<O>): any;
|
||||
}
|
||||
interface TransformerTransformCallback<I, O> {
|
||||
(chunk: I, controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
|
||||
}
|
||||
interface UnderlyingByteSource {
|
||||
autoAllocateChunkSize?: number;
|
||||
cancel?: ReadableStreamErrorCallback;
|
||||
pull?: ReadableByteStreamControllerCallback;
|
||||
start?: ReadableByteStreamControllerCallback;
|
||||
type: 'bytes';
|
||||
}
|
||||
interface UnderlyingSource<R = any> {
|
||||
cancel?: UnderlyingSourceCancelCallback;
|
||||
pull?: UnderlyingSourcePullCallback<R>;
|
||||
start?: UnderlyingSourceStartCallback<R>;
|
||||
type?: undefined;
|
||||
}
|
||||
interface UnderlyingSink<W = any> {
|
||||
abort?: UnderlyingSinkAbortCallback;
|
||||
close?: UnderlyingSinkCloseCallback;
|
||||
start?: UnderlyingSinkStartCallback;
|
||||
type?: undefined;
|
||||
write?: UnderlyingSinkWriteCallback<W>;
|
||||
}
|
||||
interface ReadableStreamErrorCallback {
|
||||
(reason: any): void | PromiseLike<void>;
|
||||
}
|
||||
/** This Streams API interface represents a readable stream of byte data. */
|
||||
interface ReadableStream<R = any> {
|
||||
readonly locked: boolean;
|
||||
cancel(reason?: any): Promise<void>;
|
||||
getReader(): ReadableStreamDefaultReader<R>;
|
||||
pipeThrough<T>(transform: ReadableWritablePair<T, R>, options?: StreamPipeOptions): ReadableStream<T>;
|
||||
pipeTo(destination: WritableStream<R>, options?: StreamPipeOptions): Promise<void>;
|
||||
tee(): [ReadableStream<R>, ReadableStream<R>];
|
||||
values(options?: { preventCancel?: boolean }): AsyncIterableIterator<R>;
|
||||
[Symbol.asyncIterator](): AsyncIterableIterator<R>;
|
||||
}
|
||||
const ReadableStream: {
|
||||
prototype: ReadableStream;
|
||||
new (underlyingSource: UnderlyingByteSource, strategy?: QueuingStrategy<Uint8Array>): ReadableStream<Uint8Array>;
|
||||
new <R = any>(underlyingSource?: UnderlyingSource<R>, strategy?: QueuingStrategy<R>): ReadableStream<R>;
|
||||
};
|
||||
interface ReadableStreamDefaultReader<R = any> extends ReadableStreamGenericReader {
|
||||
read(): Promise<ReadableStreamDefaultReadResult<R>>;
|
||||
releaseLock(): void;
|
||||
}
|
||||
const ReadableStreamDefaultReader: {
|
||||
prototype: ReadableStreamDefaultReader;
|
||||
new <R = any>(stream: ReadableStream<R>): ReadableStreamDefaultReader<R>;
|
||||
};
|
||||
const ReadableStreamBYOBReader: any;
|
||||
const ReadableStreamBYOBRequest: any;
|
||||
interface ReadableByteStreamController {
|
||||
readonly byobRequest: undefined;
|
||||
readonly desiredSize: number | null;
|
||||
close(): void;
|
||||
enqueue(chunk: ArrayBufferView): void;
|
||||
error(error?: any): void;
|
||||
}
|
||||
const ReadableByteStreamController: {
|
||||
prototype: ReadableByteStreamController;
|
||||
new (): ReadableByteStreamController;
|
||||
};
|
||||
interface ReadableStreamDefaultController<R = any> {
|
||||
readonly desiredSize: number | null;
|
||||
close(): void;
|
||||
enqueue(chunk?: R): void;
|
||||
error(e?: any): void;
|
||||
}
|
||||
const ReadableStreamDefaultController: {
|
||||
prototype: ReadableStreamDefaultController;
|
||||
new (): ReadableStreamDefaultController;
|
||||
};
|
||||
interface Transformer<I = any, O = any> {
|
||||
flush?: TransformerFlushCallback<O>;
|
||||
readableType?: undefined;
|
||||
start?: TransformerStartCallback<O>;
|
||||
transform?: TransformerTransformCallback<I, O>;
|
||||
writableType?: undefined;
|
||||
}
|
||||
interface TransformStream<I = any, O = any> {
|
||||
readonly readable: ReadableStream<O>;
|
||||
readonly writable: WritableStream<I>;
|
||||
}
|
||||
const TransformStream: {
|
||||
prototype: TransformStream;
|
||||
new <I = any, O = any>(transformer?: Transformer<I, O>, writableStrategy?: QueuingStrategy<I>, readableStrategy?: QueuingStrategy<O>): TransformStream<I, O>;
|
||||
};
|
||||
interface TransformStreamDefaultController<O = any> {
|
||||
readonly desiredSize: number | null;
|
||||
enqueue(chunk?: O): void;
|
||||
error(reason?: any): void;
|
||||
terminate(): void;
|
||||
}
|
||||
const TransformStreamDefaultController: {
|
||||
prototype: TransformStreamDefaultController;
|
||||
new (): TransformStreamDefaultController;
|
||||
};
|
||||
/**
|
||||
* This Streams API interface provides a standard abstraction for writing
|
||||
* streaming data to a destination, known as a sink. This object comes with
|
||||
* built-in back pressure and queuing.
|
||||
*/
|
||||
interface WritableStream<W = any> {
|
||||
readonly locked: boolean;
|
||||
abort(reason?: any): Promise<void>;
|
||||
close(): Promise<void>;
|
||||
getWriter(): WritableStreamDefaultWriter<W>;
|
||||
}
|
||||
const WritableStream: {
|
||||
prototype: WritableStream;
|
||||
new <W = any>(underlyingSink?: UnderlyingSink<W>, strategy?: QueuingStrategy<W>): WritableStream<W>;
|
||||
};
|
||||
/**
|
||||
* This Streams API interface is the object returned by
|
||||
* WritableStream.getWriter() and once created locks the < writer to the
|
||||
* WritableStream ensuring that no other streams can write to the underlying
|
||||
* sink.
|
||||
*/
|
||||
interface WritableStreamDefaultWriter<W = any> {
|
||||
readonly closed: Promise<undefined>;
|
||||
readonly desiredSize: number | null;
|
||||
readonly ready: Promise<undefined>;
|
||||
abort(reason?: any): Promise<void>;
|
||||
close(): Promise<void>;
|
||||
releaseLock(): void;
|
||||
write(chunk?: W): Promise<void>;
|
||||
}
|
||||
const WritableStreamDefaultWriter: {
|
||||
prototype: WritableStreamDefaultWriter;
|
||||
new <W = any>(stream: WritableStream<W>): WritableStreamDefaultWriter<W>;
|
||||
};
|
||||
/**
|
||||
* This Streams API interface represents a controller allowing control of a
|
||||
* WritableStream's state. When constructing a WritableStream, the
|
||||
* underlying sink is given a corresponding WritableStreamDefaultController
|
||||
* instance to manipulate.
|
||||
*/
|
||||
interface WritableStreamDefaultController {
|
||||
error(e?: any): void;
|
||||
}
|
||||
const WritableStreamDefaultController: {
|
||||
prototype: WritableStreamDefaultController;
|
||||
new (): WritableStreamDefaultController;
|
||||
};
|
||||
interface QueuingStrategy<T = any> {
|
||||
highWaterMark?: number;
|
||||
size?: QueuingStrategySize<T>;
|
||||
}
|
||||
interface QueuingStrategySize<T = any> {
|
||||
(chunk?: T): number;
|
||||
}
|
||||
interface QueuingStrategyInit {
|
||||
/**
|
||||
* Creates a new ByteLengthQueuingStrategy with the provided high water
|
||||
* mark.
|
||||
*
|
||||
* Note that the provided high water mark will not be validated ahead of
|
||||
* time. Instead, if it is negative, NaN, or not a number, the resulting
|
||||
* ByteLengthQueuingStrategy will cause the corresponding stream
|
||||
* constructor to throw.
|
||||
*/
|
||||
highWaterMark: number;
|
||||
}
|
||||
/**
|
||||
* This Streams API interface provides a built-in byte length queuing
|
||||
* strategy that can be used when constructing streams.
|
||||
*/
|
||||
interface ByteLengthQueuingStrategy extends QueuingStrategy<ArrayBufferView> {
|
||||
readonly highWaterMark: number;
|
||||
readonly size: QueuingStrategySize<ArrayBufferView>;
|
||||
}
|
||||
const ByteLengthQueuingStrategy: {
|
||||
prototype: ByteLengthQueuingStrategy;
|
||||
new (init: QueuingStrategyInit): ByteLengthQueuingStrategy;
|
||||
};
|
||||
/**
|
||||
* This Streams API interface provides a built-in byte length queuing
|
||||
* strategy that can be used when constructing streams.
|
||||
*/
|
||||
interface CountQueuingStrategy extends QueuingStrategy {
|
||||
readonly highWaterMark: number;
|
||||
readonly size: QueuingStrategySize;
|
||||
}
|
||||
const CountQueuingStrategy: {
|
||||
prototype: CountQueuingStrategy;
|
||||
new (init: QueuingStrategyInit): CountQueuingStrategy;
|
||||
};
|
||||
interface TextEncoderStream {
|
||||
/** Returns "utf-8". */
|
||||
readonly encoding: 'utf-8';
|
||||
readonly readable: ReadableStream<Uint8Array>;
|
||||
readonly writable: WritableStream<string>;
|
||||
readonly [Symbol.toStringTag]: string;
|
||||
}
|
||||
const TextEncoderStream: {
|
||||
prototype: TextEncoderStream;
|
||||
new (): TextEncoderStream;
|
||||
};
|
||||
interface TextDecoderOptions {
|
||||
fatal?: boolean;
|
||||
ignoreBOM?: boolean;
|
||||
}
|
||||
type BufferSource = ArrayBufferView | ArrayBuffer;
|
||||
interface TextDecoderStream {
|
||||
/** Returns encoding's name, lower cased. */
|
||||
readonly encoding: string;
|
||||
/** Returns `true` if error mode is "fatal", and `false` otherwise. */
|
||||
readonly fatal: boolean;
|
||||
/** Returns `true` if ignore BOM flag is set, and `false` otherwise. */
|
||||
readonly ignoreBOM: boolean;
|
||||
readonly readable: ReadableStream<string>;
|
||||
readonly writable: WritableStream<BufferSource>;
|
||||
readonly [Symbol.toStringTag]: string;
|
||||
}
|
||||
const TextDecoderStream: {
|
||||
prototype: TextDecoderStream;
|
||||
new (label?: string, options?: TextDecoderOptions): TextDecoderStream;
|
||||
};
|
||||
}
|
||||
declare module 'node:stream/web' {
|
||||
export * from 'stream/web';
|
||||
}
|
67
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/string_decoder.d.ts
generated
vendored
67
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/string_decoder.d.ts
generated
vendored
@ -0,0 +1,67 @@
|
||||
/**
|
||||
* The `string_decoder` module provides an API for decoding `Buffer` objects into
|
||||
* strings in a manner that preserves encoded multi-byte UTF-8 and UTF-16
|
||||
* characters. It can be accessed using:
|
||||
*
|
||||
* ```js
|
||||
* const { StringDecoder } = require('string_decoder');
|
||||
* ```
|
||||
*
|
||||
* The following example shows the basic use of the `StringDecoder` class.
|
||||
*
|
||||
* ```js
|
||||
* const { StringDecoder } = require('string_decoder');
|
||||
* const decoder = new StringDecoder('utf8');
|
||||
*
|
||||
* const cent = Buffer.from([0xC2, 0xA2]);
|
||||
* console.log(decoder.write(cent));
|
||||
*
|
||||
* const euro = Buffer.from([0xE2, 0x82, 0xAC]);
|
||||
* console.log(decoder.write(euro));
|
||||
* ```
|
||||
*
|
||||
* When a `Buffer` instance is written to the `StringDecoder` instance, an
|
||||
* internal buffer is used to ensure that the decoded string does not contain
|
||||
* any incomplete multibyte characters. These are held in the buffer until the
|
||||
* next call to `stringDecoder.write()` or until `stringDecoder.end()` is called.
|
||||
*
|
||||
* In the following example, the three UTF-8 encoded bytes of the European Euro
|
||||
* symbol (`€`) are written over three separate operations:
|
||||
*
|
||||
* ```js
|
||||
* const { StringDecoder } = require('string_decoder');
|
||||
* const decoder = new StringDecoder('utf8');
|
||||
*
|
||||
* decoder.write(Buffer.from([0xE2]));
|
||||
* decoder.write(Buffer.from([0x82]));
|
||||
* console.log(decoder.end(Buffer.from([0xAC])));
|
||||
* ```
|
||||
* @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/string_decoder.js)
|
||||
*/
|
||||
declare module 'string_decoder' {
|
||||
class StringDecoder {
|
||||
constructor(encoding?: BufferEncoding);
|
||||
/**
|
||||
* Returns a decoded string, ensuring that any incomplete multibyte characters at
|
||||
* the end of the `Buffer`, or `TypedArray`, or `DataView` are omitted from the
|
||||
* returned string and stored in an internal buffer for the next call to`stringDecoder.write()` or `stringDecoder.end()`.
|
||||
* @since v0.1.99
|
||||
* @param buffer A `Buffer`, or `TypedArray`, or `DataView` containing the bytes to decode.
|
||||
*/
|
||||
write(buffer: Buffer): string;
|
||||
/**
|
||||
* Returns any remaining input stored in the internal buffer as a string. Bytes
|
||||
* representing incomplete UTF-8 and UTF-16 characters will be replaced with
|
||||
* substitution characters appropriate for the character encoding.
|
||||
*
|
||||
* If the `buffer` argument is provided, one final call to `stringDecoder.write()`is performed before returning the remaining input.
|
||||
* After `end()` is called, the `stringDecoder` object can be reused for new input.
|
||||
* @since v0.9.3
|
||||
* @param buffer A `Buffer`, or `TypedArray`, or `DataView` containing the bytes to decode.
|
||||
*/
|
||||
end(buffer?: Buffer): string;
|
||||
}
|
||||
}
|
||||
declare module 'node:string_decoder' {
|
||||
export * from 'string_decoder';
|
||||
}
|
@ -0,0 +1,190 @@
|
||||
/**
|
||||
* The `node:test` module provides a standalone testing module.
|
||||
* @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/test.js)
|
||||
*/
|
||||
declare module 'node:test' {
|
||||
/**
|
||||
* The `test()` function is the value imported from the test module. Each invocation of this
|
||||
* function results in the creation of a test point in the TAP output.
|
||||
*
|
||||
* The {@link TestContext} object passed to the fn argument can be used to perform actions
|
||||
* related to the current test. Examples include skipping the test, adding additional TAP
|
||||
* diagnostic information, or creating subtests.
|
||||
*
|
||||
* `test()` returns a {@link Promise} that resolves once the test completes. The return value
|
||||
* can usually be discarded for top level tests. However, the return value from subtests should
|
||||
* be used to prevent the parent test from finishing first and cancelling the subtest as shown
|
||||
* in the following example.
|
||||
*
|
||||
* ```js
|
||||
* test('top level test', async (t) => {
|
||||
* // The setTimeout() in the following subtest would cause it to outlive its
|
||||
* // parent test if 'await' is removed on the next line. Once the parent test
|
||||
* // completes, it will cancel any outstanding subtests.
|
||||
* await t.test('longer running subtest', async (t) => {
|
||||
* return new Promise((resolve, reject) => {
|
||||
* setTimeout(resolve, 1000);
|
||||
* });
|
||||
* });
|
||||
* });
|
||||
* ```
|
||||
* @since v18.0.0
|
||||
* @param name The name of the test, which is displayed when reporting test results.
|
||||
* Default: The `name` property of fn, or `'<anonymous>'` if `fn` does not have a name.
|
||||
* @param options Configuration options for the test
|
||||
* @param fn The function under test. The first argument to this function is a
|
||||
* {@link TestContext} object. If the test uses callbacks, the callback function is
|
||||
* passed as the second argument. Default: A no-op function.
|
||||
* @returns A {@link Promise} resolved with `undefined` once the test completes.
|
||||
*/
|
||||
function test(name?: string, fn?: TestFn): Promise<void>;
|
||||
function test(name?: string, options?: TestOptions, fn?: TestFn): Promise<void>;
|
||||
function test(options?: TestOptions, fn?: TestFn): Promise<void>;
|
||||
function test(fn?: TestFn): Promise<void>;
|
||||
|
||||
/*
|
||||
* @since v18.6.0
|
||||
* @param name The name of the suite, which is displayed when reporting suite results.
|
||||
* Default: The `name` property of fn, or `'<anonymous>'` if `fn` does not have a name.
|
||||
* @param options Configuration options for the suite
|
||||
* @param fn The function under suite. Default: A no-op function.
|
||||
*/
|
||||
function describe(name?: string, options?: TestOptions, fn?: SuiteFn): void;
|
||||
function describe(name?: string, fn?: SuiteFn): void;
|
||||
function describe(options?: TestOptions, fn?: SuiteFn): void;
|
||||
function describe(fn?: SuiteFn): void;
|
||||
|
||||
/*
|
||||
* @since v18.6.0
|
||||
* @param name The name of the test, which is displayed when reporting test results.
|
||||
* Default: The `name` property of fn, or `'<anonymous>'` if `fn` does not have a name.
|
||||
* @param options Configuration options for the test
|
||||
* @param fn The function under test. If the test uses callbacks, the callback function is
|
||||
* passed as the second argument. Default: A no-op function.
|
||||
*/
|
||||
function it(name?: string, options?: TestOptions, fn?: ItFn): void;
|
||||
function it(name?: string, fn?: ItFn): void;
|
||||
function it(options?: TestOptions, fn?: ItFn): void;
|
||||
function it(fn?: ItFn): void;
|
||||
|
||||
/**
|
||||
* The type of a function under test. The first argument to this function is a
|
||||
* {@link TestContext} object. If the test uses callbacks, the callback function is passed as
|
||||
* the second argument.
|
||||
*/
|
||||
type TestFn = (t: TestContext, done: (result?: any) => void) => any;
|
||||
|
||||
/**
|
||||
* The type of a function under Suite.
|
||||
* If the test uses callbacks, the callback function is passed as an argument
|
||||
*/
|
||||
type SuiteFn = (done: (result?: any) => void) => void;
|
||||
|
||||
/**
|
||||
* The type of a function under test.
|
||||
* If the test uses callbacks, the callback function is passed as an argument
|
||||
*/
|
||||
type ItFn = (done: (result?: any) => void) => any;
|
||||
|
||||
/**
|
||||
* An instance of `TestContext` is passed to each test function in order to interact with the
|
||||
* test runner. However, the `TestContext` constructor is not exposed as part of the API.
|
||||
* @since v18.0.0
|
||||
*/
|
||||
interface TestContext {
|
||||
/**
|
||||
* This function is used to write TAP diagnostics to the output. Any diagnostic information is
|
||||
* included at the end of the test's results. This function does not return a value.
|
||||
* @param message Message to be displayed as a TAP diagnostic.
|
||||
* @since v18.0.0
|
||||
*/
|
||||
diagnostic(message: string): void;
|
||||
|
||||
/**
|
||||
* If `shouldRunOnlyTests` is truthy, the test context will only run tests that have the `only`
|
||||
* option set. Otherwise, all tests are run. If Node.js was not started with the `--test-only`
|
||||
* command-line option, this function is a no-op.
|
||||
* @param shouldRunOnlyTests Whether or not to run `only` tests.
|
||||
* @since v18.0.0
|
||||
*/
|
||||
runOnly(shouldRunOnlyTests: boolean): void;
|
||||
|
||||
/**
|
||||
* This function causes the test's output to indicate the test as skipped. If `message` is
|
||||
* provided, it is included in the TAP output. Calling `skip()` does not terminate execution of
|
||||
* the test function. This function does not return a value.
|
||||
* @param message Optional skip message to be displayed in TAP output.
|
||||
* @since v18.0.0
|
||||
*/
|
||||
skip(message?: string): void;
|
||||
|
||||
/**
|
||||
* This function adds a `TODO` directive to the test's output. If `message` is provided, it is
|
||||
* included in the TAP output. Calling `todo()` does not terminate execution of the test
|
||||
* function. This function does not return a value.
|
||||
* @param message Optional `TODO` message to be displayed in TAP output.
|
||||
* @since v18.0.0
|
||||
*/
|
||||
todo(message?: string): void;
|
||||
|
||||
/**
|
||||
* This function is used to create subtests under the current test. This function behaves in
|
||||
* the same fashion as the top level {@link test} function.
|
||||
* @since v18.0.0
|
||||
* @param name The name of the test, which is displayed when reporting test results.
|
||||
* Default: The `name` property of fn, or `'<anonymous>'` if `fn` does not have a name.
|
||||
* @param options Configuration options for the test
|
||||
* @param fn The function under test. This first argument to this function is a
|
||||
* {@link TestContext} object. If the test uses callbacks, the callback function is
|
||||
* passed as the second argument. Default: A no-op function.
|
||||
* @returns A {@link Promise} resolved with `undefined` once the test completes.
|
||||
*/
|
||||
test: typeof test;
|
||||
}
|
||||
|
||||
interface TestOptions {
|
||||
/**
|
||||
* The number of tests that can be run at the same time. If unspecified, subtests inherit this
|
||||
* value from their parent.
|
||||
* @default 1
|
||||
*/
|
||||
concurrency?: number;
|
||||
|
||||
/**
|
||||
* If truthy, and the test context is configured to run `only` tests, then this test will be
|
||||
* run. Otherwise, the test is skipped.
|
||||
* @default false
|
||||
*/
|
||||
only?: boolean;
|
||||
|
||||
/**
|
||||
* Allows aborting an in-progress test.
|
||||
* @since 8.7.0
|
||||
*/
|
||||
signal?: AbortSignal;
|
||||
|
||||
/**
|
||||
* If truthy, the test is skipped. If a string is provided, that string is displayed in the
|
||||
* test results as the reason for skipping the test.
|
||||
* @default false
|
||||
*/
|
||||
skip?: boolean | string;
|
||||
|
||||
/**
|
||||
* A number of milliseconds the test will fail after. If unspecified, subtests inherit this
|
||||
* value from their parent.
|
||||
* @default Infinity
|
||||
* @since 8.7.0
|
||||
*/
|
||||
timeout?: number;
|
||||
|
||||
/**
|
||||
* If truthy, the test marked as `TODO`. If a string is provided, that string is displayed in
|
||||
* the test results as the reason why the test is `TODO`.
|
||||
* @default false
|
||||
*/
|
||||
todo?: boolean | string;
|
||||
}
|
||||
|
||||
export { test as default, test, describe, it };
|
||||
}
|
@ -0,0 +1,94 @@
|
||||
/**
|
||||
* The `timer` module exposes a global API for scheduling functions to
|
||||
* be called at some future period of time. Because the timer functions are
|
||||
* globals, there is no need to call `require('timers')` to use the API.
|
||||
*
|
||||
* The timer functions within Node.js implement a similar API as the timers API
|
||||
* provided by Web Browsers but use a different internal implementation that is
|
||||
* built around the Node.js [Event Loop](https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/#setimmediate-vs-settimeout).
|
||||
* @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/timers.js)
|
||||
*/
|
||||
declare module 'timers' {
|
||||
import { Abortable } from 'node:events';
|
||||
import { setTimeout as setTimeoutPromise, setImmediate as setImmediatePromise, setInterval as setIntervalPromise } from 'node:timers/promises';
|
||||
interface TimerOptions extends Abortable {
|
||||
/**
|
||||
* Set to `false` to indicate that the scheduled `Timeout`
|
||||
* should not require the Node.js event loop to remain active.
|
||||
* @default true
|
||||
*/
|
||||
ref?: boolean | undefined;
|
||||
}
|
||||
let setTimeout: typeof global.setTimeout;
|
||||
let clearTimeout: typeof global.clearTimeout;
|
||||
let setInterval: typeof global.setInterval;
|
||||
let clearInterval: typeof global.clearInterval;
|
||||
let setImmediate: typeof global.setImmediate;
|
||||
let clearImmediate: typeof global.clearImmediate;
|
||||
global {
|
||||
namespace NodeJS {
|
||||
// compatibility with older typings
|
||||
interface Timer extends RefCounted {
|
||||
hasRef(): boolean;
|
||||
refresh(): this;
|
||||
[Symbol.toPrimitive](): number;
|
||||
}
|
||||
interface Immediate extends RefCounted {
|
||||
/**
|
||||
* If true, the `Immediate` object will keep the Node.js event loop active.
|
||||
* @since v11.0.0
|
||||
*/
|
||||
hasRef(): boolean;
|
||||
_onImmediate: Function; // to distinguish it from the Timeout class
|
||||
}
|
||||
interface Timeout extends Timer {
|
||||
/**
|
||||
* If true, the `Timeout` object will keep the Node.js event loop active.
|
||||
* @since v11.0.0
|
||||
*/
|
||||
hasRef(): boolean;
|
||||
/**
|
||||
* Sets the timer's start time to the current time, and reschedules the timer to
|
||||
* call its callback at the previously specified duration adjusted to the current
|
||||
* time. This is useful for refreshing a timer without allocating a new
|
||||
* JavaScript object.
|
||||
*
|
||||
* Using this on a timer that has already called its callback will reactivate the
|
||||
* timer.
|
||||
* @since v10.2.0
|
||||
* @return a reference to `timeout`
|
||||
*/
|
||||
refresh(): this;
|
||||
[Symbol.toPrimitive](): number;
|
||||
}
|
||||
}
|
||||
function setTimeout<TArgs extends any[]>(callback: (...args: TArgs) => void, ms?: number, ...args: TArgs): NodeJS.Timeout;
|
||||
// util.promisify no rest args compability
|
||||
// tslint:disable-next-line void-return
|
||||
function setTimeout(callback: (args: void) => void, ms?: number): NodeJS.Timeout;
|
||||
namespace setTimeout {
|
||||
const __promisify__: typeof setTimeoutPromise;
|
||||
}
|
||||
function clearTimeout(timeoutId: NodeJS.Timeout | string | number | undefined): void;
|
||||
function setInterval<TArgs extends any[]>(callback: (...args: TArgs) => void, ms?: number, ...args: TArgs): NodeJS.Timer;
|
||||
// util.promisify no rest args compability
|
||||
// tslint:disable-next-line void-return
|
||||
function setInterval(callback: (args: void) => void, ms?: number): NodeJS.Timer;
|
||||
namespace setInterval {
|
||||
const __promisify__: typeof setIntervalPromise;
|
||||
}
|
||||
function clearInterval(intervalId: NodeJS.Timeout | string | number | undefined): void;
|
||||
function setImmediate<TArgs extends any[]>(callback: (...args: TArgs) => void, ...args: TArgs): NodeJS.Immediate;
|
||||
// util.promisify no rest args compability
|
||||
// tslint:disable-next-line void-return
|
||||
function setImmediate(callback: (args: void) => void): NodeJS.Immediate;
|
||||
namespace setImmediate {
|
||||
const __promisify__: typeof setImmediatePromise;
|
||||
}
|
||||
function clearImmediate(immediateId: NodeJS.Immediate | undefined): void;
|
||||
function queueMicrotask(callback: () => void): void;
|
||||
}
|
||||
}
|
||||
declare module 'node:timers' {
|
||||
export * from 'timers';
|
||||
}
|
68
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/timers/promises.d.ts
generated
vendored
68
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/timers/promises.d.ts
generated
vendored
@ -0,0 +1,68 @@
|
||||
/**
|
||||
* The `timers/promises` API provides an alternative set of timer functions
|
||||
* that return `Promise` objects. The API is accessible via`require('timers/promises')`.
|
||||
*
|
||||
* ```js
|
||||
* import {
|
||||
* setTimeout,
|
||||
* setImmediate,
|
||||
* setInterval,
|
||||
* } from 'timers/promises';
|
||||
* ```
|
||||
* @since v15.0.0
|
||||
*/
|
||||
declare module 'timers/promises' {
|
||||
import { TimerOptions } from 'node:timers';
|
||||
/**
|
||||
* ```js
|
||||
* import {
|
||||
* setTimeout,
|
||||
* } from 'timers/promises';
|
||||
*
|
||||
* const res = await setTimeout(100, 'result');
|
||||
*
|
||||
* console.log(res); // Prints 'result'
|
||||
* ```
|
||||
* @since v15.0.0
|
||||
* @param [delay=1] The number of milliseconds to wait before fulfilling the promise.
|
||||
* @param value A value with which the promise is fulfilled.
|
||||
*/
|
||||
function setTimeout<T = void>(delay?: number, value?: T, options?: TimerOptions): Promise<T>;
|
||||
/**
|
||||
* ```js
|
||||
* import {
|
||||
* setImmediate,
|
||||
* } from 'timers/promises';
|
||||
*
|
||||
* const res = await setImmediate('result');
|
||||
*
|
||||
* console.log(res); // Prints 'result'
|
||||
* ```
|
||||
* @since v15.0.0
|
||||
* @param value A value with which the promise is fulfilled.
|
||||
*/
|
||||
function setImmediate<T = void>(value?: T, options?: TimerOptions): Promise<T>;
|
||||
/**
|
||||
* Returns an async iterator that generates values in an interval of `delay` ms.
|
||||
*
|
||||
* ```js
|
||||
* import {
|
||||
* setInterval,
|
||||
* } from 'timers/promises';
|
||||
*
|
||||
* const interval = 100;
|
||||
* for await (const startTime of setInterval(interval, Date.now())) {
|
||||
* const now = Date.now();
|
||||
* console.log(now);
|
||||
* if ((now - startTime) > 1000)
|
||||
* break;
|
||||
* }
|
||||
* console.log(Date.now());
|
||||
* ```
|
||||
* @since v15.9.0
|
||||
*/
|
||||
function setInterval<T = void>(delay?: number, value?: T, options?: TimerOptions): AsyncIterable<T>;
|
||||
}
|
||||
declare module 'node:timers/promises' {
|
||||
export * from 'timers/promises';
|
||||
}
|
File diff suppressed because it is too large
Load Diff
171
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/trace_events.d.ts
generated
vendored
171
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/trace_events.d.ts
generated
vendored
@ -0,0 +1,171 @@
|
||||
/**
|
||||
* The `trace_events` module provides a mechanism to centralize tracing information
|
||||
* generated by V8, Node.js core, and userspace code.
|
||||
*
|
||||
* Tracing can be enabled with the `--trace-event-categories` command-line flag
|
||||
* or by using the `trace_events` module. The `--trace-event-categories` flag
|
||||
* accepts a list of comma-separated category names.
|
||||
*
|
||||
* The available categories are:
|
||||
*
|
||||
* * `node`: An empty placeholder.
|
||||
* * `node.async_hooks`: Enables capture of detailed `async_hooks` trace data.
|
||||
* The `async_hooks` events have a unique `asyncId` and a special `triggerId` `triggerAsyncId` property.
|
||||
* * `node.bootstrap`: Enables capture of Node.js bootstrap milestones.
|
||||
* * `node.console`: Enables capture of `console.time()` and `console.count()`output.
|
||||
* * `node.dns.native`: Enables capture of trace data for DNS queries.
|
||||
* * `node.environment`: Enables capture of Node.js Environment milestones.
|
||||
* * `node.fs.sync`: Enables capture of trace data for file system sync methods.
|
||||
* * `node.perf`: Enables capture of `Performance API` measurements.
|
||||
* * `node.perf.usertiming`: Enables capture of only Performance API User Timing
|
||||
* measures and marks.
|
||||
* * `node.perf.timerify`: Enables capture of only Performance API timerify
|
||||
* measurements.
|
||||
* * `node.promises.rejections`: Enables capture of trace data tracking the number
|
||||
* of unhandled Promise rejections and handled-after-rejections.
|
||||
* * `node.vm.script`: Enables capture of trace data for the `vm` module's`runInNewContext()`, `runInContext()`, and `runInThisContext()` methods.
|
||||
* * `v8`: The `V8` events are GC, compiling, and execution related.
|
||||
*
|
||||
* By default the `node`, `node.async_hooks`, and `v8` categories are enabled.
|
||||
*
|
||||
* ```bash
|
||||
* node --trace-event-categories v8,node,node.async_hooks server.js
|
||||
* ```
|
||||
*
|
||||
* Prior versions of Node.js required the use of the `--trace-events-enabled`flag to enable trace events. This requirement has been removed. However, the`--trace-events-enabled` flag _may_ still be
|
||||
* used and will enable the`node`, `node.async_hooks`, and `v8` trace event categories by default.
|
||||
*
|
||||
* ```bash
|
||||
* node --trace-events-enabled
|
||||
*
|
||||
* # is equivalent to
|
||||
*
|
||||
* node --trace-event-categories v8,node,node.async_hooks
|
||||
* ```
|
||||
*
|
||||
* Alternatively, trace events may be enabled using the `trace_events` module:
|
||||
*
|
||||
* ```js
|
||||
* const trace_events = require('trace_events');
|
||||
* const tracing = trace_events.createTracing({ categories: ['node.perf'] });
|
||||
* tracing.enable(); // Enable trace event capture for the 'node.perf' category
|
||||
*
|
||||
* // do work
|
||||
*
|
||||
* tracing.disable(); // Disable trace event capture for the 'node.perf' category
|
||||
* ```
|
||||
*
|
||||
* Running Node.js with tracing enabled will produce log files that can be opened
|
||||
* in the [`chrome://tracing`](https://www.chromium.org/developers/how-tos/trace-event-profiling-tool) tab of Chrome.
|
||||
*
|
||||
* The logging file is by default called `node_trace.${rotation}.log`, where`${rotation}` is an incrementing log-rotation id. The filepath pattern can
|
||||
* be specified with `--trace-event-file-pattern` that accepts a template
|
||||
* string that supports `${rotation}` and `${pid}`:
|
||||
*
|
||||
* ```bash
|
||||
* node --trace-event-categories v8 --trace-event-file-pattern '${pid}-${rotation}.log' server.js
|
||||
* ```
|
||||
*
|
||||
* To guarantee that the log file is properly generated after signal events like`SIGINT`, `SIGTERM`, or `SIGBREAK`, make sure to have the appropriate handlers
|
||||
* in your code, such as:
|
||||
*
|
||||
* ```js
|
||||
* process.on('SIGINT', function onSigint() {
|
||||
* console.info('Received SIGINT.');
|
||||
* process.exit(130); // Or applicable exit code depending on OS and signal
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* The tracing system uses the same time source
|
||||
* as the one used by `process.hrtime()`.
|
||||
* However the trace-event timestamps are expressed in microseconds,
|
||||
* unlike `process.hrtime()` which returns nanoseconds.
|
||||
*
|
||||
* The features from this module are not available in `Worker` threads.
|
||||
* @experimental
|
||||
* @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/trace_events.js)
|
||||
*/
|
||||
declare module 'trace_events' {
|
||||
/**
|
||||
* The `Tracing` object is used to enable or disable tracing for sets of
|
||||
* categories. Instances are created using the
|
||||
* `trace_events.createTracing()` method.
|
||||
*
|
||||
* When created, the `Tracing` object is disabled. Calling the
|
||||
* `tracing.enable()` method adds the categories to the set of enabled trace
|
||||
* event categories. Calling `tracing.disable()` will remove the categories
|
||||
* from the set of enabled trace event categories.
|
||||
*/
|
||||
interface Tracing {
|
||||
/**
|
||||
* A comma-separated list of the trace event categories covered by this
|
||||
* `Tracing` object.
|
||||
*/
|
||||
readonly categories: string;
|
||||
/**
|
||||
* Disables this `Tracing` object.
|
||||
*
|
||||
* Only trace event categories _not_ covered by other enabled `Tracing`
|
||||
* objects and _not_ specified by the `--trace-event-categories` flag
|
||||
* will be disabled.
|
||||
*/
|
||||
disable(): void;
|
||||
/**
|
||||
* Enables this `Tracing` object for the set of categories covered by
|
||||
* the `Tracing` object.
|
||||
*/
|
||||
enable(): void;
|
||||
/**
|
||||
* `true` only if the `Tracing` object has been enabled.
|
||||
*/
|
||||
readonly enabled: boolean;
|
||||
}
|
||||
interface CreateTracingOptions {
|
||||
/**
|
||||
* An array of trace category names. Values included in the array are
|
||||
* coerced to a string when possible. An error will be thrown if the
|
||||
* value cannot be coerced.
|
||||
*/
|
||||
categories: string[];
|
||||
}
|
||||
/**
|
||||
* Creates and returns a `Tracing` object for the given set of `categories`.
|
||||
*
|
||||
* ```js
|
||||
* const trace_events = require('trace_events');
|
||||
* const categories = ['node.perf', 'node.async_hooks'];
|
||||
* const tracing = trace_events.createTracing({ categories });
|
||||
* tracing.enable();
|
||||
* // do stuff
|
||||
* tracing.disable();
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
* @return .
|
||||
*/
|
||||
function createTracing(options: CreateTracingOptions): Tracing;
|
||||
/**
|
||||
* Returns a comma-separated list of all currently-enabled trace event
|
||||
* categories. The current set of enabled trace event categories is determined
|
||||
* by the _union_ of all currently-enabled `Tracing` objects and any categories
|
||||
* enabled using the `--trace-event-categories` flag.
|
||||
*
|
||||
* Given the file `test.js` below, the command`node --trace-event-categories node.perf test.js` will print`'node.async_hooks,node.perf'` to the console.
|
||||
*
|
||||
* ```js
|
||||
* const trace_events = require('trace_events');
|
||||
* const t1 = trace_events.createTracing({ categories: ['node.async_hooks'] });
|
||||
* const t2 = trace_events.createTracing({ categories: ['node.perf'] });
|
||||
* const t3 = trace_events.createTracing({ categories: ['v8'] });
|
||||
*
|
||||
* t1.enable();
|
||||
* t2.enable();
|
||||
*
|
||||
* console.log(trace_events.getEnabledCategories());
|
||||
* ```
|
||||
* @since v10.0.0
|
||||
*/
|
||||
function getEnabledCategories(): string | undefined;
|
||||
}
|
||||
declare module 'node:trace_events' {
|
||||
export * from 'trace_events';
|
||||
}
|
@ -0,0 +1,206 @@
|
||||
/**
|
||||
* The `tty` module provides the `tty.ReadStream` and `tty.WriteStream` classes.
|
||||
* In most cases, it will not be necessary or possible to use this module directly.
|
||||
* However, it can be accessed using:
|
||||
*
|
||||
* ```js
|
||||
* const tty = require('tty');
|
||||
* ```
|
||||
*
|
||||
* When Node.js detects that it is being run with a text terminal ("TTY")
|
||||
* attached, `process.stdin` will, by default, be initialized as an instance of`tty.ReadStream` and both `process.stdout` and `process.stderr` will, by
|
||||
* default, be instances of `tty.WriteStream`. The preferred method of determining
|
||||
* whether Node.js is being run within a TTY context is to check that the value of
|
||||
* the `process.stdout.isTTY` property is `true`:
|
||||
*
|
||||
* ```console
|
||||
* $ node -p -e "Boolean(process.stdout.isTTY)"
|
||||
* true
|
||||
* $ node -p -e "Boolean(process.stdout.isTTY)" | cat
|
||||
* false
|
||||
* ```
|
||||
*
|
||||
* In most cases, there should be little to no reason for an application to
|
||||
* manually create instances of the `tty.ReadStream` and `tty.WriteStream`classes.
|
||||
* @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/tty.js)
|
||||
*/
|
||||
declare module 'tty' {
|
||||
import * as net from 'node:net';
|
||||
/**
|
||||
* The `tty.isatty()` method returns `true` if the given `fd` is associated with
|
||||
* a TTY and `false` if it is not, including whenever `fd` is not a non-negative
|
||||
* integer.
|
||||
* @since v0.5.8
|
||||
* @param fd A numeric file descriptor
|
||||
*/
|
||||
function isatty(fd: number): boolean;
|
||||
/**
|
||||
* Represents the readable side of a TTY. In normal circumstances `process.stdin` will be the only `tty.ReadStream` instance in a Node.js
|
||||
* process and there should be no reason to create additional instances.
|
||||
* @since v0.5.8
|
||||
*/
|
||||
class ReadStream extends net.Socket {
|
||||
constructor(fd: number, options?: net.SocketConstructorOpts);
|
||||
/**
|
||||
* A `boolean` that is `true` if the TTY is currently configured to operate as a
|
||||
* raw device. Defaults to `false`.
|
||||
* @since v0.7.7
|
||||
*/
|
||||
isRaw: boolean;
|
||||
/**
|
||||
* Allows configuration of `tty.ReadStream` so that it operates as a raw device.
|
||||
*
|
||||
* When in raw mode, input is always available character-by-character, not
|
||||
* including modifiers. Additionally, all special processing of characters by the
|
||||
* terminal is disabled, including echoing input
|
||||
* characters. Ctrl+C will no longer cause a `SIGINT` when
|
||||
* in this mode.
|
||||
* @since v0.7.7
|
||||
* @param mode If `true`, configures the `tty.ReadStream` to operate as a raw device. If `false`, configures the `tty.ReadStream` to operate in its default mode. The `readStream.isRaw`
|
||||
* property will be set to the resulting mode.
|
||||
* @return The read stream instance.
|
||||
*/
|
||||
setRawMode(mode: boolean): this;
|
||||
/**
|
||||
* A `boolean` that is always `true` for `tty.ReadStream` instances.
|
||||
* @since v0.5.8
|
||||
*/
|
||||
isTTY: boolean;
|
||||
}
|
||||
/**
|
||||
* -1 - to the left from cursor
|
||||
* 0 - the entire line
|
||||
* 1 - to the right from cursor
|
||||
*/
|
||||
type Direction = -1 | 0 | 1;
|
||||
/**
|
||||
* Represents the writable side of a TTY. In normal circumstances,`process.stdout` and `process.stderr` will be the only`tty.WriteStream` instances created for a Node.js process and there
|
||||
* should be no reason to create additional instances.
|
||||
* @since v0.5.8
|
||||
*/
|
||||
class WriteStream extends net.Socket {
|
||||
constructor(fd: number);
|
||||
addListener(event: string, listener: (...args: any[]) => void): this;
|
||||
addListener(event: 'resize', listener: () => void): this;
|
||||
emit(event: string | symbol, ...args: any[]): boolean;
|
||||
emit(event: 'resize'): boolean;
|
||||
on(event: string, listener: (...args: any[]) => void): this;
|
||||
on(event: 'resize', listener: () => void): this;
|
||||
once(event: string, listener: (...args: any[]) => void): this;
|
||||
once(event: 'resize', listener: () => void): this;
|
||||
prependListener(event: string, listener: (...args: any[]) => void): this;
|
||||
prependListener(event: 'resize', listener: () => void): this;
|
||||
prependOnceListener(event: string, listener: (...args: any[]) => void): this;
|
||||
prependOnceListener(event: 'resize', listener: () => void): this;
|
||||
/**
|
||||
* `writeStream.clearLine()` clears the current line of this `WriteStream` in a
|
||||
* direction identified by `dir`.
|
||||
* @since v0.7.7
|
||||
* @param callback Invoked once the operation completes.
|
||||
* @return `false` if the stream wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
|
||||
*/
|
||||
clearLine(dir: Direction, callback?: () => void): boolean;
|
||||
/**
|
||||
* `writeStream.clearScreenDown()` clears this `WriteStream` from the current
|
||||
* cursor down.
|
||||
* @since v0.7.7
|
||||
* @param callback Invoked once the operation completes.
|
||||
* @return `false` if the stream wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
|
||||
*/
|
||||
clearScreenDown(callback?: () => void): boolean;
|
||||
/**
|
||||
* `writeStream.cursorTo()` moves this `WriteStream`'s cursor to the specified
|
||||
* position.
|
||||
* @since v0.7.7
|
||||
* @param callback Invoked once the operation completes.
|
||||
* @return `false` if the stream wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
|
||||
*/
|
||||
cursorTo(x: number, y?: number, callback?: () => void): boolean;
|
||||
cursorTo(x: number, callback: () => void): boolean;
|
||||
/**
|
||||
* `writeStream.moveCursor()` moves this `WriteStream`'s cursor _relative_ to its
|
||||
* current position.
|
||||
* @since v0.7.7
|
||||
* @param callback Invoked once the operation completes.
|
||||
* @return `false` if the stream wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
|
||||
*/
|
||||
moveCursor(dx: number, dy: number, callback?: () => void): boolean;
|
||||
/**
|
||||
* Returns:
|
||||
*
|
||||
* * `1` for 2,
|
||||
* * `4` for 16,
|
||||
* * `8` for 256,
|
||||
* * `24` for 16,777,216 colors supported.
|
||||
*
|
||||
* Use this to determine what colors the terminal supports. Due to the nature of
|
||||
* colors in terminals it is possible to either have false positives or false
|
||||
* negatives. It depends on process information and the environment variables that
|
||||
* may lie about what terminal is used.
|
||||
* It is possible to pass in an `env` object to simulate the usage of a specific
|
||||
* terminal. This can be useful to check how specific environment settings behave.
|
||||
*
|
||||
* To enforce a specific color support, use one of the below environment settings.
|
||||
*
|
||||
* * 2 colors: `FORCE_COLOR = 0` (Disables colors)
|
||||
* * 16 colors: `FORCE_COLOR = 1`
|
||||
* * 256 colors: `FORCE_COLOR = 2`
|
||||
* * 16,777,216 colors: `FORCE_COLOR = 3`
|
||||
*
|
||||
* Disabling color support is also possible by using the `NO_COLOR` and`NODE_DISABLE_COLORS` environment variables.
|
||||
* @since v9.9.0
|
||||
* @param [env=process.env] An object containing the environment variables to check. This enables simulating the usage of a specific terminal.
|
||||
*/
|
||||
getColorDepth(env?: object): number;
|
||||
/**
|
||||
* Returns `true` if the `writeStream` supports at least as many colors as provided
|
||||
* in `count`. Minimum support is 2 (black and white).
|
||||
*
|
||||
* This has the same false positives and negatives as described in `writeStream.getColorDepth()`.
|
||||
*
|
||||
* ```js
|
||||
* process.stdout.hasColors();
|
||||
* // Returns true or false depending on if `stdout` supports at least 16 colors.
|
||||
* process.stdout.hasColors(256);
|
||||
* // Returns true or false depending on if `stdout` supports at least 256 colors.
|
||||
* process.stdout.hasColors({ TMUX: '1' });
|
||||
* // Returns true.
|
||||
* process.stdout.hasColors(2 ** 24, { TMUX: '1' });
|
||||
* // Returns false (the environment setting pretends to support 2 ** 8 colors).
|
||||
* ```
|
||||
* @since v11.13.0, v10.16.0
|
||||
* @param [count=16] The number of colors that are requested (minimum 2).
|
||||
* @param [env=process.env] An object containing the environment variables to check. This enables simulating the usage of a specific terminal.
|
||||
*/
|
||||
hasColors(count?: number): boolean;
|
||||
hasColors(env?: object): boolean;
|
||||
hasColors(count: number, env?: object): boolean;
|
||||
/**
|
||||
* `writeStream.getWindowSize()` returns the size of the TTY
|
||||
* corresponding to this `WriteStream`. The array is of the type`[numColumns, numRows]` where `numColumns` and `numRows` represent the number
|
||||
* of columns and rows in the corresponding TTY.
|
||||
* @since v0.7.7
|
||||
*/
|
||||
getWindowSize(): [number, number];
|
||||
/**
|
||||
* A `number` specifying the number of columns the TTY currently has. This property
|
||||
* is updated whenever the `'resize'` event is emitted.
|
||||
* @since v0.7.7
|
||||
*/
|
||||
columns: number;
|
||||
/**
|
||||
* A `number` specifying the number of rows the TTY currently has. This property
|
||||
* is updated whenever the `'resize'` event is emitted.
|
||||
* @since v0.7.7
|
||||
*/
|
||||
rows: number;
|
||||
/**
|
||||
* A `boolean` that is always `true`.
|
||||
* @since v0.5.8
|
||||
*/
|
||||
isTTY: boolean;
|
||||
}
|
||||
}
|
||||
declare module 'node:tty' {
|
||||
export * from 'tty';
|
||||
}
|
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,509 @@
|
||||
/**
|
||||
* The `vm` module enables compiling and running code within V8 Virtual
|
||||
* Machine contexts.
|
||||
*
|
||||
* **The `vm` module is not a security**
|
||||
* **mechanism. Do not use it to run untrusted code.**
|
||||
*
|
||||
* JavaScript code can be compiled and run immediately or
|
||||
* compiled, saved, and run later.
|
||||
*
|
||||
* A common use case is to run the code in a different V8 Context. This means
|
||||
* invoked code has a different global object than the invoking code.
|
||||
*
|
||||
* One can provide the context by `contextifying` an
|
||||
* object. The invoked code treats any property in the context like a
|
||||
* global variable. Any changes to global variables caused by the invoked
|
||||
* code are reflected in the context object.
|
||||
*
|
||||
* ```js
|
||||
* const vm = require('vm');
|
||||
*
|
||||
* const x = 1;
|
||||
*
|
||||
* const context = { x: 2 };
|
||||
* vm.createContext(context); // Contextify the object.
|
||||
*
|
||||
* const code = 'x += 40; var y = 17;';
|
||||
* // `x` and `y` are global variables in the context.
|
||||
* // Initially, x has the value 2 because that is the value of context.x.
|
||||
* vm.runInContext(code, context);
|
||||
*
|
||||
* console.log(context.x); // 42
|
||||
* console.log(context.y); // 17
|
||||
*
|
||||
* console.log(x); // 1; y is not defined.
|
||||
* ```
|
||||
* @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/vm.js)
|
||||
*/
|
||||
declare module 'vm' {
|
||||
interface Context extends NodeJS.Dict<any> {}
|
||||
interface BaseOptions {
|
||||
/**
|
||||
* Specifies the filename used in stack traces produced by this script.
|
||||
* Default: `''`.
|
||||
*/
|
||||
filename?: string | undefined;
|
||||
/**
|
||||
* Specifies the line number offset that is displayed in stack traces produced by this script.
|
||||
* Default: `0`.
|
||||
*/
|
||||
lineOffset?: number | undefined;
|
||||
/**
|
||||
* Specifies the column number offset that is displayed in stack traces produced by this script.
|
||||
* @default 0
|
||||
*/
|
||||
columnOffset?: number | undefined;
|
||||
}
|
||||
interface ScriptOptions extends BaseOptions {
|
||||
displayErrors?: boolean | undefined;
|
||||
timeout?: number | undefined;
|
||||
cachedData?: Buffer | undefined;
|
||||
/** @deprecated in favor of `script.createCachedData()` */
|
||||
produceCachedData?: boolean | undefined;
|
||||
}
|
||||
interface RunningScriptOptions extends BaseOptions {
|
||||
/**
|
||||
* When `true`, if an `Error` occurs while compiling the `code`, the line of code causing the error is attached to the stack trace.
|
||||
* Default: `true`.
|
||||
*/
|
||||
displayErrors?: boolean | undefined;
|
||||
/**
|
||||
* Specifies the number of milliseconds to execute code before terminating execution.
|
||||
* If execution is terminated, an `Error` will be thrown. This value must be a strictly positive integer.
|
||||
*/
|
||||
timeout?: number | undefined;
|
||||
/**
|
||||
* If `true`, the execution will be terminated when `SIGINT` (Ctrl+C) is received.
|
||||
* Existing handlers for the event that have been attached via `process.on('SIGINT')` will be disabled during script execution, but will continue to work after that.
|
||||
* If execution is terminated, an `Error` will be thrown.
|
||||
* Default: `false`.
|
||||
*/
|
||||
breakOnSigint?: boolean | undefined;
|
||||
/**
|
||||
* If set to `afterEvaluate`, microtasks will be run immediately after the script has run.
|
||||
*/
|
||||
microtaskMode?: 'afterEvaluate' | undefined;
|
||||
}
|
||||
interface CompileFunctionOptions extends BaseOptions {
|
||||
/**
|
||||
* Provides an optional data with V8's code cache data for the supplied source.
|
||||
*/
|
||||
cachedData?: Buffer | undefined;
|
||||
/**
|
||||
* Specifies whether to produce new cache data.
|
||||
* Default: `false`,
|
||||
*/
|
||||
produceCachedData?: boolean | undefined;
|
||||
/**
|
||||
* The sandbox/context in which the said function should be compiled in.
|
||||
*/
|
||||
parsingContext?: Context | undefined;
|
||||
/**
|
||||
* An array containing a collection of context extensions (objects wrapping the current scope) to be applied while compiling
|
||||
*/
|
||||
contextExtensions?: Object[] | undefined;
|
||||
}
|
||||
interface CreateContextOptions {
|
||||
/**
|
||||
* Human-readable name of the newly created context.
|
||||
* @default 'VM Context i' Where i is an ascending numerical index of the created context.
|
||||
*/
|
||||
name?: string | undefined;
|
||||
/**
|
||||
* Corresponds to the newly created context for display purposes.
|
||||
* The origin should be formatted like a `URL`, but with only the scheme, host, and port (if necessary),
|
||||
* like the value of the `url.origin` property of a URL object.
|
||||
* Most notably, this string should omit the trailing slash, as that denotes a path.
|
||||
* @default ''
|
||||
*/
|
||||
origin?: string | undefined;
|
||||
codeGeneration?:
|
||||
| {
|
||||
/**
|
||||
* If set to false any calls to eval or function constructors (Function, GeneratorFunction, etc)
|
||||
* will throw an EvalError.
|
||||
* @default true
|
||||
*/
|
||||
strings?: boolean | undefined;
|
||||
/**
|
||||
* If set to false any attempt to compile a WebAssembly module will throw a WebAssembly.CompileError.
|
||||
* @default true
|
||||
*/
|
||||
wasm?: boolean | undefined;
|
||||
}
|
||||
| undefined;
|
||||
/**
|
||||
* If set to `afterEvaluate`, microtasks will be run immediately after the script has run.
|
||||
*/
|
||||
microtaskMode?: 'afterEvaluate' | undefined;
|
||||
}
|
||||
type MeasureMemoryMode = 'summary' | 'detailed';
|
||||
interface MeasureMemoryOptions {
|
||||
/**
|
||||
* @default 'summary'
|
||||
*/
|
||||
mode?: MeasureMemoryMode | undefined;
|
||||
context?: Context | undefined;
|
||||
}
|
||||
interface MemoryMeasurement {
|
||||
total: {
|
||||
jsMemoryEstimate: number;
|
||||
jsMemoryRange: [number, number];
|
||||
};
|
||||
}
|
||||
/**
|
||||
* Instances of the `vm.Script` class contain precompiled scripts that can be
|
||||
* executed in specific contexts.
|
||||
* @since v0.3.1
|
||||
*/
|
||||
class Script {
|
||||
constructor(code: string, options?: ScriptOptions);
|
||||
/**
|
||||
* Runs the compiled code contained by the `vm.Script` object within the given`contextifiedObject` and returns the result. Running code does not have access
|
||||
* to local scope.
|
||||
*
|
||||
* The following example compiles code that increments a global variable, sets
|
||||
* the value of another global variable, then execute the code multiple times.
|
||||
* The globals are contained in the `context` object.
|
||||
*
|
||||
* ```js
|
||||
* const vm = require('vm');
|
||||
*
|
||||
* const context = {
|
||||
* animal: 'cat',
|
||||
* count: 2
|
||||
* };
|
||||
*
|
||||
* const script = new vm.Script('count += 1; name = "kitty";');
|
||||
*
|
||||
* vm.createContext(context);
|
||||
* for (let i = 0; i < 10; ++i) {
|
||||
* script.runInContext(context);
|
||||
* }
|
||||
*
|
||||
* console.log(context);
|
||||
* // Prints: { animal: 'cat', count: 12, name: 'kitty' }
|
||||
* ```
|
||||
*
|
||||
* Using the `timeout` or `breakOnSigint` options will result in new event loops
|
||||
* and corresponding threads being started, which have a non-zero performance
|
||||
* overhead.
|
||||
* @since v0.3.1
|
||||
* @param contextifiedObject A `contextified` object as returned by the `vm.createContext()` method.
|
||||
* @return the result of the very last statement executed in the script.
|
||||
*/
|
||||
runInContext(contextifiedObject: Context, options?: RunningScriptOptions): any;
|
||||
/**
|
||||
* First contextifies the given `contextObject`, runs the compiled code contained
|
||||
* by the `vm.Script` object within the created context, and returns the result.
|
||||
* Running code does not have access to local scope.
|
||||
*
|
||||
* The following example compiles code that sets a global variable, then executes
|
||||
* the code multiple times in different contexts. The globals are set on and
|
||||
* contained within each individual `context`.
|
||||
*
|
||||
* ```js
|
||||
* const vm = require('vm');
|
||||
*
|
||||
* const script = new vm.Script('globalVar = "set"');
|
||||
*
|
||||
* const contexts = [{}, {}, {}];
|
||||
* contexts.forEach((context) => {
|
||||
* script.runInNewContext(context);
|
||||
* });
|
||||
*
|
||||
* console.log(contexts);
|
||||
* // Prints: [{ globalVar: 'set' }, { globalVar: 'set' }, { globalVar: 'set' }]
|
||||
* ```
|
||||
* @since v0.3.1
|
||||
* @param contextObject An object that will be `contextified`. If `undefined`, a new object will be created.
|
||||
* @return the result of the very last statement executed in the script.
|
||||
*/
|
||||
runInNewContext(contextObject?: Context, options?: RunningScriptOptions): any;
|
||||
/**
|
||||
* Runs the compiled code contained by the `vm.Script` within the context of the
|
||||
* current `global` object. Running code does not have access to local scope, but _does_ have access to the current `global` object.
|
||||
*
|
||||
* The following example compiles code that increments a `global` variable then
|
||||
* executes that code multiple times:
|
||||
*
|
||||
* ```js
|
||||
* const vm = require('vm');
|
||||
*
|
||||
* global.globalVar = 0;
|
||||
*
|
||||
* const script = new vm.Script('globalVar += 1', { filename: 'myfile.vm' });
|
||||
*
|
||||
* for (let i = 0; i < 1000; ++i) {
|
||||
* script.runInThisContext();
|
||||
* }
|
||||
*
|
||||
* console.log(globalVar);
|
||||
*
|
||||
* // 1000
|
||||
* ```
|
||||
* @since v0.3.1
|
||||
* @return the result of the very last statement executed in the script.
|
||||
*/
|
||||
runInThisContext(options?: RunningScriptOptions): any;
|
||||
/**
|
||||
* Creates a code cache that can be used with the `Script` constructor's`cachedData` option. Returns a `Buffer`. This method may be called at any
|
||||
* time and any number of times.
|
||||
*
|
||||
* ```js
|
||||
* const script = new vm.Script(`
|
||||
* function add(a, b) {
|
||||
* return a + b;
|
||||
* }
|
||||
*
|
||||
* const x = add(1, 2);
|
||||
* `);
|
||||
*
|
||||
* const cacheWithoutX = script.createCachedData();
|
||||
*
|
||||
* script.runInThisContext();
|
||||
*
|
||||
* const cacheWithX = script.createCachedData();
|
||||
* ```
|
||||
* @since v10.6.0
|
||||
*/
|
||||
createCachedData(): Buffer;
|
||||
/** @deprecated in favor of `script.createCachedData()` */
|
||||
cachedDataProduced?: boolean | undefined;
|
||||
cachedDataRejected?: boolean | undefined;
|
||||
cachedData?: Buffer | undefined;
|
||||
}
|
||||
/**
|
||||
* If given a `contextObject`, the `vm.createContext()` method will `prepare
|
||||
* that object` so that it can be used in calls to {@link runInContext} or `script.runInContext()`. Inside such scripts,
|
||||
* the `contextObject` will be the global object, retaining all of its existing
|
||||
* properties but also having the built-in objects and functions any standard [global object](https://es5.github.io/#x15.1) has. Outside of scripts run by the vm module, global variables
|
||||
* will remain unchanged.
|
||||
*
|
||||
* ```js
|
||||
* const vm = require('vm');
|
||||
*
|
||||
* global.globalVar = 3;
|
||||
*
|
||||
* const context = { globalVar: 1 };
|
||||
* vm.createContext(context);
|
||||
*
|
||||
* vm.runInContext('globalVar *= 2;', context);
|
||||
*
|
||||
* console.log(context);
|
||||
* // Prints: { globalVar: 2 }
|
||||
*
|
||||
* console.log(global.globalVar);
|
||||
* // Prints: 3
|
||||
* ```
|
||||
*
|
||||
* If `contextObject` is omitted (or passed explicitly as `undefined`), a new,
|
||||
* empty `contextified` object will be returned.
|
||||
*
|
||||
* The `vm.createContext()` method is primarily useful for creating a single
|
||||
* context that can be used to run multiple scripts. For instance, if emulating a
|
||||
* web browser, the method can be used to create a single context representing a
|
||||
* window's global object, then run all `<script>` tags together within that
|
||||
* context.
|
||||
*
|
||||
* The provided `name` and `origin` of the context are made visible through the
|
||||
* Inspector API.
|
||||
* @since v0.3.1
|
||||
* @return contextified object.
|
||||
*/
|
||||
function createContext(sandbox?: Context, options?: CreateContextOptions): Context;
|
||||
/**
|
||||
* Returns `true` if the given `object` object has been `contextified` using {@link createContext}.
|
||||
* @since v0.11.7
|
||||
*/
|
||||
function isContext(sandbox: Context): boolean;
|
||||
/**
|
||||
* The `vm.runInContext()` method compiles `code`, runs it within the context of
|
||||
* the `contextifiedObject`, then returns the result. Running code does not have
|
||||
* access to the local scope. The `contextifiedObject` object _must_ have been
|
||||
* previously `contextified` using the {@link createContext} method.
|
||||
*
|
||||
* If `options` is a string, then it specifies the filename.
|
||||
*
|
||||
* The following example compiles and executes different scripts using a single `contextified` object:
|
||||
*
|
||||
* ```js
|
||||
* const vm = require('vm');
|
||||
*
|
||||
* const contextObject = { globalVar: 1 };
|
||||
* vm.createContext(contextObject);
|
||||
*
|
||||
* for (let i = 0; i < 10; ++i) {
|
||||
* vm.runInContext('globalVar *= 2;', contextObject);
|
||||
* }
|
||||
* console.log(contextObject);
|
||||
* // Prints: { globalVar: 1024 }
|
||||
* ```
|
||||
* @since v0.3.1
|
||||
* @param code The JavaScript code to compile and run.
|
||||
* @param contextifiedObject The `contextified` object that will be used as the `global` when the `code` is compiled and run.
|
||||
* @return the result of the very last statement executed in the script.
|
||||
*/
|
||||
function runInContext(code: string, contextifiedObject: Context, options?: RunningScriptOptions | string): any;
|
||||
/**
|
||||
* The `vm.runInNewContext()` first contextifies the given `contextObject` (or
|
||||
* creates a new `contextObject` if passed as `undefined`), compiles the `code`,
|
||||
* runs it within the created context, then returns the result. Running code
|
||||
* does not have access to the local scope.
|
||||
*
|
||||
* If `options` is a string, then it specifies the filename.
|
||||
*
|
||||
* The following example compiles and executes code that increments a global
|
||||
* variable and sets a new one. These globals are contained in the `contextObject`.
|
||||
*
|
||||
* ```js
|
||||
* const vm = require('vm');
|
||||
*
|
||||
* const contextObject = {
|
||||
* animal: 'cat',
|
||||
* count: 2
|
||||
* };
|
||||
*
|
||||
* vm.runInNewContext('count += 1; name = "kitty"', contextObject);
|
||||
* console.log(contextObject);
|
||||
* // Prints: { animal: 'cat', count: 3, name: 'kitty' }
|
||||
* ```
|
||||
* @since v0.3.1
|
||||
* @param code The JavaScript code to compile and run.
|
||||
* @param contextObject An object that will be `contextified`. If `undefined`, a new object will be created.
|
||||
* @return the result of the very last statement executed in the script.
|
||||
*/
|
||||
function runInNewContext(code: string, contextObject?: Context, options?: RunningScriptOptions | string): any;
|
||||
/**
|
||||
* `vm.runInThisContext()` compiles `code`, runs it within the context of the
|
||||
* current `global` and returns the result. Running code does not have access to
|
||||
* local scope, but does have access to the current `global` object.
|
||||
*
|
||||
* If `options` is a string, then it specifies the filename.
|
||||
*
|
||||
* The following example illustrates using both `vm.runInThisContext()` and
|
||||
* the JavaScript [`eval()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval) function to run the same code:
|
||||
*
|
||||
* ```js
|
||||
* const vm = require('vm');
|
||||
* let localVar = 'initial value';
|
||||
*
|
||||
* const vmResult = vm.runInThisContext('localVar = "vm";');
|
||||
* console.log(`vmResult: '${vmResult}', localVar: '${localVar}'`);
|
||||
* // Prints: vmResult: 'vm', localVar: 'initial value'
|
||||
*
|
||||
* const evalResult = eval('localVar = "eval";');
|
||||
* console.log(`evalResult: '${evalResult}', localVar: '${localVar}'`);
|
||||
* // Prints: evalResult: 'eval', localVar: 'eval'
|
||||
* ```
|
||||
*
|
||||
* Because `vm.runInThisContext()` does not have access to the local scope,`localVar` is unchanged. In contrast,
|
||||
* [`eval()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval) _does_ have access to the
|
||||
* local scope, so the value `localVar` is changed. In this way`vm.runInThisContext()` is much like an [indirect `eval()` call](https://es5.github.io/#x10.4.2), e.g.`(0,eval)('code')`.
|
||||
*
|
||||
* ## Example: Running an HTTP server within a VM
|
||||
*
|
||||
* When using either `script.runInThisContext()` or {@link runInThisContext}, the code is executed within the current V8 global
|
||||
* context. The code passed to this VM context will have its own isolated scope.
|
||||
*
|
||||
* In order to run a simple web server using the `http` module the code passed to
|
||||
* the context must either call `require('http')` on its own, or have a reference
|
||||
* to the `http` module passed to it. For instance:
|
||||
*
|
||||
* ```js
|
||||
* 'use strict';
|
||||
* const vm = require('vm');
|
||||
*
|
||||
* const code = `
|
||||
* ((require) => {
|
||||
* const http = require('http');
|
||||
*
|
||||
* http.createServer((request, response) => {
|
||||
* response.writeHead(200, { 'Content-Type': 'text/plain' });
|
||||
* response.end('Hello World\\n');
|
||||
* }).listen(8124);
|
||||
*
|
||||
* console.log('Server running at http://127.0.0.1:8124/');
|
||||
* })`;
|
||||
*
|
||||
* vm.runInThisContext(code)(require);
|
||||
* ```
|
||||
*
|
||||
* The `require()` in the above case shares the state with the context it is
|
||||
* passed from. This may introduce risks when untrusted code is executed, e.g.
|
||||
* altering objects in the context in unwanted ways.
|
||||
* @since v0.3.1
|
||||
* @param code The JavaScript code to compile and run.
|
||||
* @return the result of the very last statement executed in the script.
|
||||
*/
|
||||
function runInThisContext(code: string, options?: RunningScriptOptions | string): any;
|
||||
/**
|
||||
* Compiles the given code into the provided context (if no context is
|
||||
* supplied, the current context is used), and returns it wrapped inside a
|
||||
* function with the given `params`.
|
||||
* @since v10.10.0
|
||||
* @param code The body of the function to compile.
|
||||
* @param params An array of strings containing all parameters for the function.
|
||||
*/
|
||||
function compileFunction(code: string, params?: ReadonlyArray<string>, options?: CompileFunctionOptions): Function;
|
||||
/**
|
||||
* Measure the memory known to V8 and used by all contexts known to the
|
||||
* current V8 isolate, or the main context.
|
||||
*
|
||||
* The format of the object that the returned Promise may resolve with is
|
||||
* specific to the V8 engine and may change from one version of V8 to the next.
|
||||
*
|
||||
* The returned result is different from the statistics returned by`v8.getHeapSpaceStatistics()` in that `vm.measureMemory()` measure the
|
||||
* memory reachable by each V8 specific contexts in the current instance of
|
||||
* the V8 engine, while the result of `v8.getHeapSpaceStatistics()` measure
|
||||
* the memory occupied by each heap space in the current V8 instance.
|
||||
*
|
||||
* ```js
|
||||
* const vm = require('vm');
|
||||
* // Measure the memory used by the main context.
|
||||
* vm.measureMemory({ mode: 'summary' })
|
||||
* // This is the same as vm.measureMemory()
|
||||
* .then((result) => {
|
||||
* // The current format is:
|
||||
* // {
|
||||
* // total: {
|
||||
* // jsMemoryEstimate: 2418479, jsMemoryRange: [ 2418479, 2745799 ]
|
||||
* // }
|
||||
* // }
|
||||
* console.log(result);
|
||||
* });
|
||||
*
|
||||
* const context = vm.createContext({ a: 1 });
|
||||
* vm.measureMemory({ mode: 'detailed', execution: 'eager' })
|
||||
* .then((result) => {
|
||||
* // Reference the context here so that it won't be GC'ed
|
||||
* // until the measurement is complete.
|
||||
* console.log(context.a);
|
||||
* // {
|
||||
* // total: {
|
||||
* // jsMemoryEstimate: 2574732,
|
||||
* // jsMemoryRange: [ 2574732, 2904372 ]
|
||||
* // },
|
||||
* // current: {
|
||||
* // jsMemoryEstimate: 2438996,
|
||||
* // jsMemoryRange: [ 2438996, 2768636 ]
|
||||
* // },
|
||||
* // other: [
|
||||
* // {
|
||||
* // jsMemoryEstimate: 135736,
|
||||
* // jsMemoryRange: [ 135736, 465376 ]
|
||||
* // }
|
||||
* // ]
|
||||
* // }
|
||||
* console.log(result);
|
||||
* });
|
||||
* ```
|
||||
* @since v13.10.0
|
||||
* @experimental
|
||||
*/
|
||||
function measureMemory(options?: MeasureMemoryOptions): Promise<MemoryMeasurement>;
|
||||
}
|
||||
declare module 'node:vm' {
|
||||
export * from 'vm';
|
||||
}
|
@ -0,0 +1,158 @@
|
||||
/**
|
||||
* The WASI API provides an implementation of the [WebAssembly System Interface](https://wasi.dev/) specification. WASI gives sandboxed WebAssembly applications access to the
|
||||
* underlying operating system via a collection of POSIX-like functions.
|
||||
*
|
||||
* ```js
|
||||
* import { readFile } from 'fs/promises';
|
||||
* import { WASI } from 'wasi';
|
||||
* import { argv, env } from 'process';
|
||||
*
|
||||
* const wasi = new WASI({
|
||||
* args: argv,
|
||||
* env,
|
||||
* preopens: {
|
||||
* '/sandbox': '/some/real/path/that/wasm/can/access'
|
||||
* }
|
||||
* });
|
||||
*
|
||||
* // Some WASI binaries require:
|
||||
* // const importObject = { wasi_unstable: wasi.wasiImport };
|
||||
* const importObject = { wasi_snapshot_preview1: wasi.wasiImport };
|
||||
*
|
||||
* const wasm = await WebAssembly.compile(
|
||||
* await readFile(new URL('./demo.wasm', import.meta.url))
|
||||
* );
|
||||
* const instance = await WebAssembly.instantiate(wasm, importObject);
|
||||
*
|
||||
* wasi.start(instance);
|
||||
* ```
|
||||
*
|
||||
* To run the above example, create a new WebAssembly text format file named`demo.wat`:
|
||||
*
|
||||
* ```text
|
||||
* (module
|
||||
* ;; Import the required fd_write WASI function which will write the given io vectors to stdout
|
||||
* ;; The function signature for fd_write is:
|
||||
* ;; (File Descriptor, *iovs, iovs_len, nwritten) -> Returns number of bytes written
|
||||
* (import "wasi_snapshot_preview1" "fd_write" (func $fd_write (param i32 i32 i32 i32) (result i32)))
|
||||
*
|
||||
* (memory 1)
|
||||
* (export "memory" (memory 0))
|
||||
*
|
||||
* ;; Write 'hello world\n' to memory at an offset of 8 bytes
|
||||
* ;; Note the trailing newline which is required for the text to appear
|
||||
* (data (i32.const 8) "hello world\n")
|
||||
*
|
||||
* (func $main (export "_start")
|
||||
* ;; Creating a new io vector within linear memory
|
||||
* (i32.store (i32.const 0) (i32.const 8)) ;; iov.iov_base - This is a pointer to the start of the 'hello world\n' string
|
||||
* (i32.store (i32.const 4) (i32.const 12)) ;; iov.iov_len - The length of the 'hello world\n' string
|
||||
*
|
||||
* (call $fd_write
|
||||
* (i32.const 1) ;; file_descriptor - 1 for stdout
|
||||
* (i32.const 0) ;; *iovs - The pointer to the iov array, which is stored at memory location 0
|
||||
* (i32.const 1) ;; iovs_len - We're printing 1 string stored in an iov - so one.
|
||||
* (i32.const 20) ;; nwritten - A place in memory to store the number of bytes written
|
||||
* )
|
||||
* drop ;; Discard the number of bytes written from the top of the stack
|
||||
* )
|
||||
* )
|
||||
* ```
|
||||
*
|
||||
* Use [wabt](https://github.com/WebAssembly/wabt) to compile `.wat` to `.wasm`
|
||||
*
|
||||
* ```console
|
||||
* $ wat2wasm demo.wat
|
||||
* ```
|
||||
*
|
||||
* The `--experimental-wasi-unstable-preview1` CLI argument is needed for this
|
||||
* example to run.
|
||||
* @experimental
|
||||
* @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/wasi.js)
|
||||
*/
|
||||
declare module 'wasi' {
|
||||
interface WASIOptions {
|
||||
/**
|
||||
* An array of strings that the WebAssembly application will
|
||||
* see as command line arguments. The first argument is the virtual path to the
|
||||
* WASI command itself.
|
||||
*/
|
||||
args?: string[] | undefined;
|
||||
/**
|
||||
* An object similar to `process.env` that the WebAssembly
|
||||
* application will see as its environment.
|
||||
*/
|
||||
env?: object | undefined;
|
||||
/**
|
||||
* This object represents the WebAssembly application's
|
||||
* sandbox directory structure. The string keys of `preopens` are treated as
|
||||
* directories within the sandbox. The corresponding values in `preopens` are
|
||||
* the real paths to those directories on the host machine.
|
||||
*/
|
||||
preopens?: NodeJS.Dict<string> | undefined;
|
||||
/**
|
||||
* By default, WASI applications terminate the Node.js
|
||||
* process via the `__wasi_proc_exit()` function. Setting this option to `true`
|
||||
* causes `wasi.start()` to return the exit code rather than terminate the
|
||||
* process.
|
||||
* @default false
|
||||
*/
|
||||
returnOnExit?: boolean | undefined;
|
||||
/**
|
||||
* The file descriptor used as standard input in the WebAssembly application.
|
||||
* @default 0
|
||||
*/
|
||||
stdin?: number | undefined;
|
||||
/**
|
||||
* The file descriptor used as standard output in the WebAssembly application.
|
||||
* @default 1
|
||||
*/
|
||||
stdout?: number | undefined;
|
||||
/**
|
||||
* The file descriptor used as standard error in the WebAssembly application.
|
||||
* @default 2
|
||||
*/
|
||||
stderr?: number | undefined;
|
||||
}
|
||||
/**
|
||||
* The `WASI` class provides the WASI system call API and additional convenience
|
||||
* methods for working with WASI-based applications. Each `WASI` instance
|
||||
* represents a distinct sandbox environment. For security purposes, each `WASI`instance must have its command-line arguments, environment variables, and
|
||||
* sandbox directory structure configured explicitly.
|
||||
* @since v13.3.0, v12.16.0
|
||||
*/
|
||||
class WASI {
|
||||
constructor(options?: WASIOptions);
|
||||
/**
|
||||
* Attempt to begin execution of `instance` as a WASI command by invoking its`_start()` export. If `instance` does not contain a `_start()` export, or if`instance` contains an `_initialize()`
|
||||
* export, then an exception is thrown.
|
||||
*
|
||||
* `start()` requires that `instance` exports a [`WebAssembly.Memory`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory) named`memory`. If
|
||||
* `instance` does not have a `memory` export an exception is thrown.
|
||||
*
|
||||
* If `start()` is called more than once, an exception is thrown.
|
||||
* @since v13.3.0, v12.16.0
|
||||
*/
|
||||
start(instance: object): void; // TODO: avoid DOM dependency until WASM moved to own lib.
|
||||
/**
|
||||
* Attempt to initialize `instance` as a WASI reactor by invoking its`_initialize()` export, if it is present. If `instance` contains a `_start()`export, then an exception is thrown.
|
||||
*
|
||||
* `initialize()` requires that `instance` exports a [`WebAssembly.Memory`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Memory) named`memory`.
|
||||
* If `instance` does not have a `memory` export an exception is thrown.
|
||||
*
|
||||
* If `initialize()` is called more than once, an exception is thrown.
|
||||
* @since v14.6.0, v12.19.0
|
||||
*/
|
||||
initialize(instance: object): void; // TODO: avoid DOM dependency until WASM moved to own lib.
|
||||
/**
|
||||
* `wasiImport` is an object that implements the WASI system call API. This object
|
||||
* should be passed as the `wasi_snapshot_preview1` import during the instantiation
|
||||
* of a [`WebAssembly.Instance`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WebAssembly/Instance).
|
||||
* @since v13.3.0, v12.16.0
|
||||
*/
|
||||
readonly wasiImport: NodeJS.Dict<any>; // TODO: Narrow to DOM types
|
||||
}
|
||||
}
|
||||
declare module 'node:wasi' {
|
||||
export * from 'wasi';
|
||||
}
|
646
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/worker_threads.d.ts
generated
vendored
646
node_modules/.pnpm/@types+node@18.7.13/node_modules/@types/node/worker_threads.d.ts
generated
vendored
@ -0,0 +1,517 @@
|
||||
/**
|
||||
* The `zlib` module provides compression functionality implemented using Gzip,
|
||||
* Deflate/Inflate, and Brotli.
|
||||
*
|
||||
* To access it:
|
||||
*
|
||||
* ```js
|
||||
* const zlib = require('zlib');
|
||||
* ```
|
||||
*
|
||||
* Compression and decompression are built around the Node.js `Streams API`.
|
||||
*
|
||||
* Compressing or decompressing a stream (such as a file) can be accomplished by
|
||||
* piping the source stream through a `zlib` `Transform` stream into a destination
|
||||
* stream:
|
||||
*
|
||||
* ```js
|
||||
* const { createGzip } = require('zlib');
|
||||
* const { pipeline } = require('stream');
|
||||
* const {
|
||||
* createReadStream,
|
||||
* createWriteStream
|
||||
* } = require('fs');
|
||||
*
|
||||
* const gzip = createGzip();
|
||||
* const source = createReadStream('input.txt');
|
||||
* const destination = createWriteStream('input.txt.gz');
|
||||
*
|
||||
* pipeline(source, gzip, destination, (err) => {
|
||||
* if (err) {
|
||||
* console.error('An error occurred:', err);
|
||||
* process.exitCode = 1;
|
||||
* }
|
||||
* });
|
||||
*
|
||||
* // Or, Promisified
|
||||
*
|
||||
* const { promisify } = require('util');
|
||||
* const pipe = promisify(pipeline);
|
||||
*
|
||||
* async function do_gzip(input, output) {
|
||||
* const gzip = createGzip();
|
||||
* const source = createReadStream(input);
|
||||
* const destination = createWriteStream(output);
|
||||
* await pipe(source, gzip, destination);
|
||||
* }
|
||||
*
|
||||
* do_gzip('input.txt', 'input.txt.gz')
|
||||
* .catch((err) => {
|
||||
* console.error('An error occurred:', err);
|
||||
* process.exitCode = 1;
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* It is also possible to compress or decompress data in a single step:
|
||||
*
|
||||
* ```js
|
||||
* const { deflate, unzip } = require('zlib');
|
||||
*
|
||||
* const input = '.................................';
|
||||
* deflate(input, (err, buffer) => {
|
||||
* if (err) {
|
||||
* console.error('An error occurred:', err);
|
||||
* process.exitCode = 1;
|
||||
* }
|
||||
* console.log(buffer.toString('base64'));
|
||||
* });
|
||||
*
|
||||
* const buffer = Buffer.from('eJzT0yMAAGTvBe8=', 'base64');
|
||||
* unzip(buffer, (err, buffer) => {
|
||||
* if (err) {
|
||||
* console.error('An error occurred:', err);
|
||||
* process.exitCode = 1;
|
||||
* }
|
||||
* console.log(buffer.toString());
|
||||
* });
|
||||
*
|
||||
* // Or, Promisified
|
||||
*
|
||||
* const { promisify } = require('util');
|
||||
* const do_unzip = promisify(unzip);
|
||||
*
|
||||
* do_unzip(buffer)
|
||||
* .then((buf) => console.log(buf.toString()))
|
||||
* .catch((err) => {
|
||||
* console.error('An error occurred:', err);
|
||||
* process.exitCode = 1;
|
||||
* });
|
||||
* ```
|
||||
* @since v0.5.8
|
||||
* @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/zlib.js)
|
||||
*/
|
||||
declare module 'zlib' {
|
||||
import * as stream from 'node:stream';
|
||||
interface ZlibOptions {
|
||||
/**
|
||||
* @default constants.Z_NO_FLUSH
|
||||
*/
|
||||
flush?: number | undefined;
|
||||
/**
|
||||
* @default constants.Z_FINISH
|
||||
*/
|
||||
finishFlush?: number | undefined;
|
||||
/**
|
||||
* @default 16*1024
|
||||
*/
|
||||
chunkSize?: number | undefined;
|
||||
windowBits?: number | 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
|
||||
info?: boolean | undefined;
|
||||
maxOutputLength?: number | undefined;
|
||||
}
|
||||
interface BrotliOptions {
|
||||
/**
|
||||
* @default constants.BROTLI_OPERATION_PROCESS
|
||||
*/
|
||||
flush?: number | undefined;
|
||||
/**
|
||||
* @default constants.BROTLI_OPERATION_FINISH
|
||||
*/
|
||||
finishFlush?: number | undefined;
|
||||
/**
|
||||
* @default 16*1024
|
||||
*/
|
||||
chunkSize?: number | undefined;
|
||||
params?:
|
||||
| {
|
||||
/**
|
||||
* Each key is a `constants.BROTLI_*` constant.
|
||||
*/
|
||||
[key: number]: boolean | number;
|
||||
}
|
||||
| undefined;
|
||||
maxOutputLength?: number | undefined;
|
||||
}
|
||||
interface Zlib {
|
||||
/** @deprecated Use bytesWritten instead. */
|
||||
readonly bytesRead: number;
|
||||
readonly bytesWritten: number;
|
||||
shell?: boolean | string | undefined;
|
||||
close(callback?: () => void): void;
|
||||
flush(kind?: number, callback?: () => void): void;
|
||||
flush(callback?: () => void): void;
|
||||
}
|
||||
interface ZlibParams {
|
||||
params(level: number, strategy: number, callback: () => void): void;
|
||||
}
|
||||
interface ZlibReset {
|
||||
reset(): void;
|
||||
}
|
||||
interface BrotliCompress extends stream.Transform, Zlib {}
|
||||
interface BrotliDecompress extends stream.Transform, Zlib {}
|
||||
interface Gzip extends stream.Transform, Zlib {}
|
||||
interface Gunzip extends stream.Transform, Zlib {}
|
||||
interface Deflate extends stream.Transform, Zlib, ZlibReset, ZlibParams {}
|
||||
interface Inflate extends stream.Transform, Zlib, ZlibReset {}
|
||||
interface DeflateRaw extends stream.Transform, Zlib, ZlibReset, ZlibParams {}
|
||||
interface InflateRaw extends stream.Transform, Zlib, ZlibReset {}
|
||||
interface Unzip extends stream.Transform, Zlib {}
|
||||
/**
|
||||
* Creates and returns a new `BrotliCompress` object.
|
||||
* @since v11.7.0, v10.16.0
|
||||
*/
|
||||
function createBrotliCompress(options?: BrotliOptions): BrotliCompress;
|
||||
/**
|
||||
* Creates and returns a new `BrotliDecompress` object.
|
||||
* @since v11.7.0, v10.16.0
|
||||
*/
|
||||
function createBrotliDecompress(options?: BrotliOptions): BrotliDecompress;
|
||||
/**
|
||||
* Creates and returns a new `Gzip` object.
|
||||
* See `example`.
|
||||
* @since v0.5.8
|
||||
*/
|
||||
function createGzip(options?: ZlibOptions): Gzip;
|
||||
/**
|
||||
* Creates and returns a new `Gunzip` object.
|
||||
* @since v0.5.8
|
||||
*/
|
||||
function createGunzip(options?: ZlibOptions): Gunzip;
|
||||
/**
|
||||
* Creates and returns a new `Deflate` object.
|
||||
* @since v0.5.8
|
||||
*/
|
||||
function createDeflate(options?: ZlibOptions): Deflate;
|
||||
/**
|
||||
* Creates and returns a new `Inflate` object.
|
||||
* @since v0.5.8
|
||||
*/
|
||||
function createInflate(options?: ZlibOptions): Inflate;
|
||||
/**
|
||||
* Creates and returns a new `DeflateRaw` object.
|
||||
*
|
||||
* An upgrade of zlib from 1.2.8 to 1.2.11 changed behavior when `windowBits`is set to 8 for raw deflate streams. zlib would automatically set `windowBits`to 9 if was initially set to 8\. Newer
|
||||
* versions of zlib will throw an exception,
|
||||
* so Node.js restored the original behavior of upgrading a value of 8 to 9,
|
||||
* since passing `windowBits = 9` to zlib actually results in a compressed stream
|
||||
* that effectively uses an 8-bit window only.
|
||||
* @since v0.5.8
|
||||
*/
|
||||
function createDeflateRaw(options?: ZlibOptions): DeflateRaw;
|
||||
/**
|
||||
* Creates and returns a new `InflateRaw` object.
|
||||
* @since v0.5.8
|
||||
*/
|
||||
function createInflateRaw(options?: ZlibOptions): InflateRaw;
|
||||
/**
|
||||
* Creates and returns a new `Unzip` object.
|
||||
* @since v0.5.8
|
||||
*/
|
||||
function createUnzip(options?: ZlibOptions): Unzip;
|
||||
type InputType = string | ArrayBuffer | NodeJS.ArrayBufferView;
|
||||
type CompressCallback = (error: Error | null, result: Buffer) => void;
|
||||
/**
|
||||
* @since v11.7.0, v10.16.0
|
||||
*/
|
||||
function brotliCompress(buf: InputType, options: BrotliOptions, callback: CompressCallback): void;
|
||||
function brotliCompress(buf: InputType, callback: CompressCallback): void;
|
||||
namespace brotliCompress {
|
||||
function __promisify__(buffer: InputType, options?: BrotliOptions): Promise<Buffer>;
|
||||
}
|
||||
/**
|
||||
* Compress a chunk of data with `BrotliCompress`.
|
||||
* @since v11.7.0, v10.16.0
|
||||
*/
|
||||
function brotliCompressSync(buf: InputType, options?: BrotliOptions): Buffer;
|
||||
/**
|
||||
* @since v11.7.0, v10.16.0
|
||||
*/
|
||||
function brotliDecompress(buf: InputType, options: BrotliOptions, callback: CompressCallback): void;
|
||||
function brotliDecompress(buf: InputType, callback: CompressCallback): void;
|
||||
namespace brotliDecompress {
|
||||
function __promisify__(buffer: InputType, options?: BrotliOptions): Promise<Buffer>;
|
||||
}
|
||||
/**
|
||||
* Decompress a chunk of data with `BrotliDecompress`.
|
||||
* @since v11.7.0, v10.16.0
|
||||
*/
|
||||
function brotliDecompressSync(buf: InputType, options?: BrotliOptions): Buffer;
|
||||
/**
|
||||
* @since v0.6.0
|
||||
*/
|
||||
function deflate(buf: InputType, callback: CompressCallback): void;
|
||||
function deflate(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
|
||||
namespace deflate {
|
||||
function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
|
||||
}
|
||||
/**
|
||||
* Compress a chunk of data with `Deflate`.
|
||||
* @since v0.11.12
|
||||
*/
|
||||
function deflateSync(buf: InputType, options?: ZlibOptions): Buffer;
|
||||
/**
|
||||
* @since v0.6.0
|
||||
*/
|
||||
function deflateRaw(buf: InputType, callback: CompressCallback): void;
|
||||
function deflateRaw(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
|
||||
namespace deflateRaw {
|
||||
function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
|
||||
}
|
||||
/**
|
||||
* Compress a chunk of data with `DeflateRaw`.
|
||||
* @since v0.11.12
|
||||
*/
|
||||
function deflateRawSync(buf: InputType, options?: ZlibOptions): Buffer;
|
||||
/**
|
||||
* @since v0.6.0
|
||||
*/
|
||||
function gzip(buf: InputType, callback: CompressCallback): void;
|
||||
function gzip(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
|
||||
namespace gzip {
|
||||
function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
|
||||
}
|
||||
/**
|
||||
* Compress a chunk of data with `Gzip`.
|
||||
* @since v0.11.12
|
||||
*/
|
||||
function gzipSync(buf: InputType, options?: ZlibOptions): Buffer;
|
||||
/**
|
||||
* @since v0.6.0
|
||||
*/
|
||||
function gunzip(buf: InputType, callback: CompressCallback): void;
|
||||
function gunzip(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
|
||||
namespace gunzip {
|
||||
function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
|
||||
}
|
||||
/**
|
||||
* Decompress a chunk of data with `Gunzip`.
|
||||
* @since v0.11.12
|
||||
*/
|
||||
function gunzipSync(buf: InputType, options?: ZlibOptions): Buffer;
|
||||
/**
|
||||
* @since v0.6.0
|
||||
*/
|
||||
function inflate(buf: InputType, callback: CompressCallback): void;
|
||||
function inflate(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
|
||||
namespace inflate {
|
||||
function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
|
||||
}
|
||||
/**
|
||||
* Decompress a chunk of data with `Inflate`.
|
||||
* @since v0.11.12
|
||||
*/
|
||||
function inflateSync(buf: InputType, options?: ZlibOptions): Buffer;
|
||||
/**
|
||||
* @since v0.6.0
|
||||
*/
|
||||
function inflateRaw(buf: InputType, callback: CompressCallback): void;
|
||||
function inflateRaw(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
|
||||
namespace inflateRaw {
|
||||
function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
|
||||
}
|
||||
/**
|
||||
* Decompress a chunk of data with `InflateRaw`.
|
||||
* @since v0.11.12
|
||||
*/
|
||||
function inflateRawSync(buf: InputType, options?: ZlibOptions): Buffer;
|
||||
/**
|
||||
* @since v0.6.0
|
||||
*/
|
||||
function unzip(buf: InputType, callback: CompressCallback): void;
|
||||
function unzip(buf: InputType, options: ZlibOptions, callback: CompressCallback): void;
|
||||
namespace unzip {
|
||||
function __promisify__(buffer: InputType, options?: ZlibOptions): Promise<Buffer>;
|
||||
}
|
||||
/**
|
||||
* Decompress a chunk of data with `Unzip`.
|
||||
* @since v0.11.12
|
||||
*/
|
||||
function unzipSync(buf: InputType, options?: ZlibOptions): Buffer;
|
||||
namespace constants {
|
||||
const BROTLI_DECODE: number;
|
||||
const BROTLI_DECODER_ERROR_ALLOC_BLOCK_TYPE_TREES: number;
|
||||
const BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MAP: number;
|
||||
const BROTLI_DECODER_ERROR_ALLOC_CONTEXT_MODES: number;
|
||||
const BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_1: number;
|
||||
const BROTLI_DECODER_ERROR_ALLOC_RING_BUFFER_2: number;
|
||||
const BROTLI_DECODER_ERROR_ALLOC_TREE_GROUPS: number;
|
||||
const BROTLI_DECODER_ERROR_DICTIONARY_NOT_SET: number;
|
||||
const BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_1: number;
|
||||
const BROTLI_DECODER_ERROR_FORMAT_BLOCK_LENGTH_2: number;
|
||||
const BROTLI_DECODER_ERROR_FORMAT_CL_SPACE: number;
|
||||
const BROTLI_DECODER_ERROR_FORMAT_CONTEXT_MAP_REPEAT: number;
|
||||
const BROTLI_DECODER_ERROR_FORMAT_DICTIONARY: number;
|
||||
const BROTLI_DECODER_ERROR_FORMAT_DISTANCE: number;
|
||||
const BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_META_NIBBLE: number;
|
||||
const BROTLI_DECODER_ERROR_FORMAT_EXUBERANT_NIBBLE: number;
|
||||
const BROTLI_DECODER_ERROR_FORMAT_HUFFMAN_SPACE: number;
|
||||
const BROTLI_DECODER_ERROR_FORMAT_PADDING_1: number;
|
||||
const BROTLI_DECODER_ERROR_FORMAT_PADDING_2: number;
|
||||
const BROTLI_DECODER_ERROR_FORMAT_RESERVED: number;
|
||||
const BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_ALPHABET: number;
|
||||
const BROTLI_DECODER_ERROR_FORMAT_SIMPLE_HUFFMAN_SAME: number;
|
||||
const BROTLI_DECODER_ERROR_FORMAT_TRANSFORM: number;
|
||||
const BROTLI_DECODER_ERROR_FORMAT_WINDOW_BITS: number;
|
||||
const BROTLI_DECODER_ERROR_INVALID_ARGUMENTS: number;
|
||||
const BROTLI_DECODER_ERROR_UNREACHABLE: number;
|
||||
const BROTLI_DECODER_NEEDS_MORE_INPUT: number;
|
||||
const BROTLI_DECODER_NEEDS_MORE_OUTPUT: number;
|
||||
const BROTLI_DECODER_NO_ERROR: number;
|
||||
const BROTLI_DECODER_PARAM_DISABLE_RING_BUFFER_REALLOCATION: number;
|
||||
const BROTLI_DECODER_PARAM_LARGE_WINDOW: number;
|
||||
const BROTLI_DECODER_RESULT_ERROR: number;
|
||||
const BROTLI_DECODER_RESULT_NEEDS_MORE_INPUT: number;
|
||||
const BROTLI_DECODER_RESULT_NEEDS_MORE_OUTPUT: number;
|
||||
const BROTLI_DECODER_RESULT_SUCCESS: number;
|
||||
const BROTLI_DECODER_SUCCESS: number;
|
||||
const BROTLI_DEFAULT_MODE: number;
|
||||
const BROTLI_DEFAULT_QUALITY: number;
|
||||
const BROTLI_DEFAULT_WINDOW: number;
|
||||
const BROTLI_ENCODE: number;
|
||||
const BROTLI_LARGE_MAX_WINDOW_BITS: number;
|
||||
const BROTLI_MAX_INPUT_BLOCK_BITS: number;
|
||||
const BROTLI_MAX_QUALITY: number;
|
||||
const BROTLI_MAX_WINDOW_BITS: number;
|
||||
const BROTLI_MIN_INPUT_BLOCK_BITS: number;
|
||||
const BROTLI_MIN_QUALITY: number;
|
||||
const BROTLI_MIN_WINDOW_BITS: number;
|
||||
const BROTLI_MODE_FONT: number;
|
||||
const BROTLI_MODE_GENERIC: number;
|
||||
const BROTLI_MODE_TEXT: number;
|
||||
const BROTLI_OPERATION_EMIT_METADATA: number;
|
||||
const BROTLI_OPERATION_FINISH: number;
|
||||
const BROTLI_OPERATION_FLUSH: number;
|
||||
const BROTLI_OPERATION_PROCESS: number;
|
||||
const BROTLI_PARAM_DISABLE_LITERAL_CONTEXT_MODELING: number;
|
||||
const BROTLI_PARAM_LARGE_WINDOW: number;
|
||||
const BROTLI_PARAM_LGBLOCK: number;
|
||||
const BROTLI_PARAM_LGWIN: number;
|
||||
const BROTLI_PARAM_MODE: number;
|
||||
const BROTLI_PARAM_NDIRECT: number;
|
||||
const BROTLI_PARAM_NPOSTFIX: number;
|
||||
const BROTLI_PARAM_QUALITY: number;
|
||||
const BROTLI_PARAM_SIZE_HINT: number;
|
||||
const DEFLATE: number;
|
||||
const DEFLATERAW: number;
|
||||
const GUNZIP: number;
|
||||
const GZIP: number;
|
||||
const INFLATE: number;
|
||||
const INFLATERAW: number;
|
||||
const UNZIP: number;
|
||||
// Allowed flush values.
|
||||
const Z_NO_FLUSH: number;
|
||||
const Z_PARTIAL_FLUSH: number;
|
||||
const Z_SYNC_FLUSH: number;
|
||||
const Z_FULL_FLUSH: number;
|
||||
const Z_FINISH: number;
|
||||
const Z_BLOCK: number;
|
||||
const Z_TREES: number;
|
||||
// Return codes for the compression/decompression functions.
|
||||
// Negative values are errors, positive values are used for special but normal events.
|
||||
const Z_OK: number;
|
||||
const Z_STREAM_END: number;
|
||||
const Z_NEED_DICT: number;
|
||||
const Z_ERRNO: number;
|
||||
const Z_STREAM_ERROR: number;
|
||||
const Z_DATA_ERROR: number;
|
||||
const Z_MEM_ERROR: number;
|
||||
const Z_BUF_ERROR: number;
|
||||
const Z_VERSION_ERROR: number;
|
||||
// Compression levels.
|
||||
const Z_NO_COMPRESSION: number;
|
||||
const Z_BEST_SPEED: number;
|
||||
const Z_BEST_COMPRESSION: number;
|
||||
const Z_DEFAULT_COMPRESSION: number;
|
||||
// Compression strategy.
|
||||
const Z_FILTERED: number;
|
||||
const Z_HUFFMAN_ONLY: number;
|
||||
const Z_RLE: number;
|
||||
const Z_FIXED: number;
|
||||
const Z_DEFAULT_STRATEGY: number;
|
||||
const Z_DEFAULT_WINDOWBITS: number;
|
||||
const Z_MIN_WINDOWBITS: number;
|
||||
const Z_MAX_WINDOWBITS: number;
|
||||
const Z_MIN_CHUNK: number;
|
||||
const Z_MAX_CHUNK: number;
|
||||
const Z_DEFAULT_CHUNK: number;
|
||||
const Z_MIN_MEMLEVEL: number;
|
||||
const Z_MAX_MEMLEVEL: number;
|
||||
const Z_DEFAULT_MEMLEVEL: number;
|
||||
const Z_MIN_LEVEL: number;
|
||||
const Z_MAX_LEVEL: number;
|
||||
const Z_DEFAULT_LEVEL: number;
|
||||
const ZLIB_VERNUM: number;
|
||||
}
|
||||
// Allowed flush values.
|
||||
/** @deprecated Use `constants.Z_NO_FLUSH` */
|
||||
const Z_NO_FLUSH: number;
|
||||
/** @deprecated Use `constants.Z_PARTIAL_FLUSH` */
|
||||
const Z_PARTIAL_FLUSH: number;
|
||||
/** @deprecated Use `constants.Z_SYNC_FLUSH` */
|
||||
const Z_SYNC_FLUSH: number;
|
||||
/** @deprecated Use `constants.Z_FULL_FLUSH` */
|
||||
const Z_FULL_FLUSH: number;
|
||||
/** @deprecated Use `constants.Z_FINISH` */
|
||||
const Z_FINISH: number;
|
||||
/** @deprecated Use `constants.Z_BLOCK` */
|
||||
const Z_BLOCK: number;
|
||||
/** @deprecated Use `constants.Z_TREES` */
|
||||
const Z_TREES: number;
|
||||
// Return codes for the compression/decompression functions.
|
||||
// Negative values are errors, positive values are used for special but normal events.
|
||||
/** @deprecated Use `constants.Z_OK` */
|
||||
const Z_OK: number;
|
||||
/** @deprecated Use `constants.Z_STREAM_END` */
|
||||
const Z_STREAM_END: number;
|
||||
/** @deprecated Use `constants.Z_NEED_DICT` */
|
||||
const Z_NEED_DICT: number;
|
||||
/** @deprecated Use `constants.Z_ERRNO` */
|
||||
const Z_ERRNO: number;
|
||||
/** @deprecated Use `constants.Z_STREAM_ERROR` */
|
||||
const Z_STREAM_ERROR: number;
|
||||
/** @deprecated Use `constants.Z_DATA_ERROR` */
|
||||
const Z_DATA_ERROR: number;
|
||||
/** @deprecated Use `constants.Z_MEM_ERROR` */
|
||||
const Z_MEM_ERROR: number;
|
||||
/** @deprecated Use `constants.Z_BUF_ERROR` */
|
||||
const Z_BUF_ERROR: number;
|
||||
/** @deprecated Use `constants.Z_VERSION_ERROR` */
|
||||
const Z_VERSION_ERROR: number;
|
||||
// Compression levels.
|
||||
/** @deprecated Use `constants.Z_NO_COMPRESSION` */
|
||||
const Z_NO_COMPRESSION: number;
|
||||
/** @deprecated Use `constants.Z_BEST_SPEED` */
|
||||
const Z_BEST_SPEED: number;
|
||||
/** @deprecated Use `constants.Z_BEST_COMPRESSION` */
|
||||
const Z_BEST_COMPRESSION: number;
|
||||
/** @deprecated Use `constants.Z_DEFAULT_COMPRESSION` */
|
||||
const Z_DEFAULT_COMPRESSION: number;
|
||||
// Compression strategy.
|
||||
/** @deprecated Use `constants.Z_FILTERED` */
|
||||
const Z_FILTERED: number;
|
||||
/** @deprecated Use `constants.Z_HUFFMAN_ONLY` */
|
||||
const Z_HUFFMAN_ONLY: number;
|
||||
/** @deprecated Use `constants.Z_RLE` */
|
||||
const Z_RLE: number;
|
||||
/** @deprecated Use `constants.Z_FIXED` */
|
||||
const Z_FIXED: number;
|
||||
/** @deprecated Use `constants.Z_DEFAULT_STRATEGY` */
|
||||
const Z_DEFAULT_STRATEGY: number;
|
||||
/** @deprecated */
|
||||
const Z_BINARY: number;
|
||||
/** @deprecated */
|
||||
const Z_TEXT: number;
|
||||
/** @deprecated */
|
||||
const Z_ASCII: number;
|
||||
/** @deprecated */
|
||||
const Z_UNKNOWN: number;
|
||||
/** @deprecated */
|
||||
const Z_DEFLATED: number;
|
||||
}
|
||||
declare module 'node:zlib' {
|
||||
export * from 'zlib';
|
||||
}
|
@ -0,0 +1 @@
|
||||
../../../@types+glob@7.2.0/node_modules/@types/glob
|
@ -0,0 +1,140 @@
|
||||
# [3.2.0](https://github.com/electron/asar/compare/v3.1.0...v3.2.0) (2022-07-29)
|
||||
|
||||
|
||||
### Features
|
||||
|
||||
* give better hints when failing due to bad links ([#241](https://github.com/electron/asar/issues/241)) ([db6d154](https://github.com/electron/asar/commit/db6d1541be05f67933f07c6f30d2425a05f13182))
|
||||
|
||||
# Changes By Version
|
||||
|
||||
## [2.0.1](https://github.com/electron/asar/compare/v2.0.0...v2.0.1) - 2019-04-29
|
||||
|
||||
### Fixed
|
||||
|
||||
* Don't monkeypatch fs with promisified versions ([#176](https://github.com/electron/asar/issues/176)) ([319dd81](https://github.com/electron/asar/commit/319dd81))
|
||||
|
||||
## [2.0.0](https://github.com/electron/asar/compare/v1.0.0...v2.0.0) - 2019-04-27
|
||||
|
||||
### Removed
|
||||
|
||||
* Support for Node < 8 ([#170](https://github.com/electron/asar/issues/170)) ([8a03eae](https://github.com/electron/asar/commit/8a03eae))
|
||||
|
||||
## 1.0.0 - 2019-02-19
|
||||
|
||||
### Added
|
||||
|
||||
* Promise-based async API (#165)
|
||||
|
||||
### Changed
|
||||
|
||||
* This module requires Node 6 or later (#165)
|
||||
|
||||
### Removed
|
||||
|
||||
* V8 snapshot support, which was undocumented and used an unmaintained dependency, which itself had a dependency with a security vulnerability (#165)
|
||||
* callback-style async API - if you still need to use this style of API, please check out the `nodeify` module (#165)
|
||||
|
||||
## 0.14.6 - 2018-12-10
|
||||
|
||||
### Fixed
|
||||
|
||||
* Normalize file paths in `asar.createPackageFromFiles` (#159)
|
||||
|
||||
## 0.14.5 - 2018-10-01
|
||||
|
||||
### Fixed
|
||||
|
||||
* Regression from #154
|
||||
|
||||
## 0.14.4 - 2018-09-30
|
||||
|
||||
### Added
|
||||
|
||||
* `--is-pack` CLI option / `isPack` option to `asar.listPackage` (#145)
|
||||
|
||||
### Fixed
|
||||
|
||||
* Allow `asar.createPackageFromFiles` to not pass `metadata` or `options` (#154)
|
||||
|
||||
## 0.14.3 - 2018-03-07
|
||||
|
||||
### Added
|
||||
|
||||
* `globOptions` option to pass options to the `glob` module
|
||||
* `pattern` option
|
||||
|
||||
## 0.14.2 - 2018-02-11
|
||||
|
||||
### Fixed
|
||||
|
||||
* Invoke callback if the last file in the list was marked as unpacked (#142)
|
||||
|
||||
## 0.14.1 - 2018-01-30
|
||||
|
||||
### Fixed
|
||||
|
||||
* Maximum call stack size exceeded during unpack (#140)
|
||||
|
||||
## 0.14.0 - 2017-11-02
|
||||
|
||||
### Added
|
||||
|
||||
* Snapcraft metadata (#130)
|
||||
* `uncache` and `uncacheAll` (#118)
|
||||
|
||||
### Fixed
|
||||
|
||||
* Use of asar inside of an Electron app (#118)
|
||||
|
||||
## 0.13.1 - 2017-11-02
|
||||
|
||||
### Fixed
|
||||
|
||||
- Do not return before the write stream fully closes (#113)
|
||||
|
||||
## 0.13.0 - 2017-01-09
|
||||
|
||||
### Changed
|
||||
|
||||
- Dropped support for Node `0.10.0` and `0.12.0`. The minimum supported version
|
||||
is now Node `4.6.0`. (#100)
|
||||
- This project was ported from CoffeeScript to JavaScript. The behavior and
|
||||
APIs should be the same as previous releases. (#100)
|
||||
|
||||
## 0.12.4 - 2016-12-28
|
||||
|
||||
### Fixed
|
||||
|
||||
- Unpack glob patterns containing `{}` characters not working properly (#99)
|
||||
|
||||
## 0.12.3 - 2016-08-29
|
||||
|
||||
### Fixed
|
||||
|
||||
- Multibyte characters in paths are now supported (#86)
|
||||
|
||||
## 0.12.2 - 2016-08-22
|
||||
|
||||
### Fixed
|
||||
|
||||
- Upgraded `minimatch` to `^3.0.3` from `^3.0.0` for [RegExp DOS fix](https://nodesecurity.io/advisories/minimatch_regular-expression-denial-of-service).
|
||||
|
||||
## 0.12.1 - 2016-07-25
|
||||
|
||||
### Fixed
|
||||
|
||||
- Fix `Maximum call stack size exceeded` error regression (#80)
|
||||
|
||||
## 0.12.0 - 2016-07-20
|
||||
|
||||
### Added
|
||||
|
||||
- Added `transform` option to specify a `stream.Transform` function to the
|
||||
`createPackageWithOptions` API (#73)
|
||||
|
||||
## 0.11.0 - 2016-04-06
|
||||
|
||||
### Fixed
|
||||
|
||||
- Upgraded `mksnapshot` dependency to remove logged `graceful-fs` deprecation
|
||||
warnings (#61)
|
@ -0,0 +1,20 @@
|
||||
Copyright (c) 2014 GitHub Inc.
|
||||
|
||||
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.
|
@ -0,0 +1,215 @@
|
||||
# asar - Electron Archive
|
||||
|
||||
[![CircleCI build status](https://circleci.com/gh/electron/asar/tree/main.svg?style=shield)](https://circleci.com/gh/electron/asar/tree/main)
|
||||
[![npm version](http://img.shields.io/npm/v/asar.svg)](https://npmjs.org/package/asar)
|
||||
|
||||
Asar is a simple extensive archive format, it works like `tar` that concatenates
|
||||
all files together without compression, while having random access support.
|
||||
|
||||
## Features
|
||||
|
||||
* Support random access
|
||||
* Use JSON to store files' information
|
||||
* Very easy to write a parser
|
||||
|
||||
## Command line utility
|
||||
|
||||
### Install
|
||||
|
||||
This module requires Node 10 or later.
|
||||
|
||||
```bash
|
||||
$ npm install --engine-strict asar
|
||||
```
|
||||
|
||||
### Usage
|
||||
|
||||
```bash
|
||||
$ asar --help
|
||||
|
||||
Usage: asar [options] [command]
|
||||
|
||||
Commands:
|
||||
|
||||
pack|p <dir> <output>
|
||||
create asar archive
|
||||
|
||||
list|l <archive>
|
||||
list files of asar archive
|
||||
|
||||
extract-file|ef <archive> <filename>
|
||||
extract one file from archive
|
||||
|
||||
extract|e <archive> <dest>
|
||||
extract archive
|
||||
|
||||
|
||||
Options:
|
||||
|
||||
-h, --help output usage information
|
||||
-V, --version output the version number
|
||||
|
||||
```
|
||||
|
||||
#### Excluding multiple resources from being packed
|
||||
|
||||
Given:
|
||||
```
|
||||
app
|
||||
(a) ├── x1
|
||||
(b) ├── x2
|
||||
(c) ├── y3
|
||||
(d) │ ├── x1
|
||||
(e) │ └── z1
|
||||
(f) │ └── x2
|
||||
(g) └── z4
|
||||
(h) └── w1
|
||||
```
|
||||
|
||||
Exclude: a, b
|
||||
```bash
|
||||
$ asar pack app app.asar --unpack-dir "{x1,x2}"
|
||||
```
|
||||
|
||||
Exclude: a, b, d, f
|
||||
```bash
|
||||
$ asar pack app app.asar --unpack-dir "**/{x1,x2}"
|
||||
```
|
||||
|
||||
Exclude: a, b, d, f, h
|
||||
```bash
|
||||
$ asar pack app app.asar --unpack-dir "{**/x1,**/x2,z4/w1}"
|
||||
```
|
||||
|
||||
## Using programatically
|
||||
|
||||
### Example
|
||||
|
||||
```javascript
|
||||
const asar = require('asar');
|
||||
|
||||
const src = 'some/path/';
|
||||
const dest = 'name.asar';
|
||||
|
||||
await asar.createPackage(src, dest);
|
||||
console.log('done.');
|
||||
```
|
||||
|
||||
Please note that there is currently **no** error handling provided!
|
||||
|
||||
### Transform
|
||||
You can pass in a `transform` option, that is a function, which either returns
|
||||
nothing, or a `stream.Transform`. The latter will be used on files that will be
|
||||
in the `.asar` file to transform them (e.g. compress).
|
||||
|
||||
```javascript
|
||||
const asar = require('asar');
|
||||
|
||||
const src = 'some/path/';
|
||||
const dest = 'name.asar';
|
||||
|
||||
function transform (filename) {
|
||||
return new CustomTransformStream()
|
||||
}
|
||||
|
||||
await asar.createPackageWithOptions(src, dest, { transform: transform });
|
||||
console.log('done.');
|
||||
```
|
||||
|
||||
## Using with grunt
|
||||
|
||||
There is also an unofficial grunt plugin to generate asar archives at [bwin/grunt-asar][grunt-asar].
|
||||
|
||||
## Format
|
||||
|
||||
Asar uses [Pickle][pickle] to safely serialize binary value to file, there is
|
||||
also a [node.js binding][node-pickle] of `Pickle` class.
|
||||
|
||||
The format of asar is very flat:
|
||||
|
||||
```
|
||||
| UInt32: header_size | String: header | Bytes: file1 | ... | Bytes: file42 |
|
||||
```
|
||||
|
||||
The `header_size` and `header` are serialized with [Pickle][pickle] class, and
|
||||
`header_size`'s [Pickle][pickle] object is 8 bytes.
|
||||
|
||||
The `header` is a JSON string, and the `header_size` is the size of `header`'s
|
||||
`Pickle` object.
|
||||
|
||||
Structure of `header` is something like this:
|
||||
|
||||
```json
|
||||
{
|
||||
"files": {
|
||||
"tmp": {
|
||||
"files": {}
|
||||
},
|
||||
"usr" : {
|
||||
"files": {
|
||||
"bin": {
|
||||
"files": {
|
||||
"ls": {
|
||||
"offset": "0",
|
||||
"size": 100,
|
||||
"executable": true,
|
||||
"integrity": {
|
||||
"algorithm": "SHA256",
|
||||
"hash": "...",
|
||||
"blockSize": 1024,
|
||||
"blocks": ["...", "..."]
|
||||
}
|
||||
},
|
||||
"cd": {
|
||||
"offset": "100",
|
||||
"size": 100,
|
||||
"executable": true,
|
||||
"integrity": {
|
||||
"algorithm": "SHA256",
|
||||
"hash": "...",
|
||||
"blockSize": 1024,
|
||||
"blocks": ["...", "..."]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
"etc": {
|
||||
"files": {
|
||||
"hosts": {
|
||||
"offset": "200",
|
||||
"size": 32,
|
||||
"integrity": {
|
||||
"algorithm": "SHA256",
|
||||
"hash": "...",
|
||||
"blockSize": 1024,
|
||||
"blocks": ["...", "..."]
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
`offset` and `size` records the information to read the file from archive, the
|
||||
`offset` starts from 0 so you have to manually add the size of `header_size` and
|
||||
`header` to the `offset` to get the real offset of the file.
|
||||
|
||||
`offset` is a UINT64 number represented in string, because there is no way to
|
||||
precisely represent UINT64 in JavaScript `Number`. `size` is a JavaScript
|
||||
`Number` that is no larger than `Number.MAX_SAFE_INTEGER`, which has a value of
|
||||
`9007199254740991` and is about 8PB in size. We didn't store `size` in UINT64
|
||||
because file size in Node.js is represented as `Number` and it is not safe to
|
||||
convert `Number` to UINT64.
|
||||
|
||||
`integrity` is an object consisting of a few keys:
|
||||
* A hashing `algorithm`, currently only `SHA256` is supported.
|
||||
* A hex encoded `hash` value representing the hash of the entire file.
|
||||
* An array of hex encoded hashes for the `blocks` of the file. i.e. for a blockSize of 4KB this array contains the hash of every block if you split the file into N 4KB blocks.
|
||||
* A integer value `blockSize` representing the size in bytes of each block in the `blocks` hashes above
|
||||
|
||||
[pickle]: https://chromium.googlesource.com/chromium/src/+/master/base/pickle.h
|
||||
[node-pickle]: https://www.npmjs.org/package/chromium-pickle
|
||||
[grunt-asar]: https://github.com/bwin/grunt-asar
|
@ -0,0 +1,84 @@
|
||||
#!/usr/bin/env node
|
||||
|
||||
var packageJSON = require('../package.json')
|
||||
var splitVersion = function (version) { return version.split('.').map(function (part) { return Number(part) }) }
|
||||
var requiredNodeVersion = splitVersion(packageJSON.engines.node.slice(2))
|
||||
var actualNodeVersion = splitVersion(process.versions.node)
|
||||
|
||||
if (actualNodeVersion[0] < requiredNodeVersion[0] || (actualNodeVersion[0] === requiredNodeVersion[0] && actualNodeVersion[1] < requiredNodeVersion[1])) {
|
||||
console.error('CANNOT RUN WITH NODE ' + process.versions.node)
|
||||
console.error('asar requires Node ' + packageJSON.engines.node + '.')
|
||||
process.exit(1)
|
||||
}
|
||||
|
||||
// Not consts so that this file can load in Node < 4.0
|
||||
var asar = require('../lib/asar')
|
||||
var program = require('commander')
|
||||
|
||||
program.version('v' + packageJSON.version)
|
||||
.description('Manipulate asar archive files')
|
||||
|
||||
program.command('pack <dir> <output>')
|
||||
.alias('p')
|
||||
.description('create asar archive')
|
||||
.option('--ordering <file path>', 'path to a text file for ordering contents')
|
||||
.option('--unpack <expression>', 'do not pack files matching glob <expression>')
|
||||
.option('--unpack-dir <expression>', 'do not pack dirs matching glob <expression> or starting with literal <expression>')
|
||||
.option('--exclude-hidden', 'exclude hidden files')
|
||||
.action(function (dir, output, options) {
|
||||
options = {
|
||||
unpack: options.unpack,
|
||||
unpackDir: options.unpackDir,
|
||||
ordering: options.ordering,
|
||||
version: options.sv,
|
||||
arch: options.sa,
|
||||
builddir: options.sb,
|
||||
dot: !options.excludeHidden
|
||||
}
|
||||
asar.createPackageWithOptions(dir, output, options, function (error) {
|
||||
if (error) {
|
||||
console.error(error.stack)
|
||||
process.exit(1)
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
program.command('list <archive>')
|
||||
.alias('l')
|
||||
.description('list files of asar archive')
|
||||
.option('-i, --is-pack', 'each file in the asar is pack or unpack')
|
||||
.action(function (archive, options) {
|
||||
options = {
|
||||
isPack: options.isPack
|
||||
}
|
||||
var files = asar.listPackage(archive, options)
|
||||
for (var i in files) {
|
||||
console.log(files[i])
|
||||
}
|
||||
})
|
||||
|
||||
program.command('extract-file <archive> <filename>')
|
||||
.alias('ef')
|
||||
.description('extract one file from archive')
|
||||
.action(function (archive, filename) {
|
||||
require('fs').writeFileSync(require('path').basename(filename),
|
||||
asar.extractFile(archive, filename))
|
||||
})
|
||||
|
||||
program.command('extract <archive> <dest>')
|
||||
.alias('e')
|
||||
.description('extract archive')
|
||||
.action(function (archive, dest) {
|
||||
asar.extractAll(archive, dest)
|
||||
})
|
||||
|
||||
program.command('*')
|
||||
.action(function (cmd) {
|
||||
console.log('asar: \'%s\' is not an asar command. See \'asar --help\'.', cmd)
|
||||
})
|
||||
|
||||
program.parse(process.argv)
|
||||
|
||||
if (program.args.length === 0) {
|
||||
program.help()
|
||||
}
|
@ -0,0 +1,219 @@
|
||||
'use strict'
|
||||
|
||||
const fs = require('./wrapped-fs')
|
||||
const path = require('path')
|
||||
const minimatch = require('minimatch')
|
||||
|
||||
const Filesystem = require('./filesystem')
|
||||
const disk = require('./disk')
|
||||
const crawlFilesystem = require('./crawlfs')
|
||||
|
||||
/**
|
||||
* Whether a directory should be excluded from packing due to the `--unpack-dir" option.
|
||||
*
|
||||
* @param {string} dirPath - directory path to check
|
||||
* @param {string} pattern - literal prefix [for backward compatibility] or glob pattern
|
||||
* @param {array} unpackDirs - Array of directory paths previously marked as unpacked
|
||||
*/
|
||||
function isUnpackedDir (dirPath, pattern, unpackDirs) {
|
||||
if (dirPath.startsWith(pattern) || minimatch(dirPath, pattern)) {
|
||||
if (!unpackDirs.includes(dirPath)) {
|
||||
unpackDirs.push(dirPath)
|
||||
}
|
||||
return true
|
||||
} else {
|
||||
return unpackDirs.some(unpackDir => dirPath.startsWith(unpackDir))
|
||||
}
|
||||
}
|
||||
|
||||
module.exports.createPackage = async function (src, dest) {
|
||||
return module.exports.createPackageWithOptions(src, dest, {})
|
||||
}
|
||||
|
||||
module.exports.createPackageWithOptions = async function (src, dest, options) {
|
||||
const globOptions = options.globOptions ? options.globOptions : {}
|
||||
globOptions.dot = options.dot === undefined ? true : options.dot
|
||||
|
||||
const pattern = src + (options.pattern ? options.pattern : '/**/*')
|
||||
|
||||
const [filenames, metadata] = await crawlFilesystem(pattern, globOptions)
|
||||
return module.exports.createPackageFromFiles(src, dest, filenames, metadata, options)
|
||||
}
|
||||
|
||||
/**
|
||||
* Create an ASAR archive from a list of filenames.
|
||||
*
|
||||
* @param {string} src: Base path. All files are relative to this.
|
||||
* @param {string} dest: Archive filename (& path).
|
||||
* @param {array} filenames: List of filenames relative to src.
|
||||
* @param {object} metadata: Object with filenames as keys and {type='directory|file|link', stat: fs.stat} as values. (Optional)
|
||||
* @param {object} options: Options passed to `createPackageWithOptions`.
|
||||
*/
|
||||
module.exports.createPackageFromFiles = async function (src, dest, filenames, metadata, options) {
|
||||
if (typeof metadata === 'undefined' || metadata === null) { metadata = {} }
|
||||
if (typeof options === 'undefined' || options === null) { options = {} }
|
||||
|
||||
src = path.normalize(src)
|
||||
dest = path.normalize(dest)
|
||||
filenames = filenames.map(function (filename) { return path.normalize(filename) })
|
||||
|
||||
const filesystem = new Filesystem(src)
|
||||
const files = []
|
||||
const unpackDirs = []
|
||||
|
||||
let filenamesSorted = []
|
||||
if (options.ordering) {
|
||||
const orderingFiles = (await fs.readFile(options.ordering)).toString().split('\n').map(line => {
|
||||
if (line.includes(':')) { line = line.split(':').pop() }
|
||||
line = line.trim()
|
||||
if (line.startsWith('/')) { line = line.slice(1) }
|
||||
return line
|
||||
})
|
||||
|
||||
const ordering = []
|
||||
for (const file of orderingFiles) {
|
||||
const pathComponents = file.split(path.sep)
|
||||
let str = src
|
||||
for (const pathComponent of pathComponents) {
|
||||
str = path.join(str, pathComponent)
|
||||
ordering.push(str)
|
||||
}
|
||||
}
|
||||
|
||||
let missing = 0
|
||||
const total = filenames.length
|
||||
|
||||
for (const file of ordering) {
|
||||
if (!filenamesSorted.includes(file) && filenames.includes(file)) {
|
||||
filenamesSorted.push(file)
|
||||
}
|
||||
}
|
||||
|
||||
for (const file of filenames) {
|
||||
if (!filenamesSorted.includes(file)) {
|
||||
filenamesSorted.push(file)
|
||||
missing += 1
|
||||
}
|
||||
}
|
||||
|
||||
console.log(`Ordering file has ${((total - missing) / total) * 100}% coverage.`)
|
||||
} else {
|
||||
filenamesSorted = filenames
|
||||
}
|
||||
|
||||
const handleFile = async function (filename) {
|
||||
if (!metadata[filename]) {
|
||||
metadata[filename] = await crawlFilesystem.determineFileType(filename)
|
||||
}
|
||||
const file = metadata[filename]
|
||||
|
||||
let shouldUnpack
|
||||
switch (file.type) {
|
||||
case 'directory':
|
||||
if (options.unpackDir) {
|
||||
shouldUnpack = isUnpackedDir(path.relative(src, filename), options.unpackDir, unpackDirs)
|
||||
} else {
|
||||
shouldUnpack = false
|
||||
}
|
||||
filesystem.insertDirectory(filename, shouldUnpack)
|
||||
break
|
||||
case 'file':
|
||||
shouldUnpack = false
|
||||
if (options.unpack) {
|
||||
shouldUnpack = minimatch(filename, options.unpack, { matchBase: true })
|
||||
}
|
||||
if (!shouldUnpack && options.unpackDir) {
|
||||
const dirName = path.relative(src, path.dirname(filename))
|
||||
shouldUnpack = isUnpackedDir(dirName, options.unpackDir, unpackDirs)
|
||||
}
|
||||
files.push({ filename: filename, unpack: shouldUnpack })
|
||||
return filesystem.insertFile(filename, shouldUnpack, file, options)
|
||||
case 'link':
|
||||
filesystem.insertLink(filename)
|
||||
break
|
||||
}
|
||||
return Promise.resolve()
|
||||
}
|
||||
|
||||
const insertsDone = async function () {
|
||||
await fs.mkdirp(path.dirname(dest))
|
||||
return disk.writeFilesystem(dest, filesystem, files, metadata)
|
||||
}
|
||||
|
||||
const names = filenamesSorted.slice()
|
||||
|
||||
const next = async function (name) {
|
||||
if (!name) { return insertsDone() }
|
||||
|
||||
await handleFile(name)
|
||||
return next(names.shift())
|
||||
}
|
||||
|
||||
return next(names.shift())
|
||||
}
|
||||
|
||||
module.exports.statFile = function (archive, filename, followLinks) {
|
||||
const filesystem = disk.readFilesystemSync(archive)
|
||||
return filesystem.getFile(filename, followLinks)
|
||||
}
|
||||
|
||||
module.exports.getRawHeader = function (archive) {
|
||||
return disk.readArchiveHeaderSync(archive)
|
||||
}
|
||||
|
||||
module.exports.listPackage = function (archive, options) {
|
||||
return disk.readFilesystemSync(archive).listFiles(options)
|
||||
}
|
||||
|
||||
module.exports.extractFile = function (archive, filename) {
|
||||
const filesystem = disk.readFilesystemSync(archive)
|
||||
return disk.readFileSync(filesystem, filename, filesystem.getFile(filename))
|
||||
}
|
||||
|
||||
module.exports.extractAll = function (archive, dest) {
|
||||
const filesystem = disk.readFilesystemSync(archive)
|
||||
const filenames = filesystem.listFiles()
|
||||
|
||||
// under windows just extract links as regular files
|
||||
const followLinks = process.platform === 'win32'
|
||||
|
||||
// create destination directory
|
||||
fs.mkdirpSync(dest)
|
||||
|
||||
for (const fullPath of filenames) {
|
||||
// Remove leading slash
|
||||
const filename = fullPath.substr(1)
|
||||
const destFilename = path.join(dest, filename)
|
||||
const file = filesystem.getFile(filename, followLinks)
|
||||
if (file.files) {
|
||||
// it's a directory, create it and continue with the next entry
|
||||
fs.mkdirpSync(destFilename)
|
||||
} else if (file.link) {
|
||||
// it's a symlink, create a symlink
|
||||
const linkSrcPath = path.dirname(path.join(dest, file.link))
|
||||
const linkDestPath = path.dirname(destFilename)
|
||||
const relativePath = path.relative(linkDestPath, linkSrcPath)
|
||||
// try to delete output file, because we can't overwrite a link
|
||||
try {
|
||||
fs.unlinkSync(destFilename)
|
||||
} catch {}
|
||||
const linkTo = path.join(relativePath, path.basename(file.link))
|
||||
fs.symlinkSync(linkTo, destFilename)
|
||||
} else {
|
||||
// it's a file, extract it
|
||||
const content = disk.readFileSync(filesystem, filename, file)
|
||||
fs.writeFileSync(destFilename, content)
|
||||
if (file.executable) {
|
||||
fs.chmodSync(destFilename, '755')
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
module.exports.uncache = function (archive) {
|
||||
return disk.uncacheFilesystem(archive)
|
||||
}
|
||||
|
||||
module.exports.uncacheAll = function () {
|
||||
disk.uncacheAll()
|
||||
}
|
@ -0,0 +1,41 @@
|
||||
'use strict'
|
||||
|
||||
const { promisify } = require('util')
|
||||
|
||||
const fs = require('./wrapped-fs')
|
||||
const glob = promisify(require('glob'))
|
||||
|
||||
async function determineFileType (filename) {
|
||||
const stat = await fs.lstat(filename)
|
||||
if (stat.isFile()) {
|
||||
return { type: 'file', stat }
|
||||
} else if (stat.isDirectory()) {
|
||||
return { type: 'directory', stat }
|
||||
} else if (stat.isSymbolicLink()) {
|
||||
return { type: 'link', stat }
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = async function (dir, options) {
|
||||
const metadata = {}
|
||||
const crawled = await glob(dir, options)
|
||||
const results = await Promise.all(crawled.map(async filename => [filename, await determineFileType(filename)]))
|
||||
const links = []
|
||||
const filenames = results.map(([filename, type]) => {
|
||||
if (type) {
|
||||
metadata[filename] = type
|
||||
if (type.type === 'link') links.push(filename)
|
||||
}
|
||||
return filename
|
||||
}).filter((filename) => {
|
||||
// Newer glob can return files inside symlinked directories, to avoid
|
||||
// those appearing in archives we need to manually exclude theme here
|
||||
const exactLinkIndex = links.findIndex(link => filename === link)
|
||||
return links.every((link, index) => {
|
||||
if (index === exactLinkIndex) return true
|
||||
return !filename.startsWith(link)
|
||||
})
|
||||
})
|
||||
return [filenames, metadata]
|
||||
}
|
||||
module.exports.determineFileType = determineFileType
|
@ -0,0 +1,123 @@
|
||||
'use strict'
|
||||
|
||||
const fs = require('./wrapped-fs')
|
||||
const path = require('path')
|
||||
const pickle = require('chromium-pickle-js')
|
||||
|
||||
const Filesystem = require('./filesystem')
|
||||
let filesystemCache = {}
|
||||
|
||||
async function copyFile (dest, src, filename) {
|
||||
const srcFile = path.join(src, filename)
|
||||
const targetFile = path.join(dest, filename)
|
||||
|
||||
const [content, stats] = await Promise.all([fs.readFile(srcFile), fs.stat(srcFile), fs.mkdirp(path.dirname(targetFile))])
|
||||
return fs.writeFile(targetFile, content, { mode: stats.mode })
|
||||
}
|
||||
|
||||
async function streamTransformedFile (originalFilename, outStream, transformed) {
|
||||
return new Promise((resolve, reject) => {
|
||||
const stream = fs.createReadStream(transformed ? transformed.path : originalFilename)
|
||||
stream.pipe(outStream, { end: false })
|
||||
stream.on('error', reject)
|
||||
stream.on('end', () => resolve())
|
||||
})
|
||||
}
|
||||
|
||||
const writeFileListToStream = async function (dest, filesystem, out, list, metadata) {
|
||||
for (const file of list) {
|
||||
if (file.unpack) { // the file should not be packed into archive
|
||||
const filename = path.relative(filesystem.src, file.filename)
|
||||
await copyFile(`${dest}.unpacked`, filesystem.src, filename)
|
||||
} else {
|
||||
await streamTransformedFile(file.filename, out, metadata[file.filename].transformed)
|
||||
}
|
||||
}
|
||||
return out.end()
|
||||
}
|
||||
|
||||
module.exports.writeFilesystem = async function (dest, filesystem, files, metadata) {
|
||||
const headerPickle = pickle.createEmpty()
|
||||
headerPickle.writeString(JSON.stringify(filesystem.header))
|
||||
const headerBuf = headerPickle.toBuffer()
|
||||
|
||||
const sizePickle = pickle.createEmpty()
|
||||
sizePickle.writeUInt32(headerBuf.length)
|
||||
const sizeBuf = sizePickle.toBuffer()
|
||||
|
||||
const out = fs.createWriteStream(dest)
|
||||
await new Promise((resolve, reject) => {
|
||||
out.on('error', reject)
|
||||
out.write(sizeBuf)
|
||||
return out.write(headerBuf, () => resolve())
|
||||
})
|
||||
return writeFileListToStream(dest, filesystem, out, files, metadata)
|
||||
}
|
||||
|
||||
module.exports.readArchiveHeaderSync = function (archive) {
|
||||
const fd = fs.openSync(archive, 'r')
|
||||
let size
|
||||
let headerBuf
|
||||
try {
|
||||
const sizeBuf = Buffer.alloc(8)
|
||||
if (fs.readSync(fd, sizeBuf, 0, 8, null) !== 8) {
|
||||
throw new Error('Unable to read header size')
|
||||
}
|
||||
|
||||
const sizePickle = pickle.createFromBuffer(sizeBuf)
|
||||
size = sizePickle.createIterator().readUInt32()
|
||||
headerBuf = Buffer.alloc(size)
|
||||
if (fs.readSync(fd, headerBuf, 0, size, null) !== size) {
|
||||
throw new Error('Unable to read header')
|
||||
}
|
||||
} finally {
|
||||
fs.closeSync(fd)
|
||||
}
|
||||
|
||||
const headerPickle = pickle.createFromBuffer(headerBuf)
|
||||
const header = headerPickle.createIterator().readString()
|
||||
return { headerString: header, header: JSON.parse(header), headerSize: size }
|
||||
}
|
||||
|
||||
module.exports.readFilesystemSync = function (archive) {
|
||||
if (!filesystemCache[archive]) {
|
||||
const header = this.readArchiveHeaderSync(archive)
|
||||
const filesystem = new Filesystem(archive)
|
||||
filesystem.header = header.header
|
||||
filesystem.headerSize = header.headerSize
|
||||
filesystemCache[archive] = filesystem
|
||||
}
|
||||
return filesystemCache[archive]
|
||||
}
|
||||
|
||||
module.exports.uncacheFilesystem = function (archive) {
|
||||
if (filesystemCache[archive]) {
|
||||
filesystemCache[archive] = undefined
|
||||
return true
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
module.exports.uncacheAll = function () {
|
||||
filesystemCache = {}
|
||||
}
|
||||
|
||||
module.exports.readFileSync = function (filesystem, filename, info) {
|
||||
let buffer = Buffer.alloc(info.size)
|
||||
if (info.size <= 0) { return buffer }
|
||||
if (info.unpacked) {
|
||||
// it's an unpacked file, copy it.
|
||||
buffer = fs.readFileSync(path.join(`${filesystem.src}.unpacked`, filename))
|
||||
} else {
|
||||
// Node throws an exception when reading 0 bytes into a 0-size buffer,
|
||||
// so we short-circuit the read in this case.
|
||||
const fd = fs.openSync(filesystem.src, 'r')
|
||||
try {
|
||||
const offset = 8 + filesystem.headerSize + parseInt(info.offset)
|
||||
fs.readSync(fd, buffer, 0, info.size, offset)
|
||||
} finally {
|
||||
fs.closeSync(fd)
|
||||
}
|
||||
}
|
||||
return buffer
|
||||
}
|
@ -0,0 +1,151 @@
|
||||
'use strict'
|
||||
|
||||
const fs = require('./wrapped-fs')
|
||||
const os = require('os')
|
||||
const path = require('path')
|
||||
const { promisify } = require('util')
|
||||
const stream = require('stream')
|
||||
const getFileIntegrity = require('./integrity')
|
||||
|
||||
const UINT32_MAX = 2 ** 32 - 1
|
||||
|
||||
const pipeline = promisify(stream.pipeline)
|
||||
|
||||
class Filesystem {
|
||||
constructor (src) {
|
||||
this.src = path.resolve(src)
|
||||
this.header = { files: {} }
|
||||
this.offset = BigInt(0)
|
||||
}
|
||||
|
||||
searchNodeFromDirectory (p) {
|
||||
let json = this.header
|
||||
const dirs = p.split(path.sep)
|
||||
for (const dir of dirs) {
|
||||
if (dir !== '.') {
|
||||
json = json.files[dir]
|
||||
}
|
||||
}
|
||||
return json
|
||||
}
|
||||
|
||||
searchNodeFromPath (p) {
|
||||
p = path.relative(this.src, p)
|
||||
if (!p) { return this.header }
|
||||
const name = path.basename(p)
|
||||
const node = this.searchNodeFromDirectory(path.dirname(p))
|
||||
if (node.files == null) {
|
||||
node.files = {}
|
||||
}
|
||||
if (node.files[name] == null) {
|
||||
node.files[name] = {}
|
||||
}
|
||||
return node.files[name]
|
||||
}
|
||||
|
||||
insertDirectory (p, shouldUnpack) {
|
||||
const node = this.searchNodeFromPath(p)
|
||||
if (shouldUnpack) {
|
||||
node.unpacked = shouldUnpack
|
||||
}
|
||||
node.files = {}
|
||||
return node.files
|
||||
}
|
||||
|
||||
async insertFile (p, shouldUnpack, file, options) {
|
||||
const dirNode = this.searchNodeFromPath(path.dirname(p))
|
||||
const node = this.searchNodeFromPath(p)
|
||||
if (shouldUnpack || dirNode.unpacked) {
|
||||
node.size = file.stat.size
|
||||
node.unpacked = true
|
||||
node.integrity = await getFileIntegrity(p)
|
||||
return Promise.resolve()
|
||||
}
|
||||
|
||||
let size
|
||||
|
||||
const transformed = options.transform && options.transform(p)
|
||||
if (transformed) {
|
||||
const tmpdir = await fs.mkdtemp(path.join(os.tmpdir(), 'asar-'))
|
||||
const tmpfile = path.join(tmpdir, path.basename(p))
|
||||
const out = fs.createWriteStream(tmpfile)
|
||||
const readStream = fs.createReadStream(p)
|
||||
|
||||
await pipeline(readStream, transformed, out)
|
||||
file.transformed = {
|
||||
path: tmpfile,
|
||||
stat: await fs.lstat(tmpfile)
|
||||
}
|
||||
size = file.transformed.stat.size
|
||||
} else {
|
||||
size = file.stat.size
|
||||
}
|
||||
|
||||
// JavaScript cannot precisely present integers >= UINT32_MAX.
|
||||
if (size > UINT32_MAX) {
|
||||
throw new Error(`${p}: file size can not be larger than 4.2GB`)
|
||||
}
|
||||
|
||||
node.size = size
|
||||
node.offset = this.offset.toString()
|
||||
node.integrity = await getFileIntegrity(p)
|
||||
if (process.platform !== 'win32' && (file.stat.mode & 0o100)) {
|
||||
node.executable = true
|
||||
}
|
||||
this.offset += BigInt(size)
|
||||
}
|
||||
|
||||
insertLink (p) {
|
||||
const link = path.relative(fs.realpathSync(this.src), fs.realpathSync(p))
|
||||
if (link.substr(0, 2) === '..') {
|
||||
throw new Error(`${p}: file "${link}" links out of the package`)
|
||||
}
|
||||
const node = this.searchNodeFromPath(p)
|
||||
node.link = link
|
||||
return link
|
||||
}
|
||||
|
||||
listFiles (options) {
|
||||
const files = []
|
||||
|
||||
const fillFilesFromMetadata = function (basePath, metadata) {
|
||||
if (!metadata.files) {
|
||||
return
|
||||
}
|
||||
|
||||
for (const [childPath, childMetadata] of Object.entries(metadata.files)) {
|
||||
const fullPath = path.join(basePath, childPath)
|
||||
const packState = childMetadata.unpacked ? 'unpack' : 'pack '
|
||||
files.push((options && options.isPack) ? `${packState} : ${fullPath}` : fullPath)
|
||||
fillFilesFromMetadata(fullPath, childMetadata)
|
||||
}
|
||||
}
|
||||
|
||||
fillFilesFromMetadata('/', this.header)
|
||||
return files
|
||||
}
|
||||
|
||||
getNode (p) {
|
||||
const node = this.searchNodeFromDirectory(path.dirname(p))
|
||||
const name = path.basename(p)
|
||||
if (name) {
|
||||
return node.files[name]
|
||||
} else {
|
||||
return node
|
||||
}
|
||||
}
|
||||
|
||||
getFile (p, followLinks) {
|
||||
followLinks = typeof followLinks === 'undefined' ? true : followLinks
|
||||
const info = this.getNode(p)
|
||||
|
||||
// if followLinks is false we don't resolve symlinks
|
||||
if (info.link && followLinks) {
|
||||
return this.getFile(info.link)
|
||||
} else {
|
||||
return info
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = Filesystem
|
@ -0,0 +1,90 @@
|
||||
import { IOptions as GlobOptions } from 'glob';
|
||||
import { Stats } from 'fs';
|
||||
|
||||
export type CreateOptions = {
|
||||
dot?: boolean;
|
||||
globOptions?: GlobOptions;
|
||||
ordering?: string;
|
||||
pattern?: string;
|
||||
transform?: (filePath: string) => NodeJS.ReadWriteStream | void;
|
||||
unpack?: string;
|
||||
unpackDir?: string;
|
||||
};
|
||||
|
||||
export type ListOptions = {
|
||||
isPack: boolean;
|
||||
};
|
||||
|
||||
export type EntryMetadata = {
|
||||
unpacked: boolean;
|
||||
};
|
||||
|
||||
export type DirectoryMetadata = EntryMetadata & {
|
||||
files: { [property: string]: EntryMetadata };
|
||||
};
|
||||
|
||||
export type FileMetadata = EntryMetadata & {
|
||||
executable?: true;
|
||||
offset?: number;
|
||||
size?: number;
|
||||
};
|
||||
|
||||
export type LinkMetadata = {
|
||||
link: string;
|
||||
};
|
||||
|
||||
export type Metadata = DirectoryMetadata | FileMetadata | LinkMetadata;
|
||||
|
||||
export type InputMetadataType = 'directory' | 'file' | 'link';
|
||||
|
||||
export type InputMetadata = {
|
||||
[property: string]: {
|
||||
type: InputMetadataType;
|
||||
stat: Stats;
|
||||
}
|
||||
};
|
||||
|
||||
export type DirectoryRecord = {
|
||||
files: Record<string, DirectoryRecord | FileRecord>;
|
||||
};
|
||||
|
||||
export type FileRecord = {
|
||||
offset: string;
|
||||
size: number;
|
||||
executable?: boolean;
|
||||
integrity: {
|
||||
hash: string;
|
||||
algorithm: 'SHA256';
|
||||
blocks: string[];
|
||||
blockSize: number;
|
||||
};
|
||||
}
|
||||
|
||||
export type ArchiveHeader = {
|
||||
// The JSON parsed header string
|
||||
header: DirectoryRecord;
|
||||
headerString: string;
|
||||
headerSize: number;
|
||||
}
|
||||
|
||||
export function createPackage(src: string, dest: string): Promise<void>;
|
||||
export function createPackageWithOptions(
|
||||
src: string,
|
||||
dest: string,
|
||||
options: CreateOptions
|
||||
): Promise<void>;
|
||||
export function createPackageFromFiles(
|
||||
src: string,
|
||||
dest: string,
|
||||
filenames: string[],
|
||||
metadata?: InputMetadata,
|
||||
options?: CreateOptions
|
||||
): Promise<void>;
|
||||
|
||||
export function statFile(archive: string, filename: string, followLinks?: boolean): Metadata;
|
||||
export function getRawHeader(archive: string): ArchiveHeader;
|
||||
export function listPackage(archive: string, options?: ListOptions): string[];
|
||||
export function extractFile(archive: string, filename: string): Buffer;
|
||||
export function extractAll(archive: string, dest: string): void;
|
||||
export function uncache(archive: string): boolean;
|
||||
export function uncacheAll(): void;
|
@ -0,0 +1,62 @@
|
||||
const crypto = require('crypto')
|
||||
const fs = require('fs')
|
||||
const stream = require('stream')
|
||||
const { promisify } = require('util')
|
||||
|
||||
const ALGORITHM = 'SHA256'
|
||||
// 4MB default block size
|
||||
const BLOCK_SIZE = 4 * 1024 * 1024
|
||||
|
||||
const pipeline = promisify(stream.pipeline)
|
||||
|
||||
function hashBlock (block) {
|
||||
return crypto.createHash(ALGORITHM).update(block).digest('hex')
|
||||
}
|
||||
|
||||
async function getFileIntegrity (path) {
|
||||
const fileHash = crypto.createHash(ALGORITHM)
|
||||
|
||||
const blocks = []
|
||||
let currentBlockSize = 0
|
||||
let currentBlock = []
|
||||
|
||||
await pipeline(
|
||||
fs.createReadStream(path),
|
||||
new stream.PassThrough({
|
||||
decodeStrings: false,
|
||||
transform (_chunk, encoding, callback) {
|
||||
fileHash.update(_chunk)
|
||||
|
||||
function handleChunk (chunk) {
|
||||
const diffToSlice = Math.min(BLOCK_SIZE - currentBlockSize, chunk.byteLength)
|
||||
currentBlockSize += diffToSlice
|
||||
currentBlock.push(chunk.slice(0, diffToSlice))
|
||||
if (currentBlockSize === BLOCK_SIZE) {
|
||||
blocks.push(hashBlock(Buffer.concat(currentBlock)))
|
||||
currentBlock = []
|
||||
currentBlockSize = 0
|
||||
}
|
||||
if (diffToSlice < chunk.byteLength) {
|
||||
handleChunk(chunk.slice(diffToSlice))
|
||||
}
|
||||
}
|
||||
handleChunk(_chunk)
|
||||
callback()
|
||||
},
|
||||
flush (callback) {
|
||||
blocks.push(hashBlock(Buffer.concat(currentBlock)))
|
||||
currentBlock = []
|
||||
callback()
|
||||
}
|
||||
})
|
||||
)
|
||||
|
||||
return {
|
||||
algorithm: ALGORITHM,
|
||||
hash: fileHash.digest('hex'),
|
||||
blockSize: BLOCK_SIZE,
|
||||
blocks: blocks
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = getFileIntegrity
|
@ -0,0 +1,26 @@
|
||||
'use strict'
|
||||
|
||||
const fs = process.versions.electron ? require('original-fs') : require('fs')
|
||||
|
||||
const promisifiedMethods = [
|
||||
'lstat',
|
||||
'mkdtemp',
|
||||
'readFile',
|
||||
'stat',
|
||||
'writeFile'
|
||||
]
|
||||
|
||||
const promisified = {}
|
||||
|
||||
for (const method of Object.keys(fs)) {
|
||||
if (promisifiedMethods.includes(method)) {
|
||||
promisified[method] = fs.promises[method]
|
||||
} else {
|
||||
promisified[method] = fs[method]
|
||||
}
|
||||
}
|
||||
// To make it more like fs-extra
|
||||
promisified.mkdirp = (dir) => fs.promises.mkdir(dir, { recursive: true })
|
||||
promisified.mkdirpSync = (dir) => fs.mkdirSync(dir, { recursive: true })
|
||||
|
||||
module.exports = promisified
|
@ -0,0 +1,17 @@
|
||||
#!/bin/sh
|
||||
basedir=$(dirname "$(echo "$0" | sed -e 's,\\,/,g')")
|
||||
|
||||
case `uname` in
|
||||
*CYGWIN*) basedir=`cygpath -w "$basedir"`;;
|
||||
esac
|
||||
|
||||
if [ -z "$NODE_PATH" ]; then
|
||||
export NODE_PATH="/home/ruthenic/Coding/Javascript/demoncord/demoncord-kernel-package/node_modules/.pnpm/node_modules"
|
||||
else
|
||||
export NODE_PATH="$NODE_PATH:/home/ruthenic/Coding/Javascript/demoncord/demoncord-kernel-package/node_modules/.pnpm/node_modules"
|
||||
fi
|
||||
if [ -x "$basedir/node" ]; then
|
||||
exec "$basedir/node" "$basedir/../../bin/asar.js" "$@"
|
||||
else
|
||||
exec node "$basedir/../../bin/asar.js" "$@"
|
||||
fi
|
@ -0,0 +1,67 @@
|
||||
{
|
||||
"name": "asar",
|
||||
"description": "Creating Electron app packages",
|
||||
"version": "3.2.0",
|
||||
"main": "./lib/asar.js",
|
||||
"types": "./lib/index.d.ts",
|
||||
"bin": {
|
||||
"asar": "./bin/asar.js"
|
||||
},
|
||||
"files": [
|
||||
"bin",
|
||||
"lib",
|
||||
"lib/index.d.ts"
|
||||
],
|
||||
"engines": {
|
||||
"node": ">=10.12.0"
|
||||
},
|
||||
"license": "MIT",
|
||||
"homepage": "https://github.com/electron/asar",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://github.com/electron/asar.git"
|
||||
},
|
||||
"bugs": {
|
||||
"url": "https://github.com/electron/asar/issues"
|
||||
},
|
||||
"scripts": {
|
||||
"mocha": "xvfb-maybe electron-mocha --reporter spec && mocha --reporter spec",
|
||||
"test": "npm run lint && npm run mocha",
|
||||
"lint": "tsd && standard",
|
||||
"standard": "standard",
|
||||
"tsd": "tsd"
|
||||
},
|
||||
"standard": {
|
||||
"env": {
|
||||
"mocha": true
|
||||
},
|
||||
"globals": [
|
||||
"BigInt"
|
||||
]
|
||||
},
|
||||
"tsd": {
|
||||
"directory": "test"
|
||||
},
|
||||
"dependencies": {
|
||||
"chromium-pickle-js": "^0.2.0",
|
||||
"commander": "^5.0.0",
|
||||
"glob": "^7.1.6",
|
||||
"minimatch": "^3.0.4"
|
||||
},
|
||||
"optionalDependencies": {
|
||||
"@types/glob": "^7.1.1"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@continuous-auth/semantic-release-npm": "^2.0.0",
|
||||
"@semantic-release/changelog": "^5.0.0",
|
||||
"electron": "^5.0.0",
|
||||
"electron-mocha": "^8.2.1",
|
||||
"lodash": "^4.17.15",
|
||||
"mocha": "^7.1.1",
|
||||
"rimraf": "^3.0.2",
|
||||
"semantic-release": "^17.0.4",
|
||||
"standard": "^14.3.3",
|
||||
"tsd": "^0.11.0",
|
||||
"xvfb-maybe": "^0.2.1"
|
||||
}
|
||||
}
|
@ -0,0 +1 @@
|
||||
../../chromium-pickle-js@0.2.0/node_modules/chromium-pickle-js
|
@ -0,0 +1 @@
|
||||
../../commander@5.1.0/node_modules/commander
|
@ -0,0 +1 @@
|
||||
../../glob@7.2.3/node_modules/glob
|
@ -0,0 +1 @@
|
||||
../../minimatch@3.1.2/node_modules/minimatch
|
@ -0,0 +1,2 @@
|
||||
tidelift: "npm/balanced-match"
|
||||
patreon: juliangruber
|
21
node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/LICENSE.md
generated
vendored
21
node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/LICENSE.md
generated
vendored
@ -0,0 +1,21 @@
|
||||
(MIT)
|
||||
|
||||
Copyright (c) 2013 Julian Gruber <julian@juliangruber.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.
|
@ -0,0 +1,97 @@
|
||||
# balanced-match
|
||||
|
||||
Match balanced string pairs, like `{` and `}` or `<b>` and `</b>`. Supports regular expressions as well!
|
||||
|
||||
[![build status](https://secure.travis-ci.org/juliangruber/balanced-match.svg)](http://travis-ci.org/juliangruber/balanced-match)
|
||||
[![downloads](https://img.shields.io/npm/dm/balanced-match.svg)](https://www.npmjs.org/package/balanced-match)
|
||||
|
||||
[![testling badge](https://ci.testling.com/juliangruber/balanced-match.png)](https://ci.testling.com/juliangruber/balanced-match)
|
||||
|
||||
## Example
|
||||
|
||||
Get the first matching pair of braces:
|
||||
|
||||
```js
|
||||
var balanced = require('balanced-match');
|
||||
|
||||
console.log(balanced('{', '}', 'pre{in{nested}}post'));
|
||||
console.log(balanced('{', '}', 'pre{first}between{second}post'));
|
||||
console.log(balanced(/\s+\{\s+/, /\s+\}\s+/, 'pre { in{nest} } post'));
|
||||
```
|
||||
|
||||
The matches are:
|
||||
|
||||
```bash
|
||||
$ node example.js
|
||||
{ start: 3, end: 14, pre: 'pre', body: 'in{nested}', post: 'post' }
|
||||
{ start: 3,
|
||||
end: 9,
|
||||
pre: 'pre',
|
||||
body: 'first',
|
||||
post: 'between{second}post' }
|
||||
{ start: 3, end: 17, pre: 'pre', body: 'in{nest}', post: 'post' }
|
||||
```
|
||||
|
||||
## API
|
||||
|
||||
### var m = balanced(a, b, str)
|
||||
|
||||
For the first non-nested matching pair of `a` and `b` in `str`, return an
|
||||
object with those keys:
|
||||
|
||||
* **start** the index of the first match of `a`
|
||||
* **end** the index of the matching `b`
|
||||
* **pre** the preamble, `a` and `b` not included
|
||||
* **body** the match, `a` and `b` not included
|
||||
* **post** the postscript, `a` and `b` not included
|
||||
|
||||
If there's no match, `undefined` will be returned.
|
||||
|
||||
If the `str` contains more `a` than `b` / there are unmatched pairs, the first match that was closed will be used. For example, `{{a}` will match `['{', 'a', '']` and `{a}}` will match `['', 'a', '}']`.
|
||||
|
||||
### var r = balanced.range(a, b, str)
|
||||
|
||||
For the first non-nested matching pair of `a` and `b` in `str`, return an
|
||||
array with indexes: `[ <a index>, <b index> ]`.
|
||||
|
||||
If there's no match, `undefined` will be returned.
|
||||
|
||||
If the `str` contains more `a` than `b` / there are unmatched pairs, the first match that was closed will be used. For example, `{{a}` will match `[ 1, 3 ]` and `{a}}` will match `[0, 2]`.
|
||||
|
||||
## Installation
|
||||
|
||||
With [npm](https://npmjs.org) do:
|
||||
|
||||
```bash
|
||||
npm install balanced-match
|
||||
```
|
||||
|
||||
## Security contact information
|
||||
|
||||
To report a security vulnerability, please use the
|
||||
[Tidelift security contact](https://tidelift.com/security).
|
||||
Tidelift will coordinate the fix and disclosure.
|
||||
|
||||
## License
|
||||
|
||||
(MIT)
|
||||
|
||||
Copyright (c) 2013 Julian Gruber <julian@juliangruber.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.
|
@ -0,0 +1,62 @@
|
||||
'use strict';
|
||||
module.exports = balanced;
|
||||
function balanced(a, b, str) {
|
||||
if (a instanceof RegExp) a = maybeMatch(a, str);
|
||||
if (b instanceof RegExp) b = maybeMatch(b, str);
|
||||
|
||||
var r = range(a, b, str);
|
||||
|
||||
return r && {
|
||||
start: r[0],
|
||||
end: r[1],
|
||||
pre: str.slice(0, r[0]),
|
||||
body: str.slice(r[0] + a.length, r[1]),
|
||||
post: str.slice(r[1] + b.length)
|
||||
};
|
||||
}
|
||||
|
||||
function maybeMatch(reg, str) {
|
||||
var m = str.match(reg);
|
||||
return m ? m[0] : null;
|
||||
}
|
||||
|
||||
balanced.range = range;
|
||||
function range(a, b, str) {
|
||||
var begs, beg, left, right, result;
|
||||
var ai = str.indexOf(a);
|
||||
var bi = str.indexOf(b, ai + 1);
|
||||
var i = ai;
|
||||
|
||||
if (ai >= 0 && bi > 0) {
|
||||
if(a===b) {
|
||||
return [ai, bi];
|
||||
}
|
||||
begs = [];
|
||||
left = str.length;
|
||||
|
||||
while (i >= 0 && !result) {
|
||||
if (i == ai) {
|
||||
begs.push(i);
|
||||
ai = str.indexOf(a, i + 1);
|
||||
} else if (begs.length == 1) {
|
||||
result = [ begs.pop(), bi ];
|
||||
} else {
|
||||
beg = begs.pop();
|
||||
if (beg < left) {
|
||||
left = beg;
|
||||
right = bi;
|
||||
}
|
||||
|
||||
bi = str.indexOf(b, i + 1);
|
||||
}
|
||||
|
||||
i = ai < bi && ai >= 0 ? ai : bi;
|
||||
}
|
||||
|
||||
if (begs.length) {
|
||||
result = [ left, right ];
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
48
node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/package.json
generated
vendored
48
node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/package.json
generated
vendored
@ -0,0 +1,48 @@
|
||||
{
|
||||
"name": "balanced-match",
|
||||
"description": "Match balanced character pairs, like \"{\" and \"}\"",
|
||||
"version": "1.0.2",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git://github.com/juliangruber/balanced-match.git"
|
||||
},
|
||||
"homepage": "https://github.com/juliangruber/balanced-match",
|
||||
"main": "index.js",
|
||||
"scripts": {
|
||||
"test": "tape test/test.js",
|
||||
"bench": "matcha test/bench.js"
|
||||
},
|
||||
"devDependencies": {
|
||||
"matcha": "^0.7.0",
|
||||
"tape": "^4.6.0"
|
||||
},
|
||||
"keywords": [
|
||||
"match",
|
||||
"regexp",
|
||||
"test",
|
||||
"balanced",
|
||||
"parse"
|
||||
],
|
||||
"author": {
|
||||
"name": "Julian Gruber",
|
||||
"email": "mail@juliangruber.com",
|
||||
"url": "http://juliangruber.com"
|
||||
},
|
||||
"license": "MIT",
|
||||
"testling": {
|
||||
"files": "test/*.js",
|
||||
"browsers": [
|
||||
"ie/8..latest",
|
||||
"firefox/20..latest",
|
||||
"firefox/nightly",
|
||||
"chrome/25..latest",
|
||||
"chrome/canary",
|
||||
"opera/12..latest",
|
||||
"opera/next",
|
||||
"safari/5.1..latest",
|
||||
"ipad/6.0..latest",
|
||||
"iphone/6.0..latest",
|
||||
"android-browser/4.2..latest"
|
||||
]
|
||||
}
|
||||
}
|
@ -0,0 +1 @@
|
||||
../../balanced-match@1.0.2/node_modules/balanced-match
|
21
node_modules/.pnpm/brace-expansion@1.1.11/node_modules/brace-expansion/LICENSE
generated
vendored
21
node_modules/.pnpm/brace-expansion@1.1.11/node_modules/brace-expansion/LICENSE
generated
vendored
@ -0,0 +1,21 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2013 Julian Gruber <julian@juliangruber.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.
|
129
node_modules/.pnpm/brace-expansion@1.1.11/node_modules/brace-expansion/README.md
generated
vendored
129
node_modules/.pnpm/brace-expansion@1.1.11/node_modules/brace-expansion/README.md
generated
vendored
@ -0,0 +1,129 @@
|
||||
# brace-expansion
|
||||
|
||||
[Brace expansion](https://www.gnu.org/software/bash/manual/html_node/Brace-Expansion.html),
|
||||
as known from sh/bash, in JavaScript.
|
||||
|
||||
[![build status](https://secure.travis-ci.org/juliangruber/brace-expansion.svg)](http://travis-ci.org/juliangruber/brace-expansion)
|
||||
[![downloads](https://img.shields.io/npm/dm/brace-expansion.svg)](https://www.npmjs.org/package/brace-expansion)
|
||||
[![Greenkeeper badge](https://badges.greenkeeper.io/juliangruber/brace-expansion.svg)](https://greenkeeper.io/)
|
||||
|
||||
[![testling badge](https://ci.testling.com/juliangruber/brace-expansion.png)](https://ci.testling.com/juliangruber/brace-expansion)
|
||||
|
||||
## Example
|
||||
|
||||
```js
|
||||
var expand = require('brace-expansion');
|
||||
|
||||
expand('file-{a,b,c}.jpg')
|
||||
// => ['file-a.jpg', 'file-b.jpg', 'file-c.jpg']
|
||||
|
||||
expand('-v{,,}')
|
||||
// => ['-v', '-v', '-v']
|
||||
|
||||
expand('file{0..2}.jpg')
|
||||
// => ['file0.jpg', 'file1.jpg', 'file2.jpg']
|
||||
|
||||
expand('file-{a..c}.jpg')
|
||||
// => ['file-a.jpg', 'file-b.jpg', 'file-c.jpg']
|
||||
|
||||
expand('file{2..0}.jpg')
|
||||
// => ['file2.jpg', 'file1.jpg', 'file0.jpg']
|
||||
|
||||
expand('file{0..4..2}.jpg')
|
||||
// => ['file0.jpg', 'file2.jpg', 'file4.jpg']
|
||||
|
||||
expand('file-{a..e..2}.jpg')
|
||||
// => ['file-a.jpg', 'file-c.jpg', 'file-e.jpg']
|
||||
|
||||
expand('file{00..10..5}.jpg')
|
||||
// => ['file00.jpg', 'file05.jpg', 'file10.jpg']
|
||||
|
||||
expand('{{A..C},{a..c}}')
|
||||
// => ['A', 'B', 'C', 'a', 'b', 'c']
|
||||
|
||||
expand('ppp{,config,oe{,conf}}')
|
||||
// => ['ppp', 'pppconfig', 'pppoe', 'pppoeconf']
|
||||
```
|
||||
|
||||
## API
|
||||
|
||||
```js
|
||||
var expand = require('brace-expansion');
|
||||
```
|
||||
|
||||
### var expanded = expand(str)
|
||||
|
||||
Return an array of all possible and valid expansions of `str`. If none are
|
||||
found, `[str]` is returned.
|
||||
|
||||
Valid expansions are:
|
||||
|
||||
```js
|
||||
/^(.*,)+(.+)?$/
|
||||
// {a,b,...}
|
||||
```
|
||||
|
||||
A comma separated list of options, like `{a,b}` or `{a,{b,c}}` or `{,a,}`.
|
||||
|
||||
```js
|
||||
/^-?\d+\.\.-?\d+(\.\.-?\d+)?$/
|
||||
// {x..y[..incr]}
|
||||
```
|
||||
|
||||
A numeric sequence from `x` to `y` inclusive, with optional increment.
|
||||
If `x` or `y` start with a leading `0`, all the numbers will be padded
|
||||
to have equal length. Negative numbers and backwards iteration work too.
|
||||
|
||||
```js
|
||||
/^-?\d+\.\.-?\d+(\.\.-?\d+)?$/
|
||||
// {x..y[..incr]}
|
||||
```
|
||||
|
||||
An alphabetic sequence from `x` to `y` inclusive, with optional increment.
|
||||
`x` and `y` must be exactly one character, and if given, `incr` must be a
|
||||
number.
|
||||
|
||||
For compatibility reasons, the string `${` is not eligible for brace expansion.
|
||||
|
||||
## Installation
|
||||
|
||||
With [npm](https://npmjs.org) do:
|
||||
|
||||
```bash
|
||||
npm install brace-expansion
|
||||
```
|
||||
|
||||
## Contributors
|
||||
|
||||
- [Julian Gruber](https://github.com/juliangruber)
|
||||
- [Isaac Z. Schlueter](https://github.com/isaacs)
|
||||
|
||||
## Sponsors
|
||||
|
||||
This module is proudly supported by my [Sponsors](https://github.com/juliangruber/sponsors)!
|
||||
|
||||
Do you want to support modules like this to improve their quality, stability and weigh in on new features? Then please consider donating to my [Patreon](https://www.patreon.com/juliangruber). Not sure how much of my modules you're using? Try [feross/thanks](https://github.com/feross/thanks)!
|
||||
|
||||
## License
|
||||
|
||||
(MIT)
|
||||
|
||||
Copyright (c) 2013 Julian Gruber <julian@juliangruber.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.
|
201
node_modules/.pnpm/brace-expansion@1.1.11/node_modules/brace-expansion/index.js
generated
vendored
201
node_modules/.pnpm/brace-expansion@1.1.11/node_modules/brace-expansion/index.js
generated
vendored
@ -0,0 +1,201 @@
|
||||
var concatMap = require('concat-map');
|
||||
var balanced = require('balanced-match');
|
||||
|
||||
module.exports = expandTop;
|
||||
|
||||
var escSlash = '\0SLASH'+Math.random()+'\0';
|
||||
var escOpen = '\0OPEN'+Math.random()+'\0';
|
||||
var escClose = '\0CLOSE'+Math.random()+'\0';
|
||||
var escComma = '\0COMMA'+Math.random()+'\0';
|
||||
var escPeriod = '\0PERIOD'+Math.random()+'\0';
|
||||
|
||||
function numeric(str) {
|
||||
return parseInt(str, 10) == str
|
||||
? parseInt(str, 10)
|
||||
: str.charCodeAt(0);
|
||||
}
|
||||
|
||||
function escapeBraces(str) {
|
||||
return str.split('\\\\').join(escSlash)
|
||||
.split('\\{').join(escOpen)
|
||||
.split('\\}').join(escClose)
|
||||
.split('\\,').join(escComma)
|
||||
.split('\\.').join(escPeriod);
|
||||
}
|
||||
|
||||
function unescapeBraces(str) {
|
||||
return str.split(escSlash).join('\\')
|
||||
.split(escOpen).join('{')
|
||||
.split(escClose).join('}')
|
||||
.split(escComma).join(',')
|
||||
.split(escPeriod).join('.');
|
||||
}
|
||||
|
||||
|
||||
// Basically just str.split(","), but handling cases
|
||||
// where we have nested braced sections, which should be
|
||||
// treated as individual members, like {a,{b,c},d}
|
||||
function parseCommaParts(str) {
|
||||
if (!str)
|
||||
return [''];
|
||||
|
||||
var parts = [];
|
||||
var m = balanced('{', '}', str);
|
||||
|
||||
if (!m)
|
||||
return str.split(',');
|
||||
|
||||
var pre = m.pre;
|
||||
var body = m.body;
|
||||
var post = m.post;
|
||||
var p = pre.split(',');
|
||||
|
||||
p[p.length-1] += '{' + body + '}';
|
||||
var postParts = parseCommaParts(post);
|
||||
if (post.length) {
|
||||
p[p.length-1] += postParts.shift();
|
||||
p.push.apply(p, postParts);
|
||||
}
|
||||
|
||||
parts.push.apply(parts, p);
|
||||
|
||||
return parts;
|
||||
}
|
||||
|
||||
function expandTop(str) {
|
||||
if (!str)
|
||||
return [];
|
||||
|
||||
// I don't know why Bash 4.3 does this, but it does.
|
||||
// Anything starting with {} will have the first two bytes preserved
|
||||
// but *only* at the top level, so {},a}b will not expand to anything,
|
||||
// but a{},b}c will be expanded to [a}c,abc].
|
||||
// One could argue that this is a bug in Bash, but since the goal of
|
||||
// this module is to match Bash's rules, we escape a leading {}
|
||||
if (str.substr(0, 2) === '{}') {
|
||||
str = '\\{\\}' + str.substr(2);
|
||||
}
|
||||
|
||||
return expand(escapeBraces(str), true).map(unescapeBraces);
|
||||
}
|
||||
|
||||
function identity(e) {
|
||||
return e;
|
||||
}
|
||||
|
||||
function embrace(str) {
|
||||
return '{' + str + '}';
|
||||
}
|
||||
function isPadded(el) {
|
||||
return /^-?0\d/.test(el);
|
||||
}
|
||||
|
||||
function lte(i, y) {
|
||||
return i <= y;
|
||||
}
|
||||
function gte(i, y) {
|
||||
return i >= y;
|
||||
}
|
||||
|
||||
function expand(str, isTop) {
|
||||
var expansions = [];
|
||||
|
||||
var m = balanced('{', '}', str);
|
||||
if (!m || /\$$/.test(m.pre)) return [str];
|
||||
|
||||
var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
|
||||
var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
|
||||
var isSequence = isNumericSequence || isAlphaSequence;
|
||||
var isOptions = m.body.indexOf(',') >= 0;
|
||||
if (!isSequence && !isOptions) {
|
||||
// {a},b}
|
||||
if (m.post.match(/,.*\}/)) {
|
||||
str = m.pre + '{' + m.body + escClose + m.post;
|
||||
return expand(str);
|
||||
}
|
||||
return [str];
|
||||
}
|
||||
|
||||
var n;
|
||||
if (isSequence) {
|
||||
n = m.body.split(/\.\./);
|
||||
} else {
|
||||
n = parseCommaParts(m.body);
|
||||
if (n.length === 1) {
|
||||
// x{{a,b}}y ==> x{a}y x{b}y
|
||||
n = expand(n[0], false).map(embrace);
|
||||
if (n.length === 1) {
|
||||
var post = m.post.length
|
||||
? expand(m.post, false)
|
||||
: [''];
|
||||
return post.map(function(p) {
|
||||
return m.pre + n[0] + p;
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// at this point, n is the parts, and we know it's not a comma set
|
||||
// with a single entry.
|
||||
|
||||
// no need to expand pre, since it is guaranteed to be free of brace-sets
|
||||
var pre = m.pre;
|
||||
var post = m.post.length
|
||||
? expand(m.post, false)
|
||||
: [''];
|
||||
|
||||
var N;
|
||||
|
||||
if (isSequence) {
|
||||
var x = numeric(n[0]);
|
||||
var y = numeric(n[1]);
|
||||
var width = Math.max(n[0].length, n[1].length)
|
||||
var incr = n.length == 3
|
||||
? Math.abs(numeric(n[2]))
|
||||
: 1;
|
||||
var test = lte;
|
||||
var reverse = y < x;
|
||||
if (reverse) {
|
||||
incr *= -1;
|
||||
test = gte;
|
||||
}
|
||||
var pad = n.some(isPadded);
|
||||
|
||||
N = [];
|
||||
|
||||
for (var i = x; test(i, y); i += incr) {
|
||||
var c;
|
||||
if (isAlphaSequence) {
|
||||
c = String.fromCharCode(i);
|
||||
if (c === '\\')
|
||||
c = '';
|
||||
} else {
|
||||
c = String(i);
|
||||
if (pad) {
|
||||
var need = width - c.length;
|
||||
if (need > 0) {
|
||||
var z = new Array(need + 1).join('0');
|
||||
if (i < 0)
|
||||
c = '-' + z + c.slice(1);
|
||||
else
|
||||
c = z + c;
|
||||
}
|
||||
}
|
||||
}
|
||||
N.push(c);
|
||||
}
|
||||
} else {
|
||||
N = concatMap(n, function(el) { return expand(el, false) });
|
||||
}
|
||||
|
||||
for (var j = 0; j < N.length; j++) {
|
||||
for (var k = 0; k < post.length; k++) {
|
||||
var expansion = pre + N[j] + post[k];
|
||||
if (!isTop || isSequence || expansion)
|
||||
expansions.push(expansion);
|
||||
}
|
||||
}
|
||||
|
||||
return expansions;
|
||||
}
|
||||
|
47
node_modules/.pnpm/brace-expansion@1.1.11/node_modules/brace-expansion/package.json
generated
vendored
47
node_modules/.pnpm/brace-expansion@1.1.11/node_modules/brace-expansion/package.json
generated
vendored
@ -0,0 +1,47 @@
|
||||
{
|
||||
"name": "brace-expansion",
|
||||
"description": "Brace expansion as known from sh/bash",
|
||||
"version": "1.1.11",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git://github.com/juliangruber/brace-expansion.git"
|
||||
},
|
||||
"homepage": "https://github.com/juliangruber/brace-expansion",
|
||||
"main": "index.js",
|
||||
"scripts": {
|
||||
"test": "tape test/*.js",
|
||||
"gentest": "bash test/generate.sh",
|
||||
"bench": "matcha test/perf/bench.js"
|
||||
},
|
||||
"dependencies": {
|
||||
"balanced-match": "^1.0.0",
|
||||
"concat-map": "0.0.1"
|
||||
},
|
||||
"devDependencies": {
|
||||
"matcha": "^0.7.0",
|
||||
"tape": "^4.6.0"
|
||||
},
|
||||
"keywords": [],
|
||||
"author": {
|
||||
"name": "Julian Gruber",
|
||||
"email": "mail@juliangruber.com",
|
||||
"url": "http://juliangruber.com"
|
||||
},
|
||||
"license": "MIT",
|
||||
"testling": {
|
||||
"files": "test/*.js",
|
||||
"browsers": [
|
||||
"ie/8..latest",
|
||||
"firefox/20..latest",
|
||||
"firefox/nightly",
|
||||
"chrome/25..latest",
|
||||
"chrome/canary",
|
||||
"opera/12..latest",
|
||||
"opera/next",
|
||||
"safari/5.1..latest",
|
||||
"ipad/6.0..latest",
|
||||
"iphone/6.0..latest",
|
||||
"android-browser/4.2..latest"
|
||||
]
|
||||
}
|
||||
}
|
@ -0,0 +1 @@
|
||||
../../concat-map@0.0.1/node_modules/concat-map
|
132
node_modules/.pnpm/chromium-pickle-js@0.2.0/node_modules/chromium-pickle-js/README.md
generated
vendored
132
node_modules/.pnpm/chromium-pickle-js@0.2.0/node_modules/chromium-pickle-js/README.md
generated
vendored
@ -0,0 +1,132 @@
|
||||
# chromium-pickle-js [![Build Status](https://travis-ci.org/electron/node-chromium-pickle-js.svg?branch=master)](https://travis-ci.org/electron/node-chromium-pickle-js)
|
||||
|
||||
This module ports Chromium's `Pickle` class to Node, see `Pickle`'s header for
|
||||
introduction:
|
||||
|
||||
> This class provides facilities for basic binary value packing and unpacking.
|
||||
>
|
||||
> The Pickle class supports appending primitive values (ints, strings, etc.)
|
||||
> to a pickle instance. The Pickle instance grows its internal memory buffer
|
||||
> dynamically to hold the sequence of primitive values. The internal memory
|
||||
> buffer is exposed as the "data" of the Pickle. This "data" can be passed
|
||||
> to a Pickle object to initialize it for reading.
|
||||
>
|
||||
> When reading from a Pickle object, it is important for the consumer to know
|
||||
> what value types to read and in what order to read them as the Pickle does
|
||||
> not keep track of the type of data written to it.
|
||||
>
|
||||
> The Pickle's data has a header which contains the size of the Pickle's
|
||||
> payload. It can optionally support additional space in the header. That
|
||||
> space is controlled by the header_size parameter passed to the Pickle
|
||||
> constructor.
|
||||
|
||||
## Install
|
||||
|
||||
```bash
|
||||
$ npm install chromium-pickle-js
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
### createEmpty()
|
||||
|
||||
Returns an empty `Pickle` object.
|
||||
|
||||
### createFromBuffer(buffer)
|
||||
|
||||
* `buffer` Buffer
|
||||
|
||||
Returns a `Pickle` object that initialized from a `buffer`. The data is not
|
||||
copied so you have to ensure the `buffer` lives when using the Pickle object,
|
||||
and you should never modify the Pickle object created this way.
|
||||
|
||||
### Pickle.createIterator()
|
||||
|
||||
Returns a `PickleIterator` object that can be used to read data from this
|
||||
`Pickle` object.
|
||||
|
||||
### Pickle.toBuffer()
|
||||
|
||||
Returns a `Buffer` object that contains this `Pickle` object's data.
|
||||
|
||||
### Pickle.writeBool(value)
|
||||
|
||||
Writes `value` to `Pickle` object as `bool`. Returns `true` when succeeded and
|
||||
returns `false` when failed.
|
||||
|
||||
### Pickle.writeInt(value)
|
||||
|
||||
Writes `value` to `Pickle` object as `int`. Returns `true` when succeeded and
|
||||
returns `false` when failed.
|
||||
|
||||
### Pickle.writeUInt32(value)
|
||||
|
||||
Writes `value` to `Pickle` object as `uint32`. Returns `true` when succeeded and
|
||||
returns `false` when failed.
|
||||
|
||||
### Pickle.writeInt64(value)
|
||||
|
||||
Writes `value` to `Pickle` object as `int64`. Returns `true` when succeeded and
|
||||
returns `false` when failed.
|
||||
|
||||
### Pickle.writeUInt64(value)
|
||||
|
||||
Writes `value` to `Pickle` object as `uint64`. Returns `true` when succeeded and
|
||||
returns `false` when failed.
|
||||
|
||||
### Pickle.writeFloat(value)
|
||||
|
||||
Writes `value` to `Pickle` object as `float`. Returns `true` when succeeded and
|
||||
returns `false` when failed.
|
||||
|
||||
### Pickle.writeDouble(value)
|
||||
|
||||
Writes `value` to `Pickle` object as `Double`. Returns `true` when succeeded and
|
||||
returns `false` when failed.
|
||||
|
||||
### Pickle.writeString(str)
|
||||
|
||||
* `str` String
|
||||
|
||||
Writes `str` to `Pickle` object. Returns `true` when succeeded and returns
|
||||
`false` when failed.
|
||||
|
||||
### PickleIterator.readBool()
|
||||
|
||||
Returns current value as `bool` and seeks to next data. A`TypeError` exception
|
||||
would be thrown when failed.
|
||||
|
||||
### PickleIterator.readInt()
|
||||
|
||||
Returns current value as `int` and seeks to next data. A`TypeError` exception
|
||||
would be thrown when failed.
|
||||
|
||||
### PickleIterator.readUInt32()
|
||||
|
||||
Returns current value as `uint32` and seeks to next data. A`TypeError` exception
|
||||
would be thrown when failed.
|
||||
|
||||
### PickleIterator.readInt64()
|
||||
|
||||
Returns current value as `int64` and seeks to next data. A`TypeError` exception
|
||||
would be thrown when failed.
|
||||
|
||||
### PickleIterator.readUInt64()
|
||||
|
||||
Returns current value as `uint64` and seeks to next data. A`TypeError` exception
|
||||
would be thrown when failed.
|
||||
|
||||
### PickleIterator.readFloat()
|
||||
|
||||
Returns current value as `float` and seeks to next data. A`TypeError` exception
|
||||
would be thrown when failed.
|
||||
|
||||
### PickleIterator.readDouble()
|
||||
|
||||
Returns current value as `double` and seeks to next data. A`TypeError` exception
|
||||
would be thrown when failed.
|
||||
|
||||
### PickleIterator.readString()
|
||||
|
||||
Returns current value as `String` and seeks to next data. A`TypeError` exception
|
||||
would be thrown when failed.
|
@ -0,0 +1,11 @@
|
||||
var Pickle = require('./pickle')
|
||||
|
||||
module.exports = {
|
||||
createEmpty: function () {
|
||||
return new Pickle()
|
||||
},
|
||||
|
||||
createFromBuffer: function (buffer) {
|
||||
return new Pickle(buffer)
|
||||
}
|
||||
}
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in new issue