alexandrump/skills-here-run-place
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
Alejandro Martinez
2026-02-12 02:04:10 +01:00
commit f09af719cf
13433 changed files with 2193445 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
node_modules/@types/debug/LICENSE generated vendored Normal file
View File

@@ -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

69
node_modules/@types/debug/README.md generated vendored Normal file
View File

@@ -0,0 +1,69 @@
# Installation
> `npm install --save @types/debug`
# Summary
This package contains type definitions for debug (https://github.com/debug-js/debug).
# Details
Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/debug.
## [index.d.ts](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/debug/index.d.ts)
````ts
declare var debug: debug.Debug & { debug: debug.Debug; default: debug.Debug };
export = debug;
export as namespace debug;
declare namespace debug {
interface Debug {
(namespace: string): Debugger;
coerce: (val: any) => any;
disable: () => string;
enable: (namespaces: string) => void;
enabled: (namespaces: string) => boolean;
formatArgs: (this: Debugger, args: any[]) => void;
log: (...args: any[]) => any;
selectColor: (namespace: string) => string | number;
humanize: typeof import("ms");
names: RegExp[];
skips: RegExp[];
formatters: Formatters;
inspectOpts?: {
hideDate?: boolean | number | null;
colors?: boolean | number | null;
depth?: boolean | number | null;
showHidden?: boolean | number | null;
};
}
type IDebug = Debug;
interface Formatters {
[formatter: string]: (v: any) => string;
}
type IDebugger = Debugger;
interface Debugger {
(formatter: any, ...args: any[]): void;
color: string;
diff: number;
enabled: boolean;
log: (...args: any[]) => any;
namespace: string;
destroy: () => boolean;
extend: (namespace: string, delimiter?: string) => Debugger;
}
}
````
### Additional Details
* Last updated: Thu, 09 Nov 2023 03:06:57 GMT
* Dependencies: [@types/ms](https://npmjs.com/package/@types/ms)
# Credits
These definitions were written by [Seon-Wook Park](https://github.com/swook), [Gal Talmor](https://github.com/galtalmor), [John McLaughlin](https://github.com/zamb3zi), [Brasten Sager](https://github.com/brasten), [Nicolas Penin](https://github.com/npenin), [Kristian Brünn](https://github.com/kristianmitk), and [Caleb Gregory](https://github.com/calebgregory).

50
node_modules/@types/debug/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,50 @@
declare var debug: debug.Debug & { debug: debug.Debug; default: debug.Debug };
export = debug;
export as namespace debug;
declare namespace debug {
interface Debug {
(namespace: string): Debugger;
coerce: (val: any) => any;
disable: () => string;
enable: (namespaces: string) => void;
enabled: (namespaces: string) => boolean;
formatArgs: (this: Debugger, args: any[]) => void;
log: (...args: any[]) => any;
selectColor: (namespace: string) => string | number;
humanize: typeof import("ms");
names: RegExp[];
skips: RegExp[];
formatters: Formatters;
inspectOpts?: {
hideDate?: boolean | number | null;
colors?: boolean | number | null;
depth?: boolean | number | null;
showHidden?: boolean | number | null;
};
}
type IDebug = Debug;
interface Formatters {
[formatter: string]: (v: any) => string;
}
type IDebugger = Debugger;
interface Debugger {
(formatter: any, ...args: any[]): void;
color: string;
diff: number;
enabled: boolean;
log: (...args: any[]) => any;
namespace: string;
destroy: () => boolean;
extend: (namespace: string, delimiter?: string) => Debugger;
}
}

57
node_modules/@types/debug/package.json generated vendored Normal file
View File

@@ -0,0 +1,57 @@
{
"name": "@types/debug",
"version": "4.1.12",
"description": "TypeScript definitions for debug",
"homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/debug",
"license": "MIT",
"contributors": [
{
"name": "Seon-Wook Park",
"githubUsername": "swook",
"url": "https://github.com/swook"
},
{
"name": "Gal Talmor",
"githubUsername": "galtalmor",
"url": "https://github.com/galtalmor"
},
{
"name": "John McLaughlin",
"githubUsername": "zamb3zi",
"url": "https://github.com/zamb3zi"
},
{
"name": "Brasten Sager",
"githubUsername": "brasten",
"url": "https://github.com/brasten"
},
{
"name": "Nicolas Penin",
"githubUsername": "npenin",
"url": "https://github.com/npenin"
},
{
"name": "Kristian Brünn",
"githubUsername": "kristianmitk",
"url": "https://github.com/kristianmitk"
},
{
"name": "Caleb Gregory",
"githubUsername": "calebgregory",
"url": "https://github.com/calebgregory"
}
],
"main": "",
"types": "index.d.ts",
"repository": {
"type": "git",
"url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
"directory": "types/debug"
},
"scripts": {},
"dependencies": {
"@types/ms": "*"
},
"typesPublisherContentHash": "1053110a8e5e302f35fb57f45389304fa5a4f53bb8982b76b8065bcfd7083731",
"typeScriptVersion": "4.5"
}

21
node_modules/@types/estree/LICENSE generated vendored Normal file
View File

@@ -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

15
node_modules/@types/estree/README.md generated vendored Normal file
View File

@@ -0,0 +1,15 @@
# Installation
> `npm install --save @types/estree`
# Summary
This package contains type definitions for estree (https://github.com/estree/estree).
# Details
Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/estree.
### Additional Details
* Last updated: Fri, 06 Jun 2025 00:04:33 GMT
* Dependencies: none
# Credits
These definitions were written by [RReverser](https://github.com/RReverser).

167
node_modules/@types/estree/flow.d.ts generated vendored Normal file
View File

@@ -0,0 +1,167 @@
declare namespace ESTree {
interface FlowTypeAnnotation extends Node {}
interface FlowBaseTypeAnnotation extends FlowTypeAnnotation {}
interface FlowLiteralTypeAnnotation extends FlowTypeAnnotation, Literal {}
interface FlowDeclaration extends Declaration {}
interface AnyTypeAnnotation extends FlowBaseTypeAnnotation {}
interface ArrayTypeAnnotation extends FlowTypeAnnotation {
elementType: FlowTypeAnnotation;
}
interface BooleanLiteralTypeAnnotation extends FlowLiteralTypeAnnotation {}
interface BooleanTypeAnnotation extends FlowBaseTypeAnnotation {}
interface ClassImplements extends Node {
id: Identifier;
typeParameters?: TypeParameterInstantiation | null;
}
interface ClassProperty {
key: Expression;
value?: Expression | null;
typeAnnotation?: TypeAnnotation | null;
computed: boolean;
static: boolean;
}
interface DeclareClass extends FlowDeclaration {
id: Identifier;
typeParameters?: TypeParameterDeclaration | null;
body: ObjectTypeAnnotation;
extends: InterfaceExtends[];
}
interface DeclareFunction extends FlowDeclaration {
id: Identifier;
}
interface DeclareModule extends FlowDeclaration {
id: Literal | Identifier;
body: BlockStatement;
}
interface DeclareVariable extends FlowDeclaration {
id: Identifier;
}
interface FunctionTypeAnnotation extends FlowTypeAnnotation {
params: FunctionTypeParam[];
returnType: FlowTypeAnnotation;
rest?: FunctionTypeParam | null;
typeParameters?: TypeParameterDeclaration | null;
}
interface FunctionTypeParam {
name: Identifier;
typeAnnotation: FlowTypeAnnotation;
optional: boolean;
}
interface GenericTypeAnnotation extends FlowTypeAnnotation {
id: Identifier | QualifiedTypeIdentifier;
typeParameters?: TypeParameterInstantiation | null;
}
interface InterfaceExtends extends Node {
id: Identifier | QualifiedTypeIdentifier;
typeParameters?: TypeParameterInstantiation | null;
}
interface InterfaceDeclaration extends FlowDeclaration {
id: Identifier;
typeParameters?: TypeParameterDeclaration | null;
extends: InterfaceExtends[];
body: ObjectTypeAnnotation;
}
interface IntersectionTypeAnnotation extends FlowTypeAnnotation {
types: FlowTypeAnnotation[];
}
interface MixedTypeAnnotation extends FlowBaseTypeAnnotation {}
interface NullableTypeAnnotation extends FlowTypeAnnotation {
typeAnnotation: TypeAnnotation;
}
interface NumberLiteralTypeAnnotation extends FlowLiteralTypeAnnotation {}
interface NumberTypeAnnotation extends FlowBaseTypeAnnotation {}
interface StringLiteralTypeAnnotation extends FlowLiteralTypeAnnotation {}
interface StringTypeAnnotation extends FlowBaseTypeAnnotation {}
interface TupleTypeAnnotation extends FlowTypeAnnotation {
types: FlowTypeAnnotation[];
}
interface TypeofTypeAnnotation extends FlowTypeAnnotation {
argument: FlowTypeAnnotation;
}
interface TypeAlias extends FlowDeclaration {
id: Identifier;
typeParameters?: TypeParameterDeclaration | null;
right: FlowTypeAnnotation;
}
interface TypeAnnotation extends Node {
typeAnnotation: FlowTypeAnnotation;
}
interface TypeCastExpression extends Expression {
expression: Expression;
typeAnnotation: TypeAnnotation;
}
interface TypeParameterDeclaration extends Node {
params: Identifier[];
}
interface TypeParameterInstantiation extends Node {
params: FlowTypeAnnotation[];
}
interface ObjectTypeAnnotation extends FlowTypeAnnotation {
properties: ObjectTypeProperty[];
indexers: ObjectTypeIndexer[];
callProperties: ObjectTypeCallProperty[];
}
interface ObjectTypeCallProperty extends Node {
value: FunctionTypeAnnotation;
static: boolean;
}
interface ObjectTypeIndexer extends Node {
id: Identifier;
key: FlowTypeAnnotation;
value: FlowTypeAnnotation;
static: boolean;
}
interface ObjectTypeProperty extends Node {
key: Expression;
value: FlowTypeAnnotation;
optional: boolean;
static: boolean;
}
interface QualifiedTypeIdentifier extends Node {
qualification: Identifier | QualifiedTypeIdentifier;
id: Identifier;
}
interface UnionTypeAnnotation extends FlowTypeAnnotation {
types: FlowTypeAnnotation[];
}
interface VoidTypeAnnotation extends FlowBaseTypeAnnotation {}
}

694
node_modules/@types/estree/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,694 @@
// This definition file follows a somewhat unusual format. ESTree allows
// runtime type checks based on the `type` parameter. In order to explain this
// to typescript we want to use discriminated union types:
// https://github.com/Microsoft/TypeScript/pull/9163
//
// For ESTree this is a bit tricky because the high level interfaces like
// Node or Function are pulling double duty. We want to pass common fields down
// to the interfaces that extend them (like Identifier or
// ArrowFunctionExpression), but you can't extend a type union or enforce
// common fields on them. So we've split the high level interfaces into two
// types, a base type which passes down inherited fields, and a type union of
// all types which extend the base type. Only the type union is exported, and
// the union is how other types refer to the collection of inheriting types.
//
// This makes the definitions file here somewhat more difficult to maintain,
// but it has the notable advantage of making ESTree much easier to use as
// an end user.
export interface BaseNodeWithoutComments {
// Every leaf interface that extends BaseNode must specify a type property.
// The type property should be a string literal. For example, Identifier
// has: `type: "Identifier"`
type: string;
loc?: SourceLocation | null | undefined;
range?: [number, number] | undefined;
}
export interface BaseNode extends BaseNodeWithoutComments {
leadingComments?: Comment[] | undefined;
trailingComments?: Comment[] | undefined;
}
export interface NodeMap {
AssignmentProperty: AssignmentProperty;
CatchClause: CatchClause;
Class: Class;
ClassBody: ClassBody;
Expression: Expression;
Function: Function;
Identifier: Identifier;
Literal: Literal;
MethodDefinition: MethodDefinition;
ModuleDeclaration: ModuleDeclaration;
ModuleSpecifier: ModuleSpecifier;
Pattern: Pattern;
PrivateIdentifier: PrivateIdentifier;
Program: Program;
Property: Property;
PropertyDefinition: PropertyDefinition;
SpreadElement: SpreadElement;
Statement: Statement;
Super: Super;
SwitchCase: SwitchCase;
TemplateElement: TemplateElement;
VariableDeclarator: VariableDeclarator;
}
export type Node = NodeMap[keyof NodeMap];
export interface Comment extends BaseNodeWithoutComments {
type: "Line" | "Block";
value: string;
}
export interface SourceLocation {
source?: string | null | undefined;
start: Position;
end: Position;
}
export interface Position {
/** >= 1 */
line: number;
/** >= 0 */
column: number;
}
export interface Program extends BaseNode {
type: "Program";
sourceType: "script" | "module";
body: Array<Directive | Statement | ModuleDeclaration>;
comments?: Comment[] | undefined;
}
export interface Directive extends BaseNode {
type: "ExpressionStatement";
expression: Literal;
directive: string;
}
export interface BaseFunction extends BaseNode {
params: Pattern[];
generator?: boolean | undefined;
async?: boolean | undefined;
// The body is either BlockStatement or Expression because arrow functions
// can have a body that's either. FunctionDeclarations and
// FunctionExpressions have only BlockStatement bodies.
body: BlockStatement | Expression;
}
export type Function = FunctionDeclaration | FunctionExpression | ArrowFunctionExpression;
export type Statement =
| ExpressionStatement
| BlockStatement
| StaticBlock
| EmptyStatement
| DebuggerStatement
| WithStatement
| ReturnStatement
| LabeledStatement
| BreakStatement
| ContinueStatement
| IfStatement
| SwitchStatement
| ThrowStatement
| TryStatement
| WhileStatement
| DoWhileStatement
| ForStatement
| ForInStatement
| ForOfStatement
| Declaration;
export interface BaseStatement extends BaseNode {}
export interface EmptyStatement extends BaseStatement {
type: "EmptyStatement";
}
export interface BlockStatement extends BaseStatement {
type: "BlockStatement";
body: Statement[];
innerComments?: Comment[] | undefined;
}
export interface StaticBlock extends Omit<BlockStatement, "type"> {
type: "StaticBlock";
}
export interface ExpressionStatement extends BaseStatement {
type: "ExpressionStatement";
expression: Expression;
}
export interface IfStatement extends BaseStatement {
type: "IfStatement";
test: Expression;
consequent: Statement;
alternate?: Statement | null | undefined;
}
export interface LabeledStatement extends BaseStatement {
type: "LabeledStatement";
label: Identifier;
body: Statement;
}
export interface BreakStatement extends BaseStatement {
type: "BreakStatement";
label?: Identifier | null | undefined;
}
export interface ContinueStatement extends BaseStatement {
type: "ContinueStatement";
label?: Identifier | null | undefined;
}
export interface WithStatement extends BaseStatement {
type: "WithStatement";
object: Expression;
body: Statement;
}
export interface SwitchStatement extends BaseStatement {
type: "SwitchStatement";
discriminant: Expression;
cases: SwitchCase[];
}
export interface ReturnStatement extends BaseStatement {
type: "ReturnStatement";
argument?: Expression | null | undefined;
}
export interface ThrowStatement extends BaseStatement {
type: "ThrowStatement";
argument: Expression;
}
export interface TryStatement extends BaseStatement {
type: "TryStatement";
block: BlockStatement;
handler?: CatchClause | null | undefined;
finalizer?: BlockStatement | null | undefined;
}
export interface WhileStatement extends BaseStatement {
type: "WhileStatement";
test: Expression;
body: Statement;
}
export interface DoWhileStatement extends BaseStatement {
type: "DoWhileStatement";
body: Statement;
test: Expression;
}
export interface ForStatement extends BaseStatement {
type: "ForStatement";
init?: VariableDeclaration | Expression | null | undefined;
test?: Expression | null | undefined;
update?: Expression | null | undefined;
body: Statement;
}
export interface BaseForXStatement extends BaseStatement {
left: VariableDeclaration | Pattern;
right: Expression;
body: Statement;
}
export interface ForInStatement extends BaseForXStatement {
type: "ForInStatement";
}
export interface DebuggerStatement extends BaseStatement {
type: "DebuggerStatement";
}
export type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration;
export interface BaseDeclaration extends BaseStatement {}
export interface MaybeNamedFunctionDeclaration extends BaseFunction, BaseDeclaration {
type: "FunctionDeclaration";
/** It is null when a function declaration is a part of the `export default function` statement */
id: Identifier | null;
body: BlockStatement;
}
export interface FunctionDeclaration extends MaybeNamedFunctionDeclaration {
id: Identifier;
}
export interface VariableDeclaration extends BaseDeclaration {
type: "VariableDeclaration";
declarations: VariableDeclarator[];
kind: "var" | "let" | "const" | "using" | "await using";
}
export interface VariableDeclarator extends BaseNode {
type: "VariableDeclarator";
id: Pattern;
init?: Expression | null | undefined;
}
export interface ExpressionMap {
ArrayExpression: ArrayExpression;
ArrowFunctionExpression: ArrowFunctionExpression;
AssignmentExpression: AssignmentExpression;
AwaitExpression: AwaitExpression;
BinaryExpression: BinaryExpression;
CallExpression: CallExpression;
ChainExpression: ChainExpression;
ClassExpression: ClassExpression;
ConditionalExpression: ConditionalExpression;
FunctionExpression: FunctionExpression;
Identifier: Identifier;
ImportExpression: ImportExpression;
Literal: Literal;
LogicalExpression: LogicalExpression;
MemberExpression: MemberExpression;
MetaProperty: MetaProperty;
NewExpression: NewExpression;
ObjectExpression: ObjectExpression;
SequenceExpression: SequenceExpression;
TaggedTemplateExpression: TaggedTemplateExpression;
TemplateLiteral: TemplateLiteral;
ThisExpression: ThisExpression;
UnaryExpression: UnaryExpression;
UpdateExpression: UpdateExpression;
YieldExpression: YieldExpression;
}
export type Expression = ExpressionMap[keyof ExpressionMap];
export interface BaseExpression extends BaseNode {}
export type ChainElement = SimpleCallExpression | MemberExpression;
export interface ChainExpression extends BaseExpression {
type: "ChainExpression";
expression: ChainElement;
}
export interface ThisExpression extends BaseExpression {
type: "ThisExpression";
}
export interface ArrayExpression extends BaseExpression {
type: "ArrayExpression";
elements: Array<Expression | SpreadElement | null>;
}
export interface ObjectExpression extends BaseExpression {
type: "ObjectExpression";
properties: Array<Property | SpreadElement>;
}
export interface PrivateIdentifier extends BaseNode {
type: "PrivateIdentifier";
name: string;
}
export interface Property extends BaseNode {
type: "Property";
key: Expression | PrivateIdentifier;
value: Expression | Pattern; // Could be an AssignmentProperty
kind: "init" | "get" | "set";
method: boolean;
shorthand: boolean;
computed: boolean;
}
export interface PropertyDefinition extends BaseNode {
type: "PropertyDefinition";
key: Expression | PrivateIdentifier;
value?: Expression | null | undefined;
computed: boolean;
static: boolean;
}
export interface FunctionExpression extends BaseFunction, BaseExpression {
id?: Identifier | null | undefined;
type: "FunctionExpression";
body: BlockStatement;
}
export interface SequenceExpression extends BaseExpression {
type: "SequenceExpression";
expressions: Expression[];
}
export interface UnaryExpression extends BaseExpression {
type: "UnaryExpression";
operator: UnaryOperator;
prefix: true;
argument: Expression;
}
export interface BinaryExpression extends BaseExpression {
type: "BinaryExpression";
operator: BinaryOperator;
left: Expression | PrivateIdentifier;
right: Expression;
}
export interface AssignmentExpression extends BaseExpression {
type: "AssignmentExpression";
operator: AssignmentOperator;
left: Pattern | MemberExpression;
right: Expression;
}
export interface UpdateExpression extends BaseExpression {
type: "UpdateExpression";
operator: UpdateOperator;
argument: Expression;
prefix: boolean;
}
export interface LogicalExpression extends BaseExpression {
type: "LogicalExpression";
operator: LogicalOperator;
left: Expression;
right: Expression;
}
export interface ConditionalExpression extends BaseExpression {
type: "ConditionalExpression";
test: Expression;
alternate: Expression;
consequent: Expression;
}
export interface BaseCallExpression extends BaseExpression {
callee: Expression | Super;
arguments: Array<Expression | SpreadElement>;
}
export type CallExpression = SimpleCallExpression | NewExpression;
export interface SimpleCallExpression extends BaseCallExpression {
type: "CallExpression";
optional: boolean;
}
export interface NewExpression extends BaseCallExpression {
type: "NewExpression";
}
export interface MemberExpression extends BaseExpression, BasePattern {
type: "MemberExpression";
object: Expression | Super;
property: Expression | PrivateIdentifier;
computed: boolean;
optional: boolean;
}
export type Pattern = Identifier | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | MemberExpression;
export interface BasePattern extends BaseNode {}
export interface SwitchCase extends BaseNode {
type: "SwitchCase";
test?: Expression | null | undefined;
consequent: Statement[];
}
export interface CatchClause extends BaseNode {
type: "CatchClause";
param: Pattern | null;
body: BlockStatement;
}
export interface Identifier extends BaseNode, BaseExpression, BasePattern {
type: "Identifier";
name: string;
}
export type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral;
export interface SimpleLiteral extends BaseNode, BaseExpression {
type: "Literal";
value: string | boolean | number | null;
raw?: string | undefined;
}
export interface RegExpLiteral extends BaseNode, BaseExpression {
type: "Literal";
value?: RegExp | null | undefined;
regex: {
pattern: string;
flags: string;
};
raw?: string | undefined;
}
export interface BigIntLiteral extends BaseNode, BaseExpression {
type: "Literal";
value?: bigint | null | undefined;
bigint: string;
raw?: string | undefined;
}
export type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
export type BinaryOperator =
| "=="
| "!="
| "==="
| "!=="
| "<"
| "<="
| ">"
| ">="
| "<<"
| ">>"
| ">>>"
| "+"
| "-"
| "*"
| "/"
| "%"
| "**"
| "|"
| "^"
| "&"
| "in"
| "instanceof";
export type LogicalOperator = "||" | "&&" | "??";
export type AssignmentOperator =
| "="
| "+="
| "-="
| "*="
| "/="
| "%="
| "**="
| "<<="
| ">>="
| ">>>="
| "|="
| "^="
| "&="
| "||="
| "&&="
| "??=";
export type UpdateOperator = "++" | "--";
export interface ForOfStatement extends BaseForXStatement {
type: "ForOfStatement";
await: boolean;
}
export interface Super extends BaseNode {
type: "Super";
}
export interface SpreadElement extends BaseNode {
type: "SpreadElement";
argument: Expression;
}
export interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
type: "ArrowFunctionExpression";
expression: boolean;
body: BlockStatement | Expression;
}
export interface YieldExpression extends BaseExpression {
type: "YieldExpression";
argument?: Expression | null | undefined;
delegate: boolean;
}
export interface TemplateLiteral extends BaseExpression {
type: "TemplateLiteral";
quasis: TemplateElement[];
expressions: Expression[];
}
export interface TaggedTemplateExpression extends BaseExpression {
type: "TaggedTemplateExpression";
tag: Expression;
quasi: TemplateLiteral;
}
export interface TemplateElement extends BaseNode {
type: "TemplateElement";
tail: boolean;
value: {
/** It is null when the template literal is tagged and the text has an invalid escape (e.g. - tag`\unicode and \u{55}`) */
cooked?: string | null | undefined;
raw: string;
};
}
export interface AssignmentProperty extends Property {
value: Pattern;
kind: "init";
method: boolean; // false
}
export interface ObjectPattern extends BasePattern {
type: "ObjectPattern";
properties: Array<AssignmentProperty | RestElement>;
}
export interface ArrayPattern extends BasePattern {
type: "ArrayPattern";
elements: Array<Pattern | null>;
}
export interface RestElement extends BasePattern {
type: "RestElement";
argument: Pattern;
}
export interface AssignmentPattern extends BasePattern {
type: "AssignmentPattern";
left: Pattern;
right: Expression;
}
export type Class = ClassDeclaration | ClassExpression;
export interface BaseClass extends BaseNode {
superClass?: Expression | null | undefined;
body: ClassBody;
}
export interface ClassBody extends BaseNode {
type: "ClassBody";
body: Array<MethodDefinition | PropertyDefinition | StaticBlock>;
}
export interface MethodDefinition extends BaseNode {
type: "MethodDefinition";
key: Expression | PrivateIdentifier;
value: FunctionExpression;
kind: "constructor" | "method" | "get" | "set";
computed: boolean;
static: boolean;
}
export interface MaybeNamedClassDeclaration extends BaseClass, BaseDeclaration {
type: "ClassDeclaration";
/** It is null when a class declaration is a part of the `export default class` statement */
id: Identifier | null;
}
export interface ClassDeclaration extends MaybeNamedClassDeclaration {
id: Identifier;
}
export interface ClassExpression extends BaseClass, BaseExpression {
type: "ClassExpression";
id?: Identifier | null | undefined;
}
export interface MetaProperty extends BaseExpression {
type: "MetaProperty";
meta: Identifier;
property: Identifier;
}
export type ModuleDeclaration =
| ImportDeclaration
| ExportNamedDeclaration
| ExportDefaultDeclaration
| ExportAllDeclaration;
export interface BaseModuleDeclaration extends BaseNode {}
export type ModuleSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier;
export interface BaseModuleSpecifier extends BaseNode {
local: Identifier;
}
export interface ImportDeclaration extends BaseModuleDeclaration {
type: "ImportDeclaration";
specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>;
attributes: ImportAttribute[];
source: Literal;
}
export interface ImportSpecifier extends BaseModuleSpecifier {
type: "ImportSpecifier";
imported: Identifier | Literal;
}
export interface ImportAttribute extends BaseNode {
type: "ImportAttribute";
key: Identifier | Literal;
value: Literal;
}
export interface ImportExpression extends BaseExpression {
type: "ImportExpression";
source: Expression;
options?: Expression | null | undefined;
}
export interface ImportDefaultSpecifier extends BaseModuleSpecifier {
type: "ImportDefaultSpecifier";
}
export interface ImportNamespaceSpecifier extends BaseModuleSpecifier {
type: "ImportNamespaceSpecifier";
}
export interface ExportNamedDeclaration extends BaseModuleDeclaration {
type: "ExportNamedDeclaration";
declaration?: Declaration | null | undefined;
specifiers: ExportSpecifier[];
attributes: ImportAttribute[];
source?: Literal | null | undefined;
}
export interface ExportSpecifier extends Omit<BaseModuleSpecifier, "local"> {
type: "ExportSpecifier";
local: Identifier | Literal;
exported: Identifier | Literal;
}
export interface ExportDefaultDeclaration extends BaseModuleDeclaration {
type: "ExportDefaultDeclaration";
declaration: MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration | Expression;
}
export interface ExportAllDeclaration extends BaseModuleDeclaration {
type: "ExportAllDeclaration";
exported: Identifier | Literal | null;
attributes: ImportAttribute[];
source: Literal;
}
export interface AwaitExpression extends BaseExpression {
type: "AwaitExpression";
argument: Expression;
}

27
node_modules/@types/estree/package.json generated vendored Normal file
View File

@@ -0,0 +1,27 @@
{
"name": "@types/estree",
"version": "1.0.8",
"description": "TypeScript definitions for estree",
"homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/estree",
"license": "MIT",
"contributors": [
{
"name": "RReverser",
"githubUsername": "RReverser",
"url": "https://github.com/RReverser"
}
],
"main": "",
"types": "index.d.ts",
"repository": {
"type": "git",
"url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
"directory": "types/estree"
},
"scripts": {},
"dependencies": {},
"peerDependencies": {},
"typesPublisherContentHash": "7a167b6e4a4d9f6e9a2cb9fd3fc45c885f89cbdeb44b3e5961bb057a45c082fd",
"typeScriptVersion": "5.1",
"nonNpm": true
}

21
node_modules/@types/hast/LICENSE generated vendored Normal file
View File

@@ -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

15
node_modules/@types/hast/README.md generated vendored Normal file
View File

@@ -0,0 +1,15 @@
# Installation
> `npm install --save @types/hast`
# Summary
This package contains type definitions for hast (https://github.com/syntax-tree/hast).
# Details
Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/hast.
### Additional Details
* Last updated: Tue, 30 Jan 2024 21:35:45 GMT
* Dependencies: [@types/unist](https://npmjs.com/package/@types/unist)
# Credits
These definitions were written by [lukeggchapman](https://github.com/lukeggchapman), [Junyoung Choi](https://github.com/rokt33r), [Christian Murphy](https://github.com/ChristianMurphy), and [Remco Haszing](https://github.com/remcohaszing).

282
node_modules/@types/hast/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,282 @@
import type { Data as UnistData, Literal as UnistLiteral, Node as UnistNode, Parent as UnistParent } from "unist";
// ## Interfaces
/**
* Info associated with hast nodes by the ecosystem.
*
* This space is guaranteed to never be specified by unist or hast.
* But you can use it in utilities and plugins to store data.
*
* This type can be augmented to register custom data.
* For example:
*
* ```ts
* declare module 'hast' {
* interface Data {
* // `someNode.data.myId` is typed as `number | undefined`
* myId?: number | undefined
* }
* }
* ```
*/
export interface Data extends UnistData {}
/**
* Info associated with an element.
*/
export interface Properties {
[PropertyName: string]: boolean | number | string | null | undefined | Array<string | number>;
}
// ## Content maps
/**
* Union of registered hast nodes that can occur in {@link Element}.
*
* To register mote custom hast nodes, add them to {@link ElementContentMap}.
* They will be automatically added here.
*/
export type ElementContent = ElementContentMap[keyof ElementContentMap];
/**
* Registry of all hast nodes that can occur as children of {@link Element}.
*
* For a union of all {@link Element} children, see {@link ElementContent}.
*/
export interface ElementContentMap {
comment: Comment;
element: Element;
text: Text;
}
/**
* Union of registered hast nodes that can occur in {@link Root}.
*
* To register custom hast nodes, add them to {@link RootContentMap}.
* They will be automatically added here.
*/
export type RootContent = RootContentMap[keyof RootContentMap];
/**
* Registry of all hast nodes that can occur as children of {@link Root}.
*
* > 👉 **Note**: {@link Root} does not need to be an entire document.
* > it can also be a fragment.
*
* For a union of all {@link Root} children, see {@link RootContent}.
*/
export interface RootContentMap {
comment: Comment;
doctype: Doctype;
element: Element;
text: Text;
}
// ### Special content types
/**
* Union of registered hast nodes that can occur in {@link Root}.
*
* @deprecated Use {@link RootContent} instead.
*/
export type Content = RootContent;
/**
* Union of registered hast literals.
*
* To register custom hast nodes, add them to {@link RootContentMap} and other
* places where relevant.
* They will be automatically added here.
*/
export type Literals = Extract<Nodes, UnistLiteral>;
/**
* Union of registered hast nodes.
*
* To register custom hast nodes, add them to {@link RootContentMap} and other
* places where relevant.
* They will be automatically added here.
*/
export type Nodes = Root | RootContent;
/**
* Union of registered hast parents.
*
* To register custom hast nodes, add them to {@link RootContentMap} and other
* places where relevant.
* They will be automatically added here.
*/
export type Parents = Extract<Nodes, UnistParent>;
// ## Abstract nodes
/**
* Abstract hast node.
*
* This interface is supposed to be extended.
* If you can use {@link Literal} or {@link Parent}, you should.
* But for example in HTML, a `Doctype` is neither literal nor parent, but
* still a node.
*
* To register custom hast nodes, add them to {@link RootContentMap} and other
* places where relevant (such as {@link ElementContentMap}).
*
* For a union of all registered hast nodes, see {@link Nodes}.
*/
export interface Node extends UnistNode {
/**
* Info from the ecosystem.
*/
data?: Data | undefined;
}
/**
* Abstract hast node that contains the smallest possible value.
*
* This interface is supposed to be extended if you make custom hast nodes.
*
* For a union of all registered hast literals, see {@link Literals}.
*/
export interface Literal extends Node {
/**
* Plain-text value.
*/
value: string;
}
/**
* Abstract hast node that contains other hast nodes (*children*).
*
* This interface is supposed to be extended if you make custom hast nodes.
*
* For a union of all registered hast parents, see {@link Parents}.
*/
export interface Parent extends Node {
/**
* List of children.
*/
children: RootContent[];
}
// ## Concrete nodes
/**
* HTML comment.
*/
export interface Comment extends Literal {
/**
* Node type of HTML comments in hast.
*/
type: "comment";
/**
* Data associated with the comment.
*/
data?: CommentData | undefined;
}
/**
* Info associated with hast comments by the ecosystem.
*/
export interface CommentData extends Data {}
/**
* HTML document type.
*/
export interface Doctype extends UnistNode {
/**
* Node type of HTML document types in hast.
*/
type: "doctype";
/**
* Data associated with the doctype.
*/
data?: DoctypeData | undefined;
}
/**
* Info associated with hast doctypes by the ecosystem.
*/
export interface DoctypeData extends Data {}
/**
* HTML element.
*/
export interface Element extends Parent {
/**
* Node type of elements.
*/
type: "element";
/**
* Tag name (such as `'body'`) of the element.
*/
tagName: string;
/**
* Info associated with the element.
*/
properties: Properties;
/**
* Children of element.
*/
children: ElementContent[];
/**
* When the `tagName` field is `'template'`, a `content` field can be
* present.
*/
content?: Root | undefined;
/**
* Data associated with the element.
*/
data?: ElementData | undefined;
}
/**
* Info associated with hast elements by the ecosystem.
*/
export interface ElementData extends Data {}
/**
* Document fragment or a whole document.
*
* Should be used as the root of a tree and must not be used as a child.
*
* Can also be used as the value for the content field on a `'template'` element.
*/
export interface Root extends Parent {
/**
* Node type of hast root.
*/
type: "root";
/**
* Children of root.
*/
children: RootContent[];
/**
* Data associated with the hast root.
*/
data?: RootData | undefined;
}
/**
* Info associated with hast root nodes by the ecosystem.
*/
export interface RootData extends Data {}
/**
* HTML character data (plain text).
*/
export interface Text extends Literal {
/**
* Node type of HTML character data (plain text) in hast.
*/
type: "text";
/**
* Data associated with the text.
*/
data?: TextData | undefined;
}
/**
* Info associated with hast texts by the ecosystem.
*/
export interface TextData extends Data {}

42
node_modules/@types/hast/package.json generated vendored Normal file
View File

@@ -0,0 +1,42 @@
{
"name": "@types/hast",
"version": "3.0.4",
"description": "TypeScript definitions for hast",
"homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/hast",
"license": "MIT",
"contributors": [
{
"name": "lukeggchapman",
"githubUsername": "lukeggchapman",
"url": "https://github.com/lukeggchapman"
},
{
"name": "Junyoung Choi",
"githubUsername": "rokt33r",
"url": "https://github.com/rokt33r"
},
{
"name": "Christian Murphy",
"githubUsername": "ChristianMurphy",
"url": "https://github.com/ChristianMurphy"
},
{
"name": "Remco Haszing",
"githubUsername": "remcohaszing",
"url": "https://github.com/remcohaszing"
}
],
"main": "",
"types": "index.d.ts",
"repository": {
"type": "git",
"url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
"directory": "types/hast"
},
"scripts": {},
"dependencies": {
"@types/unist": "*"
},
"typesPublisherContentHash": "3f3f73826d79157c12087f5bb36195319c6f435b9e218fa7a8de88d1cc64d097",
"typeScriptVersion": "4.6"
}

21
node_modules/@types/mdast/LICENSE generated vendored Normal file
View File

@@ -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

15
node_modules/@types/mdast/README.md generated vendored Normal file
View File

@@ -0,0 +1,15 @@
# Installation
> `npm install --save @types/mdast`
# Summary
This package contains type definitions for mdast (https://github.com/syntax-tree/mdast).
# Details
Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/mdast.
### Additional Details
* Last updated: Tue, 14 May 2024 07:35:36 GMT
* Dependencies: [@types/unist](https://npmjs.com/package/@types/unist)
# Credits
These definitions were written by [Christian Murphy](https://github.com/ChristianMurphy), [Jun Lu](https://github.com/lujun2), [Remco Haszing](https://github.com/remcohaszing), [Titus Wormer](https://github.com/wooorm), and [Remco Haszing](https://github.com/remcohaszing).

1123
node_modules/@types/mdast/index.d.ts generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

47
node_modules/@types/mdast/package.json generated vendored Normal file
View File

@@ -0,0 +1,47 @@
{
"name": "@types/mdast",
"version": "4.0.4",
"description": "TypeScript definitions for mdast",
"homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/mdast",
"license": "MIT",
"contributors": [
{
"name": "Christian Murphy",
"githubUsername": "ChristianMurphy",
"url": "https://github.com/ChristianMurphy"
},
{
"name": "Jun Lu",
"githubUsername": "lujun2",
"url": "https://github.com/lujun2"
},
{
"name": "Remco Haszing",
"githubUsername": "remcohaszing",
"url": "https://github.com/remcohaszing"
},
{
"name": "Titus Wormer",
"githubUsername": "wooorm",
"url": "https://github.com/wooorm"
},
{
"name": "Remco Haszing",
"githubUsername": "remcohaszing",
"url": "https://github.com/remcohaszing"
}
],
"main": "",
"types": "index.d.ts",
"repository": {
"type": "git",
"url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
"directory": "types/mdast"
},
"scripts": {},
"dependencies": {
"@types/unist": "*"
},
"typesPublisherContentHash": "1599d3ca45533e9d9248231c90843306b49c07fe13ad94ebf7345da44d8fd4bd",
"typeScriptVersion": "4.7"
}

21
node_modules/@types/ms/LICENSE generated vendored Normal file
View File

@@ -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

82
node_modules/@types/ms/README.md generated vendored Normal file
View File

@@ -0,0 +1,82 @@
# Installation
> `npm install --save @types/ms`
# Summary
This package contains type definitions for ms (https://github.com/vercel/ms).
# Details
Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/ms.
## [index.d.ts](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/ms/index.d.ts)
````ts
/**
* Short/Long format for `value`.
*
* @param {Number} value
* @param {{long: boolean}} options
* @return {String}
*/
declare function ms(value: number, options?: { long: boolean }): string;
/**
* Parse the given `value` and return milliseconds.
*
* @param {ms.StringValue} value
* @return {Number}
*/
declare function ms(value: ms.StringValue): number;
declare namespace ms {
// Unit, UnitAnyCase, and StringValue are backported from ms@3
// https://github.com/vercel/ms/blob/8b5923d1d86c84a9f6aba8022d416dcf2361aa8d/src/index.ts
type Unit =
| "Years"
| "Year"
| "Yrs"
| "Yr"
| "Y"
| "Weeks"
| "Week"
| "W"
| "Days"
| "Day"
| "D"
| "Hours"
| "Hour"
| "Hrs"
| "Hr"
| "H"
| "Minutes"
| "Minute"
| "Mins"
| "Min"
| "M"
| "Seconds"
| "Second"
| "Secs"
| "Sec"
| "s"
| "Milliseconds"
| "Millisecond"
| "Msecs"
| "Msec"
| "Ms";
type UnitAnyCase = Unit | Uppercase<Unit> | Lowercase<Unit>;
type StringValue =
| `${number}`
| `${number}${UnitAnyCase}`
| `${number} ${UnitAnyCase}`;
}
export = ms;
````
### Additional Details
* Last updated: Thu, 16 Jan 2025 21:02:45 GMT
* Dependencies: none
# Credits
These definitions were written by [Zhiyuan Wang](https://github.com/danny8002).

63
node_modules/@types/ms/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,63 @@
/**
* Short/Long format for `value`.
*
* @param {Number} value
* @param {{long: boolean}} options
* @return {String}
*/
declare function ms(value: number, options?: { long: boolean }): string;
/**
* Parse the given `value` and return milliseconds.
*
* @param {ms.StringValue} value
* @return {Number}
*/
declare function ms(value: ms.StringValue): number;
declare namespace ms {
// Unit, UnitAnyCase, and StringValue are backported from ms@3
// https://github.com/vercel/ms/blob/8b5923d1d86c84a9f6aba8022d416dcf2361aa8d/src/index.ts
type Unit =
| "Years"
| "Year"
| "Yrs"
| "Yr"
| "Y"
| "Weeks"
| "Week"
| "W"
| "Days"
| "Day"
| "D"
| "Hours"
| "Hour"
| "Hrs"
| "Hr"
| "H"
| "Minutes"
| "Minute"
| "Mins"
| "Min"
| "M"
| "Seconds"
| "Second"
| "Secs"
| "Sec"
| "s"
| "Milliseconds"
| "Millisecond"
| "Msecs"
| "Msec"
| "Ms";
type UnitAnyCase = Unit | Uppercase<Unit> | Lowercase<Unit>;
type StringValue =
| `${number}`
| `${number}${UnitAnyCase}`
| `${number} ${UnitAnyCase}`;
}
export = ms;

26
node_modules/@types/ms/package.json generated vendored Normal file
View File

@@ -0,0 +1,26 @@
{
"name": "@types/ms",
"version": "2.1.0",
"description": "TypeScript definitions for ms",
"homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/ms",
"license": "MIT",
"contributors": [
{
"name": "Zhiyuan Wang",
"githubUsername": "danny8002",
"url": "https://github.com/danny8002"
}
],
"main": "",
"types": "index.d.ts",
"repository": {
"type": "git",
"url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
"directory": "types/ms"
},
"scripts": {},
"dependencies": {},
"peerDependencies": {},
"typesPublisherContentHash": "2c8651ce1714fdc6bcbc0f262c93a790f1d127fb1c2dc8edbb583decef56fd39",
"typeScriptVersion": "5.0"
}

21
node_modules/@types/nlcst/LICENSE generated vendored Normal file
View File

@@ -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

15
node_modules/@types/nlcst/README.md generated vendored Normal file
View File

@@ -0,0 +1,15 @@
# Installation
> `npm install --save @types/nlcst`
# Summary
This package contains type definitions for nlcst (https://github.com/syntax-tree/nlcst).
# Details
Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/nlcst.
### Additional Details
* Last updated: Tue, 07 Nov 2023 20:08:00 GMT
* Dependencies: [@types/unist](https://npmjs.com/package/@types/unist)
# Credits
These definitions were written by [Titus Wormer](https://github.com/wooorm), [Christian Murphy](https://github.com/ChristianMurphy), and [Remco Haszing](https://github.com/remcohaszing).

411
node_modules/@types/nlcst/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,411 @@
import type { Data as UnistData, Literal as UnistLiteral, Node as UnistNode, Parent as UnistParent } from "unist";
// ## Interfaces
/**
* Info associated with nlcst nodes by the ecosystem.
*
* This space is guaranteed to never be specified by unist or nlcst.
* But you can use it in utilities and plugins to store data.
*
* This type can be augmented to register custom data.
* For example:
*
* ```ts
* declare module 'nlcst' {
* interface Data {
* // `someNode.data.myId` is typed as `number | undefined`
* myId?: number | undefined
* }
* }
* ```
*/
export interface Data extends UnistData {}
// ## Content maps
/**
* Union of registered nlcst nodes that can occur in {@link Paragraph}.
*
* To register more custom nlcst nodes, add them to {@link ParagraphContentMap}.
* They will be automatically added here.
*/
export type ParagraphContent = ParagraphContentMap[keyof ParagraphContentMap];
/**
* Registry of all nlcst nodes that can occur as children of {@link Paragraph}.
*
* For a union of all {@link Paragraph} children, see {@link ParagraphContent}.
*/
export interface ParagraphContentMap {
sentence: Sentence;
source: Source;
whiteSpace: WhiteSpace;
}
/**
* Union of registered nlcst nodes that can occur in {@link Root}.
*
* To register custom nlcst nodes, add them to {@link RootContentMap}.
* They will be automatically added here.
*/
export type RootContent = RootContentMap[keyof RootContentMap];
/**
* Registry of all nlcst nodes that can occur as children of {@link Root}.
*
* > 👉 **Note**: {@link Root} does not need to be an entire document.
* > it can also be a fragment.
*
* For a union of all {@link Root} children, see {@link RootContent}.
*/
export interface RootContentMap {
paragraph: Paragraph;
punctuation: Punctuation;
sentence: Sentence;
source: Source;
symbol: Symbol;
text: Text;
whiteSpace: WhiteSpace;
word: Word;
}
/**
* Union of registered nlcst nodes that can occur in {@link Sentence}.
*
* To register more custom nlcst nodes, add them to {@link SentenceContentMap}.
* They will be automatically added here.
*/
export type SentenceContent = SentenceContentMap[keyof SentenceContentMap];
/**
* Registry of all nlcst nodes that can occur as children of {@link Sentence}.
*
* For a union of all {@link Sentence} children, see {@link SentenceContent}.
*/
export interface SentenceContentMap {
punctuation: Punctuation;
source: Source;
symbol: Symbol;
whiteSpace: WhiteSpace;
word: Word;
}
/**
* Union of registered nlcst nodes that can occur in {@link Word}.
*
* To register more custom nlcst nodes, add them to {@link WordContentMap}.
* They will be automatically added here.
*/
export type WordContent = WordContentMap[keyof WordContentMap];
/**
* Registry of all nlcst nodes that can occur as children of {@link Word}.
*
* For a union of all {@link Word} children, see {@link WordContent}.
*/
export interface WordContentMap {
punctuation: Punctuation;
source: Source;
symbol: Symbol;
text: Text;
}
// ### Special content types
/**
* Union of registered nlcst nodes that can occur in {@link Root}.
*
* @deprecated Use {@link RootContent} instead.
*/
export type Content = RootContent;
/**
* Union of registered nlcst literals.
*
* To register custom nlcst nodes, add them to {@link RootContentMap} and other
* places where relevant.
* They will be automatically added here.
*/
export type Literals = Extract<Nodes, UnistLiteral>;
/**
* Union of registered nlcst nodes.
*
* To register custom nlcst nodes, add them to {@link RootContentMap} and other
* places where relevant.
* They will be automatically added here.
*/
export type Nodes = Root | RootContent;
/**
* Union of registered nlcst parents.
*
* To register custom nlcst nodes, add them to {@link RootContentMap} and other
* places where relevant.
* They will be automatically added here.
*/
export type Parents = Extract<Nodes, UnistParent>;
// ## Abstract nodes
/**
* Abstract nlcst node that contains the smallest possible value.
*
* This interface is supposed to be extended if you make custom nlcst nodes.
*
* For a union of all registered nlcst literals, see {@link Literals}.
*/
export interface Literal extends Node {
/**
* Plain-text value.
*/
value: string;
}
/**
* Abstract nlcst node.
*
* This interface is supposed to be extended.
* If you can use {@link Literal} or {@link Parent}, you should.
* But for example in markdown, a `thematicBreak` (`***`) is neither literal
* nor parent, but still a node.
*
* To register custom nlcst nodes, add them to {@link RootContentMap} and other
* places where relevant (such as {@link SentenceContentMap}).
*
* For a union of all registered nlcst nodes, see {@link Nodes}.
*/
export interface Node extends UnistNode {
/**
* Info from the ecosystem.
*/
data?: Data | undefined;
}
/**
* Abstract nlcst node that contains other nlcst nodes (*children*).
*
* This interface is supposed to be extended if you make custom nlcst nodes.
*
* For a union of all registered nlcst parents, see {@link Parents}.
*/
export interface Parent extends Node {
/**
* List of children.
*/
children: RootContent[];
}
// ## Concrete nodes
/**
* Unit of discourse dealing with a particular point or idea.
*
* Can contain sentence, whitespace, and source nodes.
*/
export interface Paragraph extends Parent {
/**
* Node type of nlcst paragraph.
*/
type: "ParagraphNode";
/**
* Children of paragraph.
*/
children: ParagraphContent[];
/**
* Data associated with the nlcst paragraph.
*/
data?: ParagraphData | undefined;
}
/**
* Info associated with nlcst paragraph nodes by the ecosystem.
*/
export interface ParagraphData extends Data {}
/**
* Typographical devices which aid understanding and correct reading of other
* grammatical units.
*
* Can be used in sentence or word nodes.
*/
export interface Punctuation extends Literal {
/**
* Node type of nlcst punctuations.
*/
type: "PunctuationNode";
/**
* Data associated with the nlcst punctuation.
*/
data?: PunctuationData | undefined;
}
/**
* Info associated with nlcst punctuation nodes by the ecosystem.
*/
export interface PunctuationData extends Data {}
/**
* Document fragment or a whole document.
*
* Should be used as the root of a tree and must not be used as a child.
* Its content model is not limited, it can contain any nlcst content, with the
* restriction that all content must be of the same category.
*/
export interface Root extends Parent {
/**
* Node type of nlcst root.
*/
type: "RootNode";
/**
* Data associated with the nlcst root.
*/
data?: RootData | undefined;
}
/**
* Info associated with nlcst root nodes by the ecosystem.
*/
export interface RootData extends Data {}
/**
* Grouping of grammatically linked words, that in principle tells a complete
* thought, although it may make little sense taken in isolation out of
* context.
*
* Can be used in a paragraph node.
* Can contain word, symbol, punctuation, whitespace, and source nodes.
*/
export interface Sentence extends Parent {
/**
* Node type of nlcst sentence.
*/
type: "SentenceNode";
/**
* Children of sentence.
*/
children: SentenceContent[];
/**
* Data associated with the nlcst sentence.
*/
data?: SentenceData | undefined;
}
/**
* Info associated with nlcst sentence nodes by the ecosystem.
*/
export interface SentenceData extends Data {}
/**
* External (ungrammatical) value embedded into a grammatical unit: a hyperlink,
* code, and such.
*
* Can be used in root, paragraph, sentence, or word nodes.
*/
export interface Source extends Literal {
/**
* Node type of nlcst sources.
*/
type: "SourceNode";
/**
* Data associated with the nlcst source.
*/
data?: SourceData | undefined;
}
/**
* Info associated with nlcst source nodes by the ecosystem.
*/
export interface SourceData extends Data {}
/**
* Typographical devices different from characters which represent sounds (like
* letters and numerals), white space, or punctuation.
*
* Can be used in sentence or word nodes.
*/
export interface Symbol extends Literal {
/**
* Node type of nlcst symbols.
*/
type: "SymbolNode";
/**
* Data associated with the nlcst symbol.
*/
data?: SymbolData | undefined;
}
/**
* Info associated with nlcst symbol nodes by the ecosystem.
*/
export interface SymbolData extends Data {}
/**
* Actual content in nlcst documents: one or more characters.
*
* Can be used in word nodes.
*/
export interface Text extends Literal {
/**
* Node type of nlcst texts.
*/
type: "TextNode";
/**
* Data associated with the nlcst text.
*/
data?: TextData | undefined;
}
/**
* Info associated with nlcst text nodes by the ecosystem.
*/
export interface TextData extends Data {}
/**
* Typographical devices devoid of content, separating other units.
*
* Can be used in root, paragraph, or sentence nodes.
*/
export interface WhiteSpace extends Literal {
/**
* Node type of nlcst white space.
*/
type: "WhiteSpaceNode";
/**
* Data associated with the nlcst white space.
*/
data?: WhiteSpaceData | undefined;
}
/**
* Info associated with nlcst white space nodes by the ecosystem.
*/
export interface WhiteSpaceData extends Data {}
/**
* Smallest element that may be uttered in isolation with semantic or pragmatic
* content.
*
* Can be used in a sentence node.
* Can contain text, symbol, punctuation, and source nodes.
*/
export interface Word extends Parent {
/**
* Node type of nlcst word.
*/
type: "WordNode";
/**
* Children of word.
*/
children: WordContent[];
/**
* Data associated with the nlcst word.
*/
data?: WordData | undefined;
}
/**
* Info associated with nlcst word nodes by the ecosystem.
*/
export interface WordData extends Data {}

38
node_modules/@types/nlcst/package.json generated vendored Normal file
View File

@@ -0,0 +1,38 @@
{
"name": "@types/nlcst",
"version": "2.0.3",
"description": "TypeScript definitions for nlcst",
"homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/nlcst",
"license": "MIT",
"contributors": [
{
"name": "Titus Wormer",
"githubUsername": "wooorm",
"url": "https://github.com/wooorm"
},
{
"name": "Christian Murphy",
"githubUsername": "ChristianMurphy",
"url": "https://github.com/ChristianMurphy"
},
{
"name": "Remco Haszing",
"githubUsername": "remcohaszing",
"url": "https://github.com/remcohaszing"
}
],
"main": "",
"types": "index.d.ts",
"repository": {
"type": "git",
"url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
"directory": "types/nlcst"
},
"scripts": {},
"dependencies": {
"@types/unist": "*"
},
"typesPublisherContentHash": "0fa949bca84428c174a30ddfe401eb6dbef19a2e0731309d9e4861bfe8f63540",
"typeScriptVersion": "4.5",
"nonNpm": true
}

21
node_modules/@types/unist/LICENSE generated vendored Normal file
View File

@@ -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

15
node_modules/@types/unist/README.md generated vendored Normal file
View File

@@ -0,0 +1,15 @@
# Installation
> `npm install --save @types/unist`
# Summary
This package contains type definitions for unist (https://github.com/syntax-tree/unist).
# Details
Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/unist.
### Additional Details
* Last updated: Thu, 15 Aug 2024 02:18:53 GMT
* Dependencies: none
# Credits
These definitions were written by [bizen241](https://github.com/bizen241), [Jun Lu](https://github.com/lujun2), [Hernan Rajchert](https://github.com/hrajchert), [Titus Wormer](https://github.com/wooorm), [Junyoung Choi](https://github.com/rokt33r), [Ben Moon](https://github.com/GuiltyDolphin), [JounQin](https://github.com/JounQin), and [Remco Haszing](https://github.com/remcohaszing).

119
node_modules/@types/unist/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,119 @@
// ## Interfaces
/**
* Info associated with nodes by the ecosystem.
*
* This space is guaranteed to never be specified by unist or specifications
* implementing unist.
* But you can use it in utilities and plugins to store data.
*
* This type can be augmented to register custom data.
* For example:
*
* ```ts
* declare module 'unist' {
* interface Data {
* // `someNode.data.myId` is typed as `number | undefined`
* myId?: number | undefined
* }
* }
* ```
*/
export interface Data {}
/**
* One place in a source file.
*/
export interface Point {
/**
* Line in a source file (1-indexed integer).
*/
line: number;
/**
* Column in a source file (1-indexed integer).
*/
column: number;
/**
* Character in a source file (0-indexed integer).
*/
offset?: number | undefined;
}
/**
* Position of a node in a source document.
*
* A position is a range between two points.
*/
export interface Position {
/**
* Place of the first character of the parsed source region.
*/
start: Point;
/**
* Place of the first character after the parsed source region.
*/
end: Point;
}
// ## Abstract nodes
/**
* Abstract unist node that contains the smallest possible value.
*
* This interface is supposed to be extended.
*
* For example, in HTML, a `text` node is a leaf that contains text.
*/
export interface Literal extends Node {
/**
* Plain value.
*/
value: unknown;
}
/**
* Abstract unist node.
*
* The syntactic unit in unist syntax trees are called nodes.
*
* This interface is supposed to be extended.
* If you can use {@link Literal} or {@link Parent}, you should.
* But for example in markdown, a `thematicBreak` (`***`), is neither literal
* nor parent, but still a node.
*/
export interface Node {
/**
* Node type.
*/
type: string;
/**
* Info from the ecosystem.
*/
data?: Data | undefined;
/**
* Position of a node in a source document.
*
* Nodes that are generated (not in the original source document) must not
* have a position.
*/
position?: Position | undefined;
}
/**
* Abstract unist node that contains other nodes (*children*).
*
* This interface is supposed to be extended.
*
* For example, in XML, an element is a parent of different things, such as
* comments, text, and further elements.
*/
export interface Parent extends Node {
/**
* List of children.
*/
children: Node[];
}

60
node_modules/@types/unist/package.json generated vendored Normal file
View File

@@ -0,0 +1,60 @@
{
"name": "@types/unist",
"version": "3.0.3",
"description": "TypeScript definitions for unist",
"homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/unist",
"license": "MIT",
"contributors": [
{
"name": "bizen241",
"githubUsername": "bizen241",
"url": "https://github.com/bizen241"
},
{
"name": "Jun Lu",
"githubUsername": "lujun2",
"url": "https://github.com/lujun2"
},
{
"name": "Hernan Rajchert",
"githubUsername": "hrajchert",
"url": "https://github.com/hrajchert"
},
{
"name": "Titus Wormer",
"githubUsername": "wooorm",
"url": "https://github.com/wooorm"
},
{
"name": "Junyoung Choi",
"githubUsername": "rokt33r",
"url": "https://github.com/rokt33r"
},
{
"name": "Ben Moon",
"githubUsername": "GuiltyDolphin",
"url": "https://github.com/GuiltyDolphin"
},
{
"name": "JounQin",
"githubUsername": "JounQin",
"url": "https://github.com/JounQin"
},
{
"name": "Remco Haszing",
"githubUsername": "remcohaszing",
"url": "https://github.com/remcohaszing"
}
],
"main": "",
"types": "index.d.ts",
"repository": {
"type": "git",
"url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git",
"directory": "types/unist"
},
"scripts": {},
"dependencies": {},
"typesPublisherContentHash": "7f3d5ce8d56003f3583a5317f98d444bdc99910c7b486c6b10af4f38694e61fe",
"typeScriptVersion": "4.8"
}