WIP: bootstrap and partial real Solana watcher implementation
This commit is contained in:
@@ -0,0 +1,57 @@
|
||||
import Benchmark from "benchmark";
|
||||
|
||||
const suite = new Benchmark.Suite("ipv4");
|
||||
|
||||
const DATA = "127.0.0.1";
|
||||
const ipv4RegexA =
|
||||
/^(((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))\.){3}((25[0-5])|(2[0-4][0-9])|(1[0-9]{2})|([0-9]{1,2}))$/;
|
||||
const ipv4RegexB =
|
||||
/^(?:(?:(?=(25[0-5]))\1|(?=(2[0-4][0-9]))\2|(?=(1[0-9]{2}))\3|(?=([0-9]{1,2}))\4)\.){3}(?:(?=(25[0-5]))\5|(?=(2[0-4][0-9]))\6|(?=(1[0-9]{2}))\7|(?=([0-9]{1,2}))\8)$/;
|
||||
const ipv4RegexC = /^(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)$/;
|
||||
const ipv4RegexD = /^(\b25[0-5]|\b2[0-4][0-9]|\b[01]?[0-9][0-9]?)(\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}$/;
|
||||
const ipv4RegexE = /^((25[0-5]|(2[0-4]|1\d|[1-9]|)\d)\.){3}(25[0-5]|(2[0-4]|1\d|[1-9]|)\d)$/;
|
||||
const ipv4RegexF = /^((25[0-5]|(2[0-4]|1\d|[1-9]|)\d)\.?\b){4}$/;
|
||||
const ipv4RegexG = /^((25[0-5]|(2[0-4]|1\d|[1-9]|)\d)(\.(?!$)|$)){4}$/;
|
||||
const ipv4RegexH = /^((25[0-5]|(2[0-4]|1[0-9]|[1-9]|)[0-9])(\.(?!$)|$)){4}$/;
|
||||
const ipv4RegexI =
|
||||
/^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
|
||||
|
||||
suite
|
||||
.add("A", () => {
|
||||
return ipv4RegexA.test(DATA);
|
||||
})
|
||||
.add("B", () => {
|
||||
return ipv4RegexB.test(DATA);
|
||||
})
|
||||
.add("C", () => {
|
||||
return ipv4RegexC.test(DATA);
|
||||
})
|
||||
.add("D", () => {
|
||||
return ipv4RegexD.test(DATA);
|
||||
})
|
||||
.add("E", () => {
|
||||
return ipv4RegexE.test(DATA);
|
||||
})
|
||||
.add("F", () => {
|
||||
return ipv4RegexF.test(DATA);
|
||||
})
|
||||
.add("G", () => {
|
||||
return ipv4RegexG.test(DATA);
|
||||
})
|
||||
.add("H", () => {
|
||||
return ipv4RegexH.test(DATA);
|
||||
})
|
||||
.add("I", () => {
|
||||
return ipv4RegexI.test(DATA);
|
||||
})
|
||||
.on("cycle", (e: Benchmark.Event) => {
|
||||
console.log(`${suite.name!}: ${e.target}`);
|
||||
});
|
||||
|
||||
export default {
|
||||
suites: [suite],
|
||||
};
|
||||
|
||||
if (require.main === module) {
|
||||
suite.run();
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
import { S as SnapshotEnvironment, a as SnapshotEnvironmentOptions } from './environment.d-DOJxxZV9.js';
|
||||
import '@vitest/utils';
|
||||
|
||||
declare class NodeSnapshotEnvironment implements SnapshotEnvironment {
|
||||
private options;
|
||||
constructor(options?: SnapshotEnvironmentOptions);
|
||||
getVersion(): string;
|
||||
getHeader(): string;
|
||||
resolveRawPath(testPath: string, rawPath: string): Promise<string>;
|
||||
resolvePath(filepath: string): Promise<string>;
|
||||
prepareDirectory(dirPath: string): Promise<void>;
|
||||
saveSnapshotFile(filepath: string, snapshot: string): Promise<void>;
|
||||
readSnapshotFile(filepath: string): Promise<string | null>;
|
||||
removeSnapshotFile(filepath: string): Promise<void>;
|
||||
}
|
||||
|
||||
export { NodeSnapshotEnvironment, SnapshotEnvironment };
|
||||
@@ -0,0 +1,16 @@
|
||||
/**
|
||||
* NIST secp384r1 aka p384.
|
||||
* @module
|
||||
*/
|
||||
/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
|
||||
import {} from "./abstract/hash-to-curve.js";
|
||||
import { p384_hasher, p384 as p384n } from "./nist.js";
|
||||
/** @deprecated use `import { p384 } from '@noble/curves/nist.js';` */
|
||||
export const p384 = p384n;
|
||||
/** @deprecated use `import { p384 } from '@noble/curves/nist.js';` */
|
||||
export const secp384r1 = p384n;
|
||||
/** @deprecated use `import { p384_hasher } from '@noble/curves/nist.js';` */
|
||||
export const hashToCurve = /* @__PURE__ */ (() => p384_hasher.hashToCurve)();
|
||||
/** @deprecated use `import { p384_hasher } from '@noble/curves/nist.js';` */
|
||||
export const encodeToCurve = /* @__PURE__ */ (() => p384_hasher.encodeToCurve)();
|
||||
//# sourceMappingURL=p384.js.map
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,182 @@
|
||||
# pino-std-serializers [](https://github.com/pinojs/pino-std-serializers/actions?query=workflow%3ACI)
|
||||
|
||||
This module provides a set of standard object serializers for the
|
||||
[Pino](https://getpino.io) logger.
|
||||
|
||||
## Serializers
|
||||
|
||||
### `exports.err(error)`
|
||||
Serializes an `Error` like object. Returns an object:
|
||||
|
||||
```js
|
||||
{
|
||||
type: 'string', // The name of the object's constructor.
|
||||
message: 'string', // The supplied error message.
|
||||
stack: 'string', // The stack when the error was generated.
|
||||
raw: Error // Non-enumerable, i.e. will not be in the output, original
|
||||
// Error object. This is available for subsequent serializers
|
||||
// to use.
|
||||
[...any additional Enumerable property the original Error had]
|
||||
}
|
||||
```
|
||||
|
||||
Any other extra properties, e.g. `statusCode`, that have been attached to the
|
||||
object will also be present on the serialized object.
|
||||
|
||||
If the error object has a [`cause`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error/cause) property, the `cause`'s `message` and `stack` will be appended to the top-level `message` and `stack`. All other parameters that belong to the `error.cause` object will be omitted.
|
||||
|
||||
Example:
|
||||
|
||||
```js
|
||||
const serializer = require('pino-std-serializers').err;
|
||||
|
||||
const innerError = new Error("inner error");
|
||||
innerError.isInner = true;
|
||||
const outerError = new Error("outer error", { cause: innerError });
|
||||
outerError.isInner = false;
|
||||
|
||||
const serialized = serializer(outerError);
|
||||
/* Result:
|
||||
{
|
||||
"type": "Error",
|
||||
"message": "outer error: inner error",
|
||||
"isInner": false,
|
||||
"stack": "Error: outer error
|
||||
at <...omitted..>
|
||||
caused by: Error: inner error
|
||||
at <...omitted..>
|
||||
}
|
||||
*/
|
||||
```
|
||||
|
||||
### `exports.errWithCause(error)`
|
||||
Serializes an `Error` like object, including any `error.cause`. Returns an object:
|
||||
|
||||
```js
|
||||
{
|
||||
type: 'string', // The name of the object's constructor.
|
||||
message: 'string', // The supplied error message.
|
||||
stack: 'string', // The stack when the error was generated.
|
||||
cause?: Error, // If the original error had an error.cause, it will be serialized here
|
||||
raw: Error // Non-enumerable, i.e. will not be in the output, original
|
||||
// Error object. This is available for subsequent serializers
|
||||
// to use.
|
||||
[...any additional Enumerable property the original Error had]
|
||||
}
|
||||
```
|
||||
|
||||
Any other extra properties, e.g. `statusCode`, that have been attached to the object will also be present on the serialized object.
|
||||
|
||||
Example:
|
||||
```javascript
|
||||
const serializer = require('pino-std-serializers').errWithCause;
|
||||
|
||||
const innerError = new Error("inner error");
|
||||
innerError.isInner = true;
|
||||
const outerError = new Error("outer error", { cause: innerError });
|
||||
outerError.isInner = false;
|
||||
|
||||
const serialized = serializer(outerError);
|
||||
/* Result:
|
||||
{
|
||||
"type": "Error",
|
||||
"message": "outer error",
|
||||
"isInner": false,
|
||||
"stack": "Error: outer error
|
||||
at <...omitted..>",
|
||||
"cause": {
|
||||
"type": "Error",
|
||||
"message": "inner error",
|
||||
"isInner": true,
|
||||
"stack": "Error: inner error
|
||||
at <...omitted..>"
|
||||
},
|
||||
}
|
||||
*/
|
||||
```
|
||||
|
||||
### `exports.mapHttpResponse(response)`
|
||||
Used internally by Pino for general response logging. Returns an object:
|
||||
|
||||
```js
|
||||
{
|
||||
res: {}
|
||||
}
|
||||
```
|
||||
|
||||
Where `res` is the `response` as serialized by the standard response serializer.
|
||||
|
||||
### `exports.mapHttpRequest(request)`
|
||||
Used internall by Pino for general request logging. Returns an object:
|
||||
|
||||
```js
|
||||
{
|
||||
req: {}
|
||||
}
|
||||
```
|
||||
|
||||
Where `req` is the `request` as serialized by the standard request serializer.
|
||||
|
||||
### `exports.req(request)`
|
||||
The default `request` serializer. Returns an object:
|
||||
|
||||
```js
|
||||
{
|
||||
id: 'string', // Defaults to `undefined`, unless there is an `id` property
|
||||
// already attached to the `request` object or to the `request.info`
|
||||
// object. Attach a synchronous function
|
||||
// to the `request.id` that returns an identifier to have
|
||||
// the value filled.
|
||||
method: 'string',
|
||||
url: 'string', // the request pathname (as per req.url in core HTTP)
|
||||
query: 'object', // the request query (as per req.query in express or hapi)
|
||||
params: 'object', // the request params (as per req.params in express or hapi)
|
||||
headers: Object, // a reference to the `headers` object from the request
|
||||
// (as per req.headers in core HTTP)
|
||||
remoteAddress: 'string',
|
||||
remotePort: Number,
|
||||
raw: Object // Non-enumerable, i.e. will not be in the output, original
|
||||
// request object. This is available for subsequent serializers
|
||||
// to use. In cases where the `request` input already has
|
||||
// a `raw` property this will replace the original `request.raw`
|
||||
// property
|
||||
}
|
||||
```
|
||||
|
||||
### `exports.res(response)`
|
||||
The default `response` serializer. Returns an object:
|
||||
|
||||
```js
|
||||
{
|
||||
statusCode: Number, // Response status code, will be null before headers are flushed
|
||||
headers: Object, // The headers to be sent in the response.
|
||||
raw: Object // Non-enumerable, i.e. will not be in the output, original
|
||||
// response object. This is available for subsequent serializers
|
||||
// to use.
|
||||
}
|
||||
```
|
||||
|
||||
### `exports.wrapErrorSerializer(customSerializer)`
|
||||
A utility method for wrapping the default error serializer. This allows
|
||||
custom serializers to work with the already serialized object.
|
||||
|
||||
The `customSerializer` accepts one parameter — the newly serialized error
|
||||
object — and returns the new (or updated) error object.
|
||||
|
||||
### `exports.wrapRequestSerializer(customSerializer)`
|
||||
A utility method for wrapping the default request serializer. This allows
|
||||
custom serializers to work with the already serialized object.
|
||||
|
||||
The `customSerializer` accepts one parameter — the newly serialized request
|
||||
object — and returns the new (or updated) request object.
|
||||
|
||||
### `exports.wrapResponseSerializer(customSerializer)`
|
||||
A utility method for wrapping the default response serializer. This allows
|
||||
custom serializers to work with the already serialized object.
|
||||
|
||||
The `customSerializer` accepts one parameter — the newly serialized response
|
||||
object — and returns the new (or updated) response object.
|
||||
|
||||
## License
|
||||
|
||||
MIT License
|
||||
@@ -0,0 +1,390 @@
|
||||
declare module 'repl' {
|
||||
import { Interface, Completer, AsyncCompleter } from 'readline';
|
||||
import { Context } from 'vm';
|
||||
import { InspectOptions } from '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;
|
||||
/**
|
||||
* 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;
|
||||
}
|
||||
|
||||
/**
|
||||
* Provides a customizable Read-Eval-Print-Loop (REPL).
|
||||
*
|
||||
* Instances of `repl.REPLServer` will accept individual lines of user input, evaluate those
|
||||
* according to a user-defined evaluation function, then output the result. Input and output
|
||||
* may be from `stdin` and `stdout`, respectively, or may be connected to any Node.js `stream`.
|
||||
*
|
||||
* Instances of `repl.REPLServer` support automatic completion of inputs, simplistic Emacs-style
|
||||
* line editing, multi-line inputs, ANSI-styled output, saving and restoring current REPL session
|
||||
* state, error recovery, and customizable evaluation functions.
|
||||
*
|
||||
* Instances of `repl.REPLServer` are created using the `repl.start()` method and _should not_
|
||||
* be created directly using the JavaScript `new` keyword.
|
||||
*
|
||||
* @see https://nodejs.org/dist/latest-v10.x/docs/api/repl.html#repl_repl
|
||||
*/
|
||||
class REPLServer extends Interface {
|
||||
/**
|
||||
* The `vm.Context` provided to the `eval` function to be used for JavaScript
|
||||
* evaluation.
|
||||
*/
|
||||
readonly context: Context;
|
||||
/**
|
||||
* Outdated alias for `input`.
|
||||
*/
|
||||
readonly inputStream: NodeJS.ReadableStream;
|
||||
/**
|
||||
* Outdated alias for `output`.
|
||||
*/
|
||||
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: { readonly [name: string]: REPLCommand | undefined };
|
||||
/**
|
||||
* 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();
|
||||
|
||||
/**
|
||||
* Used to add new `.`-prefixed commands to the REPL instance. Such commands are invoked
|
||||
* by typing a `.` followed by the `keyword`.
|
||||
*
|
||||
* @param keyword The command keyword (_without_ a leading `.` character).
|
||||
* @param cmd The function to invoke when the command is processed.
|
||||
*
|
||||
* @see https://nodejs.org/dist/latest-v10.x/docs/api/repl.html#repl_replserver_definecommand_keyword_cmd
|
||||
*/
|
||||
defineCommand(keyword: string, cmd: REPLCommandAction | REPLCommand): void;
|
||||
/**
|
||||
* 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'.
|
||||
*
|
||||
* This method is primarily intended to be called from within the action function for
|
||||
* commands registered using the `replServer.defineCommand()` method.
|
||||
*
|
||||
* @param preserveCursor When `true`, the cursor placement will not be reset to `0`.
|
||||
*/
|
||||
displayPrompt(preserveCursor?: boolean): void;
|
||||
/**
|
||||
* 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.
|
||||
* @param path The path to the history file
|
||||
*/
|
||||
setupHistory(path: string, cb: (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: symbol; // TODO: 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: symbol; // TODO: unique symbol
|
||||
|
||||
/**
|
||||
* Creates and starts a `repl.REPLServer` instance.
|
||||
*
|
||||
* @param options The options for the `REPLServer`. If `options` is a string, then it specifies
|
||||
* the input prompt.
|
||||
*/
|
||||
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);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
/**
|
||||
* Audited & minimal JS implementation of elliptic curve cryptography.
|
||||
* @module
|
||||
* @example
|
||||
```js
|
||||
import { secp256k1, schnorr } from '@noble/curves/secp256k1.js';
|
||||
import { ed25519, ed25519ph, ed25519ctx, x25519, RistrettoPoint } from '@noble/curves/ed25519.js';
|
||||
import { ed448, ed448ph, ed448ctx, x448 } from '@noble/curves/ed448.js';
|
||||
import { p256, p384, p521 } from '@noble/curves/nist.js';
|
||||
import { bls12_381 } from '@noble/curves/bls12-381.js';
|
||||
import { bn254 } from '@noble/curves/bn254.js';
|
||||
import { bytesToHex, hexToBytes, concatBytes, utf8ToBytes } from '@noble/curves/abstract/utils.js';
|
||||
```
|
||||
*/
|
||||
throw new Error('root module cannot be imported: import submodules instead. Check out README');
|
||||
@@ -0,0 +1,9 @@
|
||||
export declare enum JsxEmit {
|
||||
None = 0,
|
||||
Preserve = 1,
|
||||
ReactNative = 2,
|
||||
React = 3,
|
||||
ReactJSX = 4,
|
||||
ReactJSXDev = 5
|
||||
}
|
||||
//# sourceMappingURL=jsxEmit.enum.d.ts.map
|
||||
@@ -0,0 +1,197 @@
|
||||
/**
|
||||
* @fileoverview Rule to enforce requiring named capture groups in regular expression.
|
||||
* @author Pig Fang <https://github.com/g-plane>
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Requirements
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
const {
|
||||
CALL,
|
||||
CONSTRUCT,
|
||||
ReferenceTracker,
|
||||
getStringIfConstant,
|
||||
} = require("@eslint-community/eslint-utils");
|
||||
const regexpp = require("@eslint-community/regexpp");
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Typedefs
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @import { SuggestedEdit } from "@eslint/core"; */
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Helpers
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
const parser = new regexpp.RegExpParser();
|
||||
|
||||
/**
|
||||
* Creates fixer suggestions for the regex, if statically determinable.
|
||||
* @param {number} groupStart Starting index of the regex group.
|
||||
* @param {string} pattern The regular expression pattern to be checked.
|
||||
* @param {string} rawText Source text of the regexNode.
|
||||
* @param {ASTNode} regexNode AST node which contains the regular expression.
|
||||
* @returns {Array<SuggestedEdit>} Fixer suggestions for the regex, if statically determinable.
|
||||
*/
|
||||
function suggestIfPossible(groupStart, pattern, rawText, regexNode) {
|
||||
switch (regexNode.type) {
|
||||
case "Literal":
|
||||
if (typeof regexNode.value === "string" && rawText.includes("\\")) {
|
||||
return null;
|
||||
}
|
||||
break;
|
||||
case "TemplateLiteral":
|
||||
if (
|
||||
regexNode.expressions.length ||
|
||||
rawText.slice(1, -1) !== pattern
|
||||
) {
|
||||
return null;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
return null;
|
||||
}
|
||||
|
||||
const start = regexNode.range[0] + groupStart + 2;
|
||||
|
||||
return [
|
||||
{
|
||||
fix(fixer) {
|
||||
const existingTemps = pattern.match(/temp\d+/gu) || [];
|
||||
const highestTempCount = existingTemps.reduce(
|
||||
(previous, next) =>
|
||||
Math.max(previous, Number(next.slice("temp".length))),
|
||||
0,
|
||||
);
|
||||
|
||||
return fixer.insertTextBeforeRange(
|
||||
[start, start],
|
||||
`?<temp${highestTempCount + 1}>`,
|
||||
);
|
||||
},
|
||||
messageId: "addGroupName",
|
||||
},
|
||||
{
|
||||
fix(fixer) {
|
||||
return fixer.insertTextBeforeRange([start, start], "?:");
|
||||
},
|
||||
messageId: "addNonCapture",
|
||||
},
|
||||
];
|
||||
}
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @type {import('../types').Rule.RuleModule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
type: "suggestion",
|
||||
|
||||
docs: {
|
||||
description:
|
||||
"Enforce using named capture group in regular expression",
|
||||
recommended: false,
|
||||
url: "https://eslint.org/docs/latest/rules/prefer-named-capture-group",
|
||||
},
|
||||
|
||||
hasSuggestions: true,
|
||||
|
||||
schema: [],
|
||||
|
||||
messages: {
|
||||
addGroupName: "Add name to capture group.",
|
||||
addNonCapture: "Convert group to non-capturing.",
|
||||
required:
|
||||
"Capture group '{{group}}' should be converted to a named or non-capturing group.",
|
||||
},
|
||||
},
|
||||
|
||||
create(context) {
|
||||
const sourceCode = context.sourceCode;
|
||||
|
||||
/**
|
||||
* Function to check regular expression.
|
||||
* @param {string} pattern The regular expression pattern to be checked.
|
||||
* @param {ASTNode} node AST node which contains the regular expression or a call/new expression.
|
||||
* @param {ASTNode} regexNode AST node which contains the regular expression.
|
||||
* @param {string|null} flags The regular expression flags to be checked.
|
||||
* @returns {void}
|
||||
*/
|
||||
function checkRegex(pattern, node, regexNode, flags) {
|
||||
let ast;
|
||||
|
||||
try {
|
||||
ast = parser.parsePattern(pattern, 0, pattern.length, {
|
||||
unicode: Boolean(flags && flags.includes("u")),
|
||||
unicodeSets: Boolean(flags && flags.includes("v")),
|
||||
});
|
||||
} catch {
|
||||
// ignore regex syntax errors
|
||||
return;
|
||||
}
|
||||
|
||||
regexpp.visitRegExpAST(ast, {
|
||||
onCapturingGroupEnter(group) {
|
||||
if (!group.name) {
|
||||
const rawText = sourceCode.getText(regexNode);
|
||||
const suggest = suggestIfPossible(
|
||||
group.start,
|
||||
pattern,
|
||||
rawText,
|
||||
regexNode,
|
||||
);
|
||||
|
||||
context.report({
|
||||
node,
|
||||
messageId: "required",
|
||||
data: {
|
||||
group: group.raw,
|
||||
},
|
||||
suggest,
|
||||
});
|
||||
}
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
return {
|
||||
Literal(node) {
|
||||
if (node.regex) {
|
||||
checkRegex(
|
||||
node.regex.pattern,
|
||||
node,
|
||||
node,
|
||||
node.regex.flags,
|
||||
);
|
||||
}
|
||||
},
|
||||
Program(node) {
|
||||
const scope = sourceCode.getScope(node);
|
||||
const tracker = new ReferenceTracker(scope);
|
||||
const traceMap = {
|
||||
RegExp: {
|
||||
[CALL]: true,
|
||||
[CONSTRUCT]: true,
|
||||
},
|
||||
};
|
||||
|
||||
for (const { node: refNode } of tracker.iterateGlobalReferences(
|
||||
traceMap,
|
||||
)) {
|
||||
const regex = getStringIfConstant(refNode.arguments[0]);
|
||||
const flags = getStringIfConstant(refNode.arguments[1]);
|
||||
|
||||
if (regex) {
|
||||
checkRegex(regex, refNode, refNode.arguments[0], flags);
|
||||
}
|
||||
}
|
||||
},
|
||||
};
|
||||
},
|
||||
};
|
||||
@@ -0,0 +1,175 @@
|
||||
/**
|
||||
* @fileoverview Rule to flag assignment in a conditional statement's test expression
|
||||
* @author Stephen Murray <spmurrayzzz>
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Requirements
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
const astUtils = require("./utils/ast-utils");
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Helpers
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
const TEST_CONDITION_PARENT_TYPES = new Set([
|
||||
"IfStatement",
|
||||
"WhileStatement",
|
||||
"DoWhileStatement",
|
||||
"ForStatement",
|
||||
"ConditionalExpression",
|
||||
]);
|
||||
|
||||
const NODE_DESCRIPTIONS = {
|
||||
DoWhileStatement: "a 'do...while' statement",
|
||||
ForStatement: "a 'for' statement",
|
||||
IfStatement: "an 'if' statement",
|
||||
WhileStatement: "a 'while' statement",
|
||||
};
|
||||
|
||||
//------------------------------------------------------------------------------
|
||||
// Rule Definition
|
||||
//------------------------------------------------------------------------------
|
||||
|
||||
/** @type {import('../types').Rule.RuleModule} */
|
||||
module.exports = {
|
||||
meta: {
|
||||
type: "problem",
|
||||
|
||||
defaultOptions: ["except-parens"],
|
||||
|
||||
docs: {
|
||||
description:
|
||||
"Disallow assignment operators in conditional expressions",
|
||||
recommended: true,
|
||||
url: "https://eslint.org/docs/latest/rules/no-cond-assign",
|
||||
},
|
||||
|
||||
schema: [
|
||||
{
|
||||
enum: ["except-parens", "always"],
|
||||
},
|
||||
],
|
||||
|
||||
messages: {
|
||||
unexpected: "Unexpected assignment within {{type}}.",
|
||||
|
||||
// must match JSHint's error message
|
||||
missing:
|
||||
"Expected a conditional expression and instead saw an assignment.",
|
||||
},
|
||||
},
|
||||
|
||||
create(context) {
|
||||
const [prohibitAssign] = context.options;
|
||||
const sourceCode = context.sourceCode;
|
||||
|
||||
/**
|
||||
* Check whether an AST node is the test expression for a conditional statement.
|
||||
* @param {!Object} node The node to test.
|
||||
* @returns {boolean} `true` if the node is the text expression for a conditional statement; otherwise, `false`.
|
||||
*/
|
||||
function isConditionalTestExpression(node) {
|
||||
return (
|
||||
node.parent &&
|
||||
TEST_CONDITION_PARENT_TYPES.has(node.parent.type) &&
|
||||
node === node.parent.test
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Given an AST node, perform a bottom-up search for the first ancestor that represents a conditional statement.
|
||||
* @param {!Object} node The node to use at the start of the search.
|
||||
* @returns {?Object} The closest ancestor node that represents a conditional statement.
|
||||
*/
|
||||
function findConditionalAncestor(node) {
|
||||
let currentAncestor = node;
|
||||
|
||||
do {
|
||||
if (isConditionalTestExpression(currentAncestor)) {
|
||||
return currentAncestor.parent;
|
||||
}
|
||||
} while (
|
||||
(currentAncestor = currentAncestor.parent) &&
|
||||
!astUtils.isFunction(currentAncestor)
|
||||
);
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check whether the code represented by an AST node is enclosed in two sets of parentheses.
|
||||
* @param {!Object} node The node to test.
|
||||
* @returns {boolean} `true` if the code is enclosed in two sets of parentheses; otherwise, `false`.
|
||||
*/
|
||||
function isParenthesisedTwice(node) {
|
||||
const previousToken = sourceCode.getTokenBefore(node, 1),
|
||||
nextToken = sourceCode.getTokenAfter(node, 1);
|
||||
|
||||
return (
|
||||
astUtils.isParenthesised(sourceCode, node) &&
|
||||
previousToken &&
|
||||
astUtils.isOpeningParenToken(previousToken) &&
|
||||
previousToken.range[1] <= node.range[0] &&
|
||||
astUtils.isClosingParenToken(nextToken) &&
|
||||
nextToken.range[0] >= node.range[1]
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check a conditional statement's test expression for top-level assignments that are not enclosed in parentheses.
|
||||
* @param {!Object} node The node for the conditional statement.
|
||||
* @returns {void}
|
||||
*/
|
||||
function testForAssign(node) {
|
||||
if (
|
||||
node.test &&
|
||||
node.test.type === "AssignmentExpression" &&
|
||||
(node.type === "ForStatement"
|
||||
? !astUtils.isParenthesised(sourceCode, node.test)
|
||||
: !isParenthesisedTwice(node.test))
|
||||
) {
|
||||
context.report({
|
||||
node: node.test,
|
||||
messageId: "missing",
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Check whether an assignment expression is descended from a conditional statement's test expression.
|
||||
* @param {!Object} node The node for the assignment expression.
|
||||
* @returns {void}
|
||||
*/
|
||||
function testForConditionalAncestor(node) {
|
||||
const ancestor = findConditionalAncestor(node);
|
||||
|
||||
if (ancestor) {
|
||||
context.report({
|
||||
node,
|
||||
messageId: "unexpected",
|
||||
data: {
|
||||
type: NODE_DESCRIPTIONS[ancestor.type] || ancestor.type,
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
if (prohibitAssign === "always") {
|
||||
return {
|
||||
AssignmentExpression: testForConditionalAncestor,
|
||||
};
|
||||
}
|
||||
|
||||
return {
|
||||
DoWhileStatement: testForAssign,
|
||||
ForStatement: testForAssign,
|
||||
IfStatement: testForAssign,
|
||||
WhileStatement: testForAssign,
|
||||
ConditionalExpression: testForAssign,
|
||||
};
|
||||
},
|
||||
};
|
||||
@@ -0,0 +1,217 @@
|
||||
/**
|
||||
* @fileoverview Flat Config Array
|
||||
* @author Nicholas C. Zakas
|
||||
*/
|
||||
|
||||
"use strict";
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Requirements
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
const { ConfigArray, ConfigArraySymbol } = require("@eslint/config-array");
|
||||
const { flatConfigSchema } = require("./flat-config-schema");
|
||||
const { defaultConfig } = require("./default-config");
|
||||
const { Config } = require("./config");
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Helpers
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Fields that are considered metadata and not part of the config object.
|
||||
*/
|
||||
const META_FIELDS = new Set(["name", "basePath"]);
|
||||
|
||||
/**
|
||||
* Wraps a config error with details about where the error occurred.
|
||||
* @param {Error} error The original error.
|
||||
* @param {number} originalLength The original length of the config array.
|
||||
* @param {number} baseLength The length of the base config.
|
||||
* @returns {TypeError} The new error with details.
|
||||
*/
|
||||
function wrapConfigErrorWithDetails(error, originalLength, baseLength) {
|
||||
let location = "user-defined";
|
||||
let configIndex = error.index;
|
||||
|
||||
/*
|
||||
* A config array is set up in this order:
|
||||
* 1. Base config
|
||||
* 2. Original configs
|
||||
* 3. User-defined configs
|
||||
* 4. CLI-defined configs
|
||||
*
|
||||
* So we need to adjust the index to account for the base config.
|
||||
*
|
||||
* - If the index is less than the base length, it's in the base config
|
||||
* (as specified by `baseConfig` argument to `FlatConfigArray` constructor).
|
||||
* - If the index is greater than the base length but less than the original
|
||||
* length + base length, it's in the original config. The original config
|
||||
* is passed to the `FlatConfigArray` constructor as the first argument.
|
||||
* - Otherwise, it's in the user-defined config, which is loaded from the
|
||||
* config file and merged with any command-line options.
|
||||
*/
|
||||
if (error.index < baseLength) {
|
||||
location = "base";
|
||||
} else if (error.index < originalLength + baseLength) {
|
||||
location = "original";
|
||||
configIndex = error.index - baseLength;
|
||||
} else {
|
||||
configIndex = error.index - originalLength - baseLength;
|
||||
}
|
||||
|
||||
return new TypeError(
|
||||
`${error.message.slice(0, -1)} at ${location} index ${configIndex}.`,
|
||||
{ cause: error },
|
||||
);
|
||||
}
|
||||
|
||||
const originalBaseConfig = Symbol("originalBaseConfig");
|
||||
const originalLength = Symbol("originalLength");
|
||||
const baseLength = Symbol("baseLength");
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
// Exports
|
||||
//-----------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Represents an array containing configuration information for ESLint.
|
||||
*/
|
||||
class FlatConfigArray extends ConfigArray {
|
||||
/**
|
||||
* Creates a new instance.
|
||||
* @param {*[]} configs An array of configuration information.
|
||||
* @param {{basePath: string, shouldIgnore: boolean, baseConfig: FlatConfig}} options The options
|
||||
* to use for the config array instance.
|
||||
*/
|
||||
constructor(
|
||||
configs,
|
||||
{ basePath, shouldIgnore = true, baseConfig = defaultConfig } = {},
|
||||
) {
|
||||
super(configs, {
|
||||
basePath,
|
||||
schema: flatConfigSchema,
|
||||
});
|
||||
|
||||
/**
|
||||
* The original length of the array before any modifications.
|
||||
* @type {number}
|
||||
*/
|
||||
this[originalLength] = this.length;
|
||||
|
||||
if (baseConfig[Symbol.iterator]) {
|
||||
this.unshift(...baseConfig);
|
||||
} else {
|
||||
this.unshift(baseConfig);
|
||||
}
|
||||
|
||||
/**
|
||||
* The length of the array after applying the base config.
|
||||
* @type {number}
|
||||
*/
|
||||
this[baseLength] = this.length - this[originalLength];
|
||||
|
||||
/**
|
||||
* The base config used to build the config array.
|
||||
* @type {Array<FlatConfig>}
|
||||
*/
|
||||
this[originalBaseConfig] = baseConfig;
|
||||
Object.defineProperty(this, originalBaseConfig, { writable: false });
|
||||
|
||||
/**
|
||||
* Determines if `ignores` fields should be honored.
|
||||
* If true, then all `ignores` fields are honored.
|
||||
* if false, then only `ignores` fields in the baseConfig are honored.
|
||||
* @type {boolean}
|
||||
*/
|
||||
this.shouldIgnore = shouldIgnore;
|
||||
Object.defineProperty(this, "shouldIgnore", { writable: false });
|
||||
}
|
||||
|
||||
/**
|
||||
* Normalizes the array by calling the superclass method and catching/rethrowing
|
||||
* any ConfigError exceptions with additional details.
|
||||
* @param {any} [context] The context to use to normalize the array.
|
||||
* @returns {Promise<FlatConfigArray>} A promise that resolves when the array is normalized.
|
||||
*/
|
||||
normalize(context) {
|
||||
return super.normalize(context).catch(error => {
|
||||
if (error.name === "ConfigError") {
|
||||
throw wrapConfigErrorWithDetails(
|
||||
error,
|
||||
this[originalLength],
|
||||
this[baseLength],
|
||||
);
|
||||
}
|
||||
|
||||
throw error;
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Normalizes the array by calling the superclass method and catching/rethrowing
|
||||
* any ConfigError exceptions with additional details.
|
||||
* @param {any} [context] The context to use to normalize the array.
|
||||
* @returns {FlatConfigArray} The current instance.
|
||||
* @throws {TypeError} If the config is invalid.
|
||||
*/
|
||||
normalizeSync(context) {
|
||||
try {
|
||||
return super.normalizeSync(context);
|
||||
} catch (error) {
|
||||
if (error.name === "ConfigError") {
|
||||
throw wrapConfigErrorWithDetails(
|
||||
error,
|
||||
this[originalLength],
|
||||
this[baseLength],
|
||||
);
|
||||
}
|
||||
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
|
||||
/* eslint-disable class-methods-use-this -- Desired as instance method */
|
||||
/**
|
||||
* Replaces a config with another config to allow us to put strings
|
||||
* in the config array that will be replaced by objects before
|
||||
* normalization.
|
||||
* @param {Object} config The config to preprocess.
|
||||
* @returns {Object} The preprocessed config.
|
||||
*/
|
||||
[ConfigArraySymbol.preprocessConfig](config) {
|
||||
/*
|
||||
* If a config object has `ignores` and no other non-meta fields, then it's an object
|
||||
* for global ignores. If `shouldIgnore` is false, that object shouldn't apply,
|
||||
* so we'll remove its `ignores`.
|
||||
*/
|
||||
if (
|
||||
!this.shouldIgnore &&
|
||||
!this[originalBaseConfig].includes(config) &&
|
||||
config.ignores &&
|
||||
Object.keys(config).filter(key => !META_FIELDS.has(key)).length ===
|
||||
1
|
||||
) {
|
||||
/* eslint-disable-next-line no-unused-vars -- need to strip off other keys */
|
||||
const { ignores, ...otherKeys } = config;
|
||||
|
||||
return otherKeys;
|
||||
}
|
||||
|
||||
return config;
|
||||
}
|
||||
|
||||
/**
|
||||
* Finalizes the config by replacing plugin references with their objects
|
||||
* and validating rule option schemas.
|
||||
* @param {Object} config The config to finalize.
|
||||
* @returns {Object} The finalized config.
|
||||
* @throws {TypeError} If the config is invalid.
|
||||
*/
|
||||
[ConfigArraySymbol.finalizeConfig](config) {
|
||||
return new Config(config);
|
||||
}
|
||||
/* eslint-enable class-methods-use-this -- Desired as instance method */
|
||||
}
|
||||
|
||||
exports.FlatConfigArray = FlatConfigArray;
|
||||
@@ -0,0 +1,54 @@
|
||||
{
|
||||
"name": "@types/uuid",
|
||||
"version": "10.0.0",
|
||||
"description": "TypeScript definitions for uuid",
|
||||
"homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/uuid",
|
||||
"license": "MIT",
|
||||
"contributors": [
|
||||
{
|
||||
"name": "Oliver Hoffmann",
|
||||
"githubUsername": "iamolivinius",
|
||||
"url": "https://github.com/iamolivinius"
|
||||
},
|
||||
{
|
||||
"name": "Felipe Ochoa",
|
||||
"githubUsername": "felipeochoa",
|
||||
"url": "https://github.com/felipeochoa"
|
||||
},
|
||||
{
|
||||
"name": "Chris Barth",
|
||||
"githubUsername": "cjbarth",
|
||||
"url": "https://github.com/cjbarth"
|
||||
},
|
||||
{
|
||||
"name": "Linus Unnebäck",
|
||||
"githubUsername": "LinusU",
|
||||
"url": "https://github.com/LinusU"
|
||||
},
|
||||
{
|
||||
"name": "Christoph Tavan",
|
||||
"githubUsername": "ctavan",
|
||||
"url": "https://github.com/ctavan"
|
||||
}
|
||||
],
|
||||
"main": "",
|
||||
"types": "index.d.ts",
|
||||
"exports": {
|
||||
"./package.json": "./package.json",
|
||||
".": {
|
||||
"types": {
|
||||
"import": "./index.d.mts",
|
||||
"default": "./index.d.ts"
|
||||
}
|
||||
}
|
||||
},
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
|
||||
"directory": "types/uuid"
|
||||
},
|
||||
"scripts": {},
|
||||
"dependencies": {},
|
||||
"typesPublisherContentHash": "08fbc5ff7d23aaac1e81b5acf98181d2544ce6ffd5578e9879e2a75f0c087d54",
|
||||
"typeScriptVersion": "4.7"
|
||||
}
|
||||
@@ -0,0 +1,40 @@
|
||||
// This file is autogenerated by build-prefixes.js. DO NOT EDIT!
|
||||
|
||||
export interface Targets {
|
||||
android?: number,
|
||||
chrome?: number,
|
||||
edge?: number,
|
||||
firefox?: number,
|
||||
ie?: number,
|
||||
ios_saf?: number,
|
||||
opera?: number,
|
||||
safari?: number,
|
||||
samsung?: number
|
||||
}
|
||||
|
||||
export const Features: {
|
||||
Nesting: 1,
|
||||
NotSelectorList: 2,
|
||||
DirSelector: 4,
|
||||
LangSelectorList: 8,
|
||||
IsSelector: 16,
|
||||
TextDecorationThicknessPercent: 32,
|
||||
MediaIntervalSyntax: 64,
|
||||
MediaRangeSyntax: 128,
|
||||
CustomMediaQueries: 256,
|
||||
ClampFunction: 512,
|
||||
ColorFunction: 1024,
|
||||
OklabColors: 2048,
|
||||
LabColors: 4096,
|
||||
P3Colors: 8192,
|
||||
HexAlphaColors: 16384,
|
||||
SpaceSeparatedColorNotation: 32768,
|
||||
FontFamilySystemUi: 65536,
|
||||
DoublePositionGradients: 131072,
|
||||
VendorPrefixes: 262144,
|
||||
LogicalProperties: 524288,
|
||||
LightDark: 1048576,
|
||||
Selectors: 31,
|
||||
MediaQueries: 448,
|
||||
Colors: 1113088,
|
||||
};
|
||||
@@ -0,0 +1,118 @@
|
||||
/* eslint-disable jsdoc/valid-types -- doesn't allow `readonly`.
|
||||
TODO: remove eslint-disable when https://github.com/jsdoc-type-pratt-parser/jsdoc-type-pratt-parser/issues/164 is fixed
|
||||
*/
|
||||
/**
|
||||
* @typedef {{ readonly [type: string]: ReadonlyArray<string> }} VisitorKeys
|
||||
*/
|
||||
/* eslint-enable jsdoc/valid-types -- doesn't allow `readonly string[]`. TODO: check why */
|
||||
|
||||
/**
|
||||
* @type {VisitorKeys}
|
||||
*/
|
||||
const KEYS = {
|
||||
ArrayExpression: ["elements"],
|
||||
ArrayPattern: ["elements"],
|
||||
ArrowFunctionExpression: ["params", "body"],
|
||||
AssignmentExpression: ["left", "right"],
|
||||
AssignmentPattern: ["left", "right"],
|
||||
AwaitExpression: ["argument"],
|
||||
BinaryExpression: ["left", "right"],
|
||||
BlockStatement: ["body"],
|
||||
BreakStatement: ["label"],
|
||||
CallExpression: ["callee", "arguments"],
|
||||
CatchClause: ["param", "body"],
|
||||
ChainExpression: ["expression"],
|
||||
ClassBody: ["body"],
|
||||
ClassDeclaration: ["id", "superClass", "body"],
|
||||
ClassExpression: ["id", "superClass", "body"],
|
||||
ConditionalExpression: ["test", "consequent", "alternate"],
|
||||
ContinueStatement: ["label"],
|
||||
DebuggerStatement: [],
|
||||
DoWhileStatement: ["body", "test"],
|
||||
EmptyStatement: [],
|
||||
ExperimentalRestProperty: ["argument"],
|
||||
ExperimentalSpreadProperty: ["argument"],
|
||||
ExportAllDeclaration: ["exported", "source", "attributes"],
|
||||
ExportDefaultDeclaration: ["declaration"],
|
||||
ExportNamedDeclaration: [
|
||||
"declaration",
|
||||
"specifiers",
|
||||
"source",
|
||||
"attributes",
|
||||
],
|
||||
ExportSpecifier: ["local", "exported"],
|
||||
ExpressionStatement: ["expression"],
|
||||
ForInStatement: ["left", "right", "body"],
|
||||
ForOfStatement: ["left", "right", "body"],
|
||||
ForStatement: ["init", "test", "update", "body"],
|
||||
FunctionDeclaration: ["id", "params", "body"],
|
||||
FunctionExpression: ["id", "params", "body"],
|
||||
Identifier: [],
|
||||
IfStatement: ["test", "consequent", "alternate"],
|
||||
ImportAttribute: ["key", "value"],
|
||||
ImportDeclaration: ["specifiers", "source", "attributes"],
|
||||
ImportDefaultSpecifier: ["local"],
|
||||
ImportExpression: ["source", "options"],
|
||||
ImportNamespaceSpecifier: ["local"],
|
||||
ImportSpecifier: ["imported", "local"],
|
||||
JSXAttribute: ["name", "value"],
|
||||
JSXClosingElement: ["name"],
|
||||
JSXClosingFragment: [],
|
||||
JSXElement: ["openingElement", "children", "closingElement"],
|
||||
JSXEmptyExpression: [],
|
||||
JSXExpressionContainer: ["expression"],
|
||||
JSXFragment: ["openingFragment", "children", "closingFragment"],
|
||||
JSXIdentifier: [],
|
||||
JSXMemberExpression: ["object", "property"],
|
||||
JSXNamespacedName: ["namespace", "name"],
|
||||
JSXOpeningElement: ["name", "attributes"],
|
||||
JSXOpeningFragment: [],
|
||||
JSXSpreadAttribute: ["argument"],
|
||||
JSXSpreadChild: ["expression"],
|
||||
JSXText: [],
|
||||
LabeledStatement: ["label", "body"],
|
||||
Literal: [],
|
||||
LogicalExpression: ["left", "right"],
|
||||
MemberExpression: ["object", "property"],
|
||||
MetaProperty: ["meta", "property"],
|
||||
MethodDefinition: ["key", "value"],
|
||||
NewExpression: ["callee", "arguments"],
|
||||
ObjectExpression: ["properties"],
|
||||
ObjectPattern: ["properties"],
|
||||
PrivateIdentifier: [],
|
||||
Program: ["body"],
|
||||
Property: ["key", "value"],
|
||||
PropertyDefinition: ["key", "value"],
|
||||
RestElement: ["argument"],
|
||||
ReturnStatement: ["argument"],
|
||||
SequenceExpression: ["expressions"],
|
||||
SpreadElement: ["argument"],
|
||||
StaticBlock: ["body"],
|
||||
Super: [],
|
||||
SwitchCase: ["test", "consequent"],
|
||||
SwitchStatement: ["discriminant", "cases"],
|
||||
TaggedTemplateExpression: ["tag", "quasi"],
|
||||
TemplateElement: [],
|
||||
TemplateLiteral: ["quasis", "expressions"],
|
||||
ThisExpression: [],
|
||||
ThrowStatement: ["argument"],
|
||||
TryStatement: ["block", "handler", "finalizer"],
|
||||
UnaryExpression: ["argument"],
|
||||
UpdateExpression: ["argument"],
|
||||
VariableDeclaration: ["declarations"],
|
||||
VariableDeclarator: ["id", "init"],
|
||||
WhileStatement: ["test", "body"],
|
||||
WithStatement: ["object", "body"],
|
||||
YieldExpression: ["argument"],
|
||||
};
|
||||
|
||||
// Types.
|
||||
const NODE_TYPES = Object.keys(KEYS);
|
||||
|
||||
// Freeze the keys.
|
||||
for (const type of NODE_TYPES) {
|
||||
Object.freeze(KEYS[type]);
|
||||
}
|
||||
Object.freeze(KEYS);
|
||||
|
||||
export default KEYS;
|
||||
@@ -0,0 +1,42 @@
|
||||
#!/bin/bash
|
||||
|
||||
set -e
|
||||
|
||||
PATH=./node_modules/.bin:${PATH}
|
||||
CURRENT_VERSION=$(jq -r .version package.json)
|
||||
|
||||
case ${1} in
|
||||
Major | MAJOR | major)
|
||||
LEVEL=major
|
||||
;;
|
||||
|
||||
Minor | MINOR | minor)
|
||||
LEVEL=minor
|
||||
;;
|
||||
|
||||
Patch | PATCH | patch)
|
||||
LEVEL=patch
|
||||
;;
|
||||
|
||||
*)
|
||||
LEVEL=patch
|
||||
;;
|
||||
esac
|
||||
|
||||
NEW_VERSION=$(semver -i ${LEVEL} ${CURRENT_VERSION})
|
||||
echo "${CURRENT_VERSION} => ${NEW_VERSION}"
|
||||
read -n 1 -s -r -p "Press any key to continue (ctrl+c to abort)..."
|
||||
echo ""
|
||||
|
||||
echo "Patching package.json..."
|
||||
cat package.json | \
|
||||
jq --arg vers "${NEW_VERSION}" '.version = $vers' | \
|
||||
tee package.json 1>/dev/null
|
||||
|
||||
echo "Patching lib/meta.js ..."
|
||||
SED_SCRIPT=$(printf 's/%s/%s/' ${CURRENT_VERSION//\./\\.} ${NEW_VERSION//\./\\.})
|
||||
cat ./lib/meta.js | \
|
||||
sed -e ${SED_SCRIPT} | \
|
||||
tee ./lib/meta.js 1>/dev/null
|
||||
|
||||
echo "Done."
|
||||
@@ -0,0 +1,20 @@
|
||||
export * from './BlockScope';
|
||||
export * from './CatchScope';
|
||||
export * from './ClassFieldInitializerScope';
|
||||
export * from './ClassScope';
|
||||
export * from './ClassStaticBlockScope';
|
||||
export * from './ConditionalTypeScope';
|
||||
export * from './ForScope';
|
||||
export * from './FunctionExpressionNameScope';
|
||||
export * from './FunctionScope';
|
||||
export * from './FunctionTypeScope';
|
||||
export * from './GlobalScope';
|
||||
export * from './MappedTypeScope';
|
||||
export * from './ModuleScope';
|
||||
export * from './Scope';
|
||||
export * from './ScopeType';
|
||||
export * from './SwitchScope';
|
||||
export * from './TSEnumScope';
|
||||
export * from './TSModuleScope';
|
||||
export * from './TypeScope';
|
||||
export * from './WithScope';
|
||||
@@ -0,0 +1,42 @@
|
||||
{
|
||||
"name": "std-env",
|
||||
"version": "4.2.0",
|
||||
"description": "Runtime agnostic JS utils",
|
||||
"license": "MIT",
|
||||
"repository": "unjs/std-env",
|
||||
"files": [
|
||||
"dist"
|
||||
],
|
||||
"type": "module",
|
||||
"sideEffects": false,
|
||||
"main": "./dist/index.mjs",
|
||||
"types": "./dist/index.d.mts",
|
||||
"exports": {
|
||||
".": "./dist/index.mjs"
|
||||
},
|
||||
"scripts": {
|
||||
"build": "obuild",
|
||||
"dev": "vitest",
|
||||
"lint": "oxlint . && oxfmt",
|
||||
"lint:fix": "oxlint --fix . && oxfmt",
|
||||
"prepack": "obuild",
|
||||
"release": "pnpm test && pnpm build && changelogen --release && npm publish && git push --follow-tags",
|
||||
"test": "pnpm lint && pnpm typecheck && vitest run --coverage",
|
||||
"typecheck": "tsgo --noEmit"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@types/node": "^26.1.0",
|
||||
"@typescript/native-preview": "latest",
|
||||
"@vitest/coverage-v8": "^4.1.10",
|
||||
"changelogen": "^0.6.2",
|
||||
"esbuild": "^0.28.1",
|
||||
"mitata": "^1.0.34",
|
||||
"obuild": "^0.4.37",
|
||||
"oxfmt": "^0.57.0",
|
||||
"oxlint": "^1.72.0",
|
||||
"rollup": "^4.62.2",
|
||||
"typescript": "^6.0.3",
|
||||
"vitest": "^4.1.10"
|
||||
},
|
||||
"packageManager": "pnpm@11.10.0"
|
||||
}
|
||||
@@ -0,0 +1,2 @@
|
||||
import type { LibDefinition } from '../variable';
|
||||
export declare const es2022_full: LibDefinition;
|
||||
@@ -0,0 +1,54 @@
|
||||
import { expect, test } from "vitest";
|
||||
|
||||
import * as z from "zod/v4";
|
||||
|
||||
const gtFive = z.bigint().gt(BigInt(5));
|
||||
const gteFive = z.bigint().gte(BigInt(5));
|
||||
const ltFive = z.bigint().lt(BigInt(5));
|
||||
const lteFive = z.bigint().lte(BigInt(5));
|
||||
const positive = z.bigint().positive();
|
||||
const negative = z.bigint().negative();
|
||||
const nonnegative = z.bigint().nonnegative();
|
||||
const nonpositive = z.bigint().nonpositive();
|
||||
const multipleOfFive = z.bigint().multipleOf(BigInt(5));
|
||||
|
||||
test("passing validations", () => {
|
||||
z.bigint().parse(BigInt(1));
|
||||
z.bigint().parse(BigInt(0));
|
||||
z.bigint().parse(BigInt(-1));
|
||||
gtFive.parse(BigInt(6));
|
||||
gteFive.parse(BigInt(5));
|
||||
gteFive.parse(BigInt(6));
|
||||
ltFive.parse(BigInt(4));
|
||||
lteFive.parse(BigInt(5));
|
||||
lteFive.parse(BigInt(4));
|
||||
positive.parse(BigInt(3));
|
||||
negative.parse(BigInt(-2));
|
||||
nonnegative.parse(BigInt(0));
|
||||
nonnegative.parse(BigInt(7));
|
||||
nonpositive.parse(BigInt(0));
|
||||
nonpositive.parse(BigInt(-12));
|
||||
multipleOfFive.parse(BigInt(15));
|
||||
});
|
||||
|
||||
test("failing validations", () => {
|
||||
expect(() => gtFive.parse(BigInt(5))).toThrow();
|
||||
expect(() => gteFive.parse(BigInt(4))).toThrow();
|
||||
expect(() => ltFive.parse(BigInt(5))).toThrow();
|
||||
expect(() => lteFive.parse(BigInt(6))).toThrow();
|
||||
expect(() => positive.parse(BigInt(0))).toThrow();
|
||||
expect(() => positive.parse(BigInt(-2))).toThrow();
|
||||
expect(() => negative.parse(BigInt(0))).toThrow();
|
||||
expect(() => negative.parse(BigInt(3))).toThrow();
|
||||
expect(() => nonnegative.parse(BigInt(-1))).toThrow();
|
||||
expect(() => nonpositive.parse(BigInt(1))).toThrow();
|
||||
expect(() => multipleOfFive.parse(BigInt(13))).toThrow();
|
||||
});
|
||||
|
||||
test("min max getters", () => {
|
||||
expect(z.bigint().min(BigInt(5)).minValue).toEqual(BigInt(5));
|
||||
expect(z.bigint().min(BigInt(5)).min(BigInt(10)).minValue).toEqual(BigInt(10));
|
||||
|
||||
expect(z.bigint().max(BigInt(5)).maxValue).toEqual(BigInt(5));
|
||||
expect(z.bigint().max(BigInt(5)).max(BigInt(1)).maxValue).toEqual(BigInt(1));
|
||||
});
|
||||
Reference in New Issue
Block a user