8889841cexpress/README.md000066600000001625150432033150007520 0ustar00# Installation > `npm install --save @types/express` # Summary This package contains type definitions for Express (http://expressjs.com). # Details Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/express. ### Additional Details * Last updated: Fri, 03 Feb 2023 21:32:47 GMT * Dependencies: [@types/body-parser](https://npmjs.com/package/@types/body-parser), [@types/express-serve-static-core](https://npmjs.com/package/@types/express-serve-static-core), [@types/qs](https://npmjs.com/package/@types/qs), [@types/serve-static](https://npmjs.com/package/@types/serve-static) * Global values: none # Credits These definitions were written by [Boris Yankov](https://github.com/borisyankov), [China Medical University Hospital](https://github.com/CMUH), [Puneet Arora](https://github.com/puneetar), and [Dylan Frankland](https://github.com/dfrankland). express/index.d.ts000066600000011325150432033150010140 0ustar00// Type definitions for Express 4.17 // Project: http://expressjs.com // Definitions by: Boris Yankov // China Medical University Hospital // Puneet Arora // Dylan Frankland // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped /* =================== USAGE =================== import express = require("express"); var app = express(); =============================================== */ /// /// import * as bodyParser from 'body-parser'; import * as serveStatic from 'serve-static'; import * as core from 'express-serve-static-core'; import * as qs from 'qs'; /** * Creates an Express application. The express() function is a top-level function exported by the express module. */ declare function e(): core.Express; declare namespace e { /** * This is a built-in middleware function in Express. It parses incoming requests with JSON payloads and is based on body-parser. * @since 4.16.0 */ var json: typeof bodyParser.json; /** * This is a built-in middleware function in Express. It parses incoming requests with Buffer payloads and is based on body-parser. * @since 4.17.0 */ var raw: typeof bodyParser.raw; /** * This is a built-in middleware function in Express. It parses incoming requests with text payloads and is based on body-parser. * @since 4.17.0 */ var text: typeof bodyParser.text; /** * These are the exposed prototypes. */ var application: Application; var request: Request; var response: Response; /** * This is a built-in middleware function in Express. It serves static files and is based on serve-static. */ var static: serveStatic.RequestHandlerConstructor; /** * This is a built-in middleware function in Express. It parses incoming requests with urlencoded payloads and is based on body-parser. * @since 4.16.0 */ var urlencoded: typeof bodyParser.urlencoded; /** * This is a built-in middleware function in Express. It parses incoming request query parameters. */ export function query(options: qs.IParseOptions | typeof qs.parse): Handler; export function Router(options?: RouterOptions): core.Router; interface RouterOptions { /** * Enable case sensitivity. */ caseSensitive?: boolean | undefined; /** * Preserve the req.params values from the parent router. * If the parent and the child have conflicting param names, the child’s value take precedence. * * @default false * @since 4.5.0 */ mergeParams?: boolean | undefined; /** * Enable strict routing. */ strict?: boolean | undefined; } interface Application extends core.Application {} interface CookieOptions extends core.CookieOptions {} interface Errback extends core.Errback {} interface ErrorRequestHandler< P = core.ParamsDictionary, ResBody = any, ReqBody = any, ReqQuery = core.Query, Locals extends Record = Record > extends core.ErrorRequestHandler {} interface Express extends core.Express {} interface Handler extends core.Handler {} interface IRoute extends core.IRoute {} interface IRouter extends core.IRouter {} interface IRouterHandler extends core.IRouterHandler {} interface IRouterMatcher extends core.IRouterMatcher {} interface MediaType extends core.MediaType {} interface NextFunction extends core.NextFunction {} interface Locals extends core.Locals {} interface Request< P = core.ParamsDictionary, ResBody = any, ReqBody = any, ReqQuery = core.Query, Locals extends Record = Record > extends core.Request {} interface RequestHandler< P = core.ParamsDictionary, ResBody = any, ReqBody = any, ReqQuery = core.Query, Locals extends Record = Record > extends core.RequestHandler {} interface RequestParamHandler extends core.RequestParamHandler {} interface Response< ResBody = any, Locals extends Record = Record > extends core.Response {} interface Router extends core.Router {} interface Send extends core.Send {} } export = e; express/LICENSE000066600000002165150432033150007246 0ustar00 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 express/package.json000066600000002607150432033150010530 0ustar00{ "name": "@types/express", "version": "4.17.17", "description": "TypeScript definitions for Express", "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/express", "license": "MIT", "contributors": [ { "name": "Boris Yankov", "url": "https://github.com/borisyankov", "githubUsername": "borisyankov" }, { "name": "China Medical University Hospital", "url": "https://github.com/CMUH", "githubUsername": "CMUH" }, { "name": "Puneet Arora", "url": "https://github.com/puneetar", "githubUsername": "puneetar" }, { "name": "Dylan Frankland", "url": "https://github.com/dfrankland", "githubUsername": "dfrankland" } ], "main": "", "types": "index.d.ts", "repository": { "type": "git", "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git", "directory": "types/express" }, "scripts": {}, "dependencies": { "@types/body-parser": "*", "@types/express-serve-static-core": "^4.17.33", "@types/qs": "*", "@types/serve-static": "*" }, "typesPublisherContentHash": "a4c3d98898199c22408b7c0662e85011cacce7899cd22a66275337ec40edac14", "typeScriptVersion": "4.2" }estree/README.md000066600000000764150432033150007321 0ustar00# Installation > `npm install --save @types/estree` # Summary This package contains type definitions for ESTree AST specification (https://github.com/estree/estree). # Details Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/estree. ### Additional Details * Last updated: Sun, 06 Feb 2022 12:01:26 GMT * Dependencies: none * Global values: none # Credits These definitions were written by [RReverser](https://github.com/RReverser). estree/flow.d.ts000066600000011165150432033150007600 0ustar00// Type definitions for ESTree AST extensions for Facebook Flow // Project: https://github.com/estree/estree // Definitions by: RReverser // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped 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: Array; } 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: Array; 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: Array; body: ObjectTypeAnnotation; } interface IntersectionTypeAnnotation extends FlowTypeAnnotation { types: Array; } 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: Array; } 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: Array; } interface TypeParameterInstantiation extends Node { params: Array; } interface ObjectTypeAnnotation extends FlowTypeAnnotation { properties: Array; indexers: Array; callProperties: Array; } 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: Array; } interface VoidTypeAnnotation extends FlowBaseTypeAnnotation {} } estree/index.d.ts000066600000040650150432033150007741 0ustar00// Type definitions for ESTree AST specification // Project: https://github.com/estree/estree // Definitions by: RReverser // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped // 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. 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; } interface BaseNode extends BaseNodeWithoutComments { leadingComments?: Array | undefined; trailingComments?: Array | undefined; } export type Node = Identifier | Literal | Program | Function | SwitchCase | CatchClause | VariableDeclarator | Statement | Expression | PrivateIdentifier | Property | PropertyDefinition | AssignmentProperty | Super | TemplateElement | SpreadElement | Pattern | ClassBody | Class | MethodDefinition | ModuleDeclaration | ModuleSpecifier; export interface Comment extends BaseNodeWithoutComments { type: "Line" | "Block"; value: string; } 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; comments?: Array | undefined; } export interface Directive extends BaseNode { type: "ExpressionStatement"; expression: Literal; directive: string; } interface BaseFunction extends BaseNode { params: Array; 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; interface BaseStatement extends BaseNode { } export interface EmptyStatement extends BaseStatement { type: "EmptyStatement"; } export interface BlockStatement extends BaseStatement { type: "BlockStatement"; body: Array; innerComments?: Array | undefined; } export interface StaticBlock extends Omit { 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: Array; } 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; } 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; interface BaseDeclaration extends BaseStatement { } export interface FunctionDeclaration 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 VariableDeclaration extends BaseDeclaration { type: "VariableDeclaration"; declarations: Array; kind: "var" | "let" | "const"; } export interface VariableDeclarator extends BaseNode { type: "VariableDeclarator"; id: Pattern; init?: Expression | null | undefined; } type Expression = ThisExpression | ArrayExpression | ObjectExpression | FunctionExpression | ArrowFunctionExpression | YieldExpression | Literal | UnaryExpression | UpdateExpression | BinaryExpression | AssignmentExpression | LogicalExpression | MemberExpression | ConditionalExpression | CallExpression | NewExpression | SequenceExpression | TemplateLiteral | TaggedTemplateExpression | ClassExpression | MetaProperty | Identifier | AwaitExpression | ImportExpression | ChainExpression; export interface BaseExpression extends BaseNode { } 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; } export interface ObjectExpression extends BaseExpression { type: "ObjectExpression"; properties: Array; } 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: Array; } export interface UnaryExpression extends BaseExpression { type: "UnaryExpression"; operator: UnaryOperator; prefix: true; argument: Expression; } export interface BinaryExpression extends BaseExpression { type: "BinaryExpression"; operator: BinaryOperator; left: Expression; 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; } interface BaseCallExpression extends BaseExpression { callee: Expression | Super; arguments: Array; } 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; interface BasePattern extends BaseNode { } export interface SwitchCase extends BaseNode { type: "SwitchCase"; test?: Expression | null | undefined; consequent: Array; } 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: Array; expressions: Array; } 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; } export interface ArrayPattern extends BasePattern { type: "ArrayPattern"; elements: Array; } 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; interface BaseClass extends BaseNode { superClass?: Expression | null | undefined; body: ClassBody; } export interface ClassBody extends BaseNode { type: "ClassBody"; body: Array; } export interface MethodDefinition extends BaseNode { type: "MethodDefinition"; key: Expression | PrivateIdentifier; value: FunctionExpression; kind: "constructor" | "method" | "get" | "set"; computed: boolean; static: boolean; } export interface ClassDeclaration 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 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; interface BaseModuleDeclaration extends BaseNode { } export type ModuleSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier; interface BaseModuleSpecifier extends BaseNode { local: Identifier; } export interface ImportDeclaration extends BaseModuleDeclaration { type: "ImportDeclaration"; specifiers: Array; source: Literal; } export interface ImportSpecifier extends BaseModuleSpecifier { type: "ImportSpecifier"; imported: Identifier; } export interface ImportExpression extends BaseExpression { type: "ImportExpression"; source: Expression; } 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: Array; source?: Literal | null | undefined; } export interface ExportSpecifier extends BaseModuleSpecifier { type: "ExportSpecifier"; exported: Identifier; } export interface ExportDefaultDeclaration extends BaseModuleDeclaration { type: "ExportDefaultDeclaration"; declaration: Declaration | Expression; } export interface ExportAllDeclaration extends BaseModuleDeclaration { type: "ExportAllDeclaration"; exported: Identifier | null; source: Literal; } export interface AwaitExpression extends BaseExpression { type: "AwaitExpression"; argument: Expression; } estree/LICENSE000066600000002165150432033150007044 0ustar00 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 estree/package.json000066600000001440150432033150010320 0ustar00{ "name": "@types/estree", "version": "0.0.51", "description": "TypeScript definitions for ESTree AST specification", "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/estree", "license": "MIT", "contributors": [ { "name": "RReverser", "url": "https://github.com/RReverser", "githubUsername": "RReverser" } ], "main": "", "types": "index.d.ts", "repository": { "type": "git", "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git", "directory": "types/estree" }, "scripts": {}, "dependencies": {}, "typesPublisherContentHash": "95cbccd2dde8b8492f61e0e8049641ae05129705d9ba742955b711cfb71f3621", "typeScriptVersion": "3.8" }sockjs/README.md000066600000004332150432033150007321 0ustar00# Installation > `npm install --save @types/sockjs` # Summary This package contains type definitions for sockjs (https://github.com/sockjs/sockjs-node). # Details Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/sockjs. ## [index.d.ts](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/sockjs/index.d.ts) ````ts // Type definitions for sockjs 0.3 // Project: https://github.com/sockjs/sockjs-node // Definitions by: Phil McCloghry-Laing // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped /// import http = require('http'); export interface ServerOptions { sockjs_url?: string | undefined; prefix?: string | undefined; response_limit?: number | undefined; websocket?: boolean | undefined; jsessionid?: any; log?(severity: string, message: string): void; heartbeat_delay?: number | undefined; disconnect_delay?: number | undefined; } export function createServer(options?: ServerOptions): Server; export interface Server extends NodeJS.EventEmitter { installHandlers(server: http.Server, options?: ServerOptions): any; on(event: 'connection', listener: (conn: Connection) => any): this; on(event: string, listener: Function): this; } export interface Connection extends NodeJS.ReadWriteStream { remoteAddress: string; remotePort: number; address: { [key: string]: { address: string; port: number; }; }; headers: { [key: string]: string; }; url: string; pathname: string; prefix: string; protocol: string; readyState: number; id: string; close(code?: string, reason?: string): boolean; destroy(): void; on(event: 'data', listener: (message: string) => any): this; on(event: 'close', listener: () => void): this; on(event: string, listener: Function): this; } ```` ### Additional Details * Last updated: Tue, 06 Jul 2021 16:35:05 GMT * Dependencies: [@types/node](https://npmjs.com/package/@types/node) * Global values: none # Credits These definitions were written by [Phil McCloghry-Laing](https://github.com/pmccloghrylaing). sockjs/index.d.ts000066600000003071150432033150007742 0ustar00// Type definitions for sockjs 0.3 // Project: https://github.com/sockjs/sockjs-node // Definitions by: Phil McCloghry-Laing // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped /// import http = require('http'); export interface ServerOptions { sockjs_url?: string | undefined; prefix?: string | undefined; response_limit?: number | undefined; websocket?: boolean | undefined; jsessionid?: any; log?(severity: string, message: string): void; heartbeat_delay?: number | undefined; disconnect_delay?: number | undefined; } export function createServer(options?: ServerOptions): Server; export interface Server extends NodeJS.EventEmitter { installHandlers(server: http.Server, options?: ServerOptions): any; on(event: 'connection', listener: (conn: Connection) => any): this; on(event: string, listener: Function): this; } export interface Connection extends NodeJS.ReadWriteStream { remoteAddress: string; remotePort: number; address: { [key: string]: { address: string; port: number; }; }; headers: { [key: string]: string; }; url: string; pathname: string; prefix: string; protocol: string; readyState: number; id: string; close(code?: string, reason?: string): boolean; destroy(): void; on(event: 'data', listener: (message: string) => any): this; on(event: 'close', listener: () => void): this; on(event: string, listener: Function): this; } sockjs/LICENSE000066600000002165150432033150007051 0ustar00 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 sockjs/package.json000066600000001505150432033150010327 0ustar00{ "name": "@types/sockjs", "version": "0.3.33", "description": "TypeScript definitions for sockjs", "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/sockjs", "license": "MIT", "contributors": [ { "name": "Phil McCloghry-Laing", "url": "https://github.com/pmccloghrylaing", "githubUsername": "pmccloghrylaing" } ], "main": "", "types": "index.d.ts", "repository": { "type": "git", "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git", "directory": "types/sockjs" }, "scripts": {}, "dependencies": { "@types/node": "*" }, "typesPublisherContentHash": "60705ce98e42b180403cdab479820d2e483d02749f85cb6ef9bbd39ee05102af", "typeScriptVersion": "3.6" }imagemin/README.md000066600000003231150432033150007610 0ustar00# Installation > `npm install --save @types/imagemin` # Summary This package contains type definitions for imagemin (https://github.com/imagemin/imagemin#readme). # Details Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/imagemin. ## [index.d.ts](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/imagemin/index.d.ts) ````ts // Type definitions for imagemin 8.0 // Project: https://github.com/imagemin/imagemin#readme // Definitions by: Romain Faust // Jeff Chan // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped /// /** * @async */ declare function imagemin(input: ReadonlyArray, options?: Options): Promise; declare namespace imagemin { /** * @async */ function buffer(input: Buffer, options?: BufferOptions): Promise; } export type Plugin = (input: Buffer) => Promise; export interface Options { destination?: string | undefined; plugins: ReadonlyArray; glob?: boolean | undefined; } export interface Result { data: Buffer; sourcePath: string; destinationPath: string; } export interface BufferOptions { plugins: ReadonlyArray; } export default imagemin; ```` ### Additional Details * Last updated: Wed, 08 Feb 2023 19:03:02 GMT * Dependencies: [@types/node](https://npmjs.com/package/@types/node) * Global values: none # Credits These definitions were written by [Romain Faust](https://github.com/romain-faust), and [Jeff Chan](https://github.com/hkjeffchan). imagemin/index.d.ts000066600000001705150432033150010236 0ustar00// Type definitions for imagemin 8.0 // Project: https://github.com/imagemin/imagemin#readme // Definitions by: Romain Faust // Jeff Chan // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped /// /** * @async */ declare function imagemin(input: ReadonlyArray, options?: Options): Promise; declare namespace imagemin { /** * @async */ function buffer(input: Buffer, options?: BufferOptions): Promise; } export type Plugin = (input: Buffer) => Promise; export interface Options { destination?: string | undefined; plugins: ReadonlyArray; glob?: boolean | undefined; } export interface Result { data: Buffer; sourcePath: string; destinationPath: string; } export interface BufferOptions { plugins: ReadonlyArray; } export default imagemin; imagemin/LICENSE000066600000002165150432033150007343 0ustar00 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 imagemin/package.json000066600000001751150432033150010624 0ustar00{ "name": "@types/imagemin", "version": "8.0.1", "description": "TypeScript definitions for imagemin", "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/imagemin", "license": "MIT", "contributors": [ { "name": "Romain Faust", "url": "https://github.com/romain-faust", "githubUsername": "romain-faust" }, { "name": "Jeff Chan", "url": "https://github.com/hkjeffchan", "githubUsername": "hkjeffchan" } ], "main": "", "types": "index.d.ts", "repository": { "type": "git", "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git", "directory": "types/imagemin" }, "scripts": {}, "dependencies": { "@types/node": "*" }, "typesPublisherContentHash": "498cbb93dbfcb0d2e6ca4019ab6f943c95a982b37aec69f94a9c01308c9c2cde", "typeScriptVersion": "4.2", "type": "module" }connect-history-api-fallback/README.md000066600000004052150432033150013460 0ustar00# Installation > `npm install --save @types/connect-history-api-fallback` # Summary This package contains type definitions for connect-history-api-fallback (https://github.com/bripkens/connect-history-api-fallback#readme). # Details Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/connect-history-api-fallback. ## [index.d.ts](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/connect-history-api-fallback/index.d.ts) ````ts // Type definitions for connect-history-api-fallback 1.3 // Project: https://github.com/bripkens/connect-history-api-fallback#readme // Definitions by: Douglas Duteil // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped // TypeScript Version: 2.3 /// import { Url } from 'url'; import * as core from "express-serve-static-core"; export = historyApiFallback; declare function historyApiFallback(options?: historyApiFallback.Options): core.RequestHandler; declare namespace historyApiFallback { interface Options { readonly disableDotRule?: true | undefined; readonly htmlAcceptHeaders?: ReadonlyArray | undefined; readonly index?: string | undefined; readonly logger?: typeof console.log | undefined; readonly rewrites?: ReadonlyArray | undefined; readonly verbose?: boolean | undefined; } interface Context { readonly match: RegExpMatchArray; readonly parsedUrl: Url; } type RewriteTo = (context: Context) => string; interface Rewrite { readonly from: RegExp; readonly to: string | RegExp | RewriteTo; } } ```` ### Additional Details * Last updated: Tue, 06 Jul 2021 18:05:59 GMT * Dependencies: [@types/express-serve-static-core](https://npmjs.com/package/@types/express-serve-static-core), [@types/node](https://npmjs.com/package/@types/node) * Global values: none # Credits These definitions were written by [Douglas Duteil](https://github.com/douglasduteil). connect-history-api-fallback/index.d.ts000066600000002277150432033150014111 0ustar00// Type definitions for connect-history-api-fallback 1.3 // Project: https://github.com/bripkens/connect-history-api-fallback#readme // Definitions by: Douglas Duteil // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped // TypeScript Version: 2.3 /// import { Url } from 'url'; import * as core from "express-serve-static-core"; export = historyApiFallback; declare function historyApiFallback(options?: historyApiFallback.Options): core.RequestHandler; declare namespace historyApiFallback { interface Options { readonly disableDotRule?: true | undefined; readonly htmlAcceptHeaders?: ReadonlyArray | undefined; readonly index?: string | undefined; readonly logger?: typeof console.log | undefined; readonly rewrites?: ReadonlyArray | undefined; readonly verbose?: boolean | undefined; } interface Context { readonly match: RegExpMatchArray; readonly parsedUrl: Url; } type RewriteTo = (context: Context) => string; interface Rewrite { readonly from: RegExp; readonly to: string | RegExp | RewriteTo; } } connect-history-api-fallback/LICENSE000066600000002165150432033150013211 0ustar00 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 connect-history-api-fallback/package.json000066600000001703150432033150014467 0ustar00{ "name": "@types/connect-history-api-fallback", "version": "1.3.5", "description": "TypeScript definitions for connect-history-api-fallback", "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/connect-history-api-fallback", "license": "MIT", "contributors": [ { "name": "Douglas Duteil", "url": "https://github.com/douglasduteil", "githubUsername": "douglasduteil" } ], "main": "", "types": "index.d.ts", "repository": { "type": "git", "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git", "directory": "types/connect-history-api-fallback" }, "scripts": {}, "dependencies": { "@types/express-serve-static-core": "*", "@types/node": "*" }, "typesPublisherContentHash": "a24785c4139e895dbf093b9cba3ee1b0ce5709a928e6a36ac4ae4161c74399ff", "typeScriptVersion": "3.6" }serve-index/README.md000066600000003634150432033150010262 0ustar00# Installation > `npm install --save @types/serve-index` # Summary This package contains type definitions for serve-index (https://github.com/expressjs/serve-index). # Details Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/serve-index. ## [index.d.ts](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/serve-index/index.d.ts) ````ts // Type definitions for serve-index 1.9 // Project: https://github.com/expressjs/serve-index // Definitions by: Tanguy Krotoff // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped import { Handler } from 'express'; import { Stats } from 'fs'; /** Serves pages that contain directory listings for a given path. */ declare function serveIndex(path: string, options?: serveIndex.Options): Handler; declare namespace serveIndex { interface File { name: string; stat: Stats; } interface Locals { directory: string; displayIcons: boolean; fileList: File[]; name: string; stat: Stats; path: string; style: string; viewName: string; } type TemplateCallback = (error: Error | null, htmlString?: string) => void; interface Options { filter?: ((filename: string, index: number, files: File[], dir: string) => boolean) | undefined; hidden?: boolean | undefined; icons?: boolean | undefined; stylesheet?: string | undefined; template?: string | ((locals: Locals, callback: TemplateCallback) => void) | undefined; view?: string | undefined; } } export = serveIndex; ```` ### Additional Details * Last updated: Tue, 06 Jul 2021 16:34:37 GMT * Dependencies: [@types/express](https://npmjs.com/package/@types/express) * Global values: none # Credits These definitions were written by [Tanguy Krotoff](https://github.com/tkrotoff). serve-index/index.d.ts000066600000002353150432033150010701 0ustar00// Type definitions for serve-index 1.9 // Project: https://github.com/expressjs/serve-index // Definitions by: Tanguy Krotoff // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped import { Handler } from 'express'; import { Stats } from 'fs'; /** Serves pages that contain directory listings for a given path. */ declare function serveIndex(path: string, options?: serveIndex.Options): Handler; declare namespace serveIndex { interface File { name: string; stat: Stats; } interface Locals { directory: string; displayIcons: boolean; fileList: File[]; name: string; stat: Stats; path: string; style: string; viewName: string; } type TemplateCallback = (error: Error | null, htmlString?: string) => void; interface Options { filter?: ((filename: string, index: number, files: File[], dir: string) => boolean) | undefined; hidden?: boolean | undefined; icons?: boolean | undefined; stylesheet?: string | undefined; template?: string | ((locals: Locals, callback: TemplateCallback) => void) | undefined; view?: string | undefined; } } export = serveIndex; serve-index/LICENSE000066600000002165150432033150010006 0ustar00 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 serve-index/package.json000066600000001507150432033150011266 0ustar00{ "name": "@types/serve-index", "version": "1.9.1", "description": "TypeScript definitions for serve-index", "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/serve-index", "license": "MIT", "contributors": [ { "name": "Tanguy Krotoff", "url": "https://github.com/tkrotoff", "githubUsername": "tkrotoff" } ], "main": "", "types": "index.d.ts", "repository": { "type": "git", "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git", "directory": "types/serve-index" }, "scripts": {}, "dependencies": { "@types/express": "*" }, "typesPublisherContentHash": "14036a52b61d5326a23e498434889cb337bebd08a9e1ae3f609c099255155afd", "typeScriptVersion": "3.6" }babel__template/README.md000066600000001503150432033150011121 0ustar00# Installation > `npm install --save @types/babel__template` # Summary This package contains type definitions for @babel/template (https://github.com/babel/babel/tree/master/packages/babel-template). # Details Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/babel__template. ### Additional Details * Last updated: Tue, 06 Jul 2021 18:05:41 GMT * Dependencies: [@types/babel__parser](https://npmjs.com/package/@types/babel__parser), [@types/babel__types](https://npmjs.com/package/@types/babel__types) * Global values: none # Credits These definitions were written by [Troy Gerwien](https://github.com/yortus), [Marvin Hagemeister](https://github.com/marvinhagemeister), [Melvin Groenhoff](https://github.com/mgroenhoff), and [ExE Boss](https://github.com/ExE-Boss). babel__template/index.d.ts000066600000007020150432033150011543 0ustar00// Type definitions for @babel/template 7.4 // Project: https://github.com/babel/babel/tree/master/packages/babel-template, https://babeljs.io // Definitions by: Troy Gerwien // Marvin Hagemeister // Melvin Groenhoff // ExE Boss // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped import { ParserOptions } from '@babel/parser'; import { Expression, Program, Statement } from '@babel/types'; export interface TemplateBuilderOptions extends ParserOptions { /** * A set of placeholder names to automatically accept. * Items in this list do not need to match `placeholderPattern`. * * This option cannot be used when using `%%foo%%` style placeholders. */ placeholderWhitelist?: Set | null | undefined; /** * A pattern to search for when looking for `Identifier` and `StringLiteral` * nodes that should be considered as placeholders. * * `false` will disable placeholder searching placeholders, leaving only * the `placeholderWhitelist` value to find replacements. * * This option cannot be used when using `%%foo%%` style placeholders. * * @default /^[_$A-Z0-9]+$/ */ placeholderPattern?: RegExp | false | null | undefined; /** * Set this to `true` to preserve comments from the template string * into the resulting AST, or `false` to automatically discard comments. * * @default false */ preserveComments?: boolean | null | undefined; /** * Set to `true` to use `%%foo%%` style placeholders, `false` to use legacy placeholders * described by `placeholderPattern` or `placeholderWhitelist`. * * When it is not set, it behaves as `true` if there are syntactic placeholders, otherwise as `false`. * * @since 7.4.0 */ syntacticPlaceholders?: boolean | null | undefined; } export interface TemplateBuilder { /** * Build a new builder, merging the given options with the previous ones. */ (opts: TemplateBuilderOptions): TemplateBuilder; /** * Building from a string produces an AST builder function by default. */ (code: string, opts?: TemplateBuilderOptions): (arg?: PublicReplacements) => T; /** * Building from a template literal produces an AST builder function by default. */ (tpl: TemplateStringsArray, ...args: unknown[]): (arg?: PublicReplacements) => T; /** * Allow users to explicitly create templates that produce ASTs, * skipping the need for an intermediate function. * * Does not allow `%%foo%%` style placeholders. */ ast: { (tpl: string, opts?: TemplateBuilderOptions): T; (tpl: TemplateStringsArray, ...args: unknown[]): T; }; } export type PublicReplacements = { [index: string]: unknown } | unknown[]; export const smart: TemplateBuilder; export const statement: TemplateBuilder; export const statements: TemplateBuilder; export const expression: TemplateBuilder; export const program: TemplateBuilder; type DefaultTemplateBuilder = typeof smart & { smart: typeof smart; statement: typeof statement; statements: typeof statements; expression: typeof expression; program: typeof program; ast: typeof smart.ast; }; declare const templateBuilder: DefaultTemplateBuilder; export default templateBuilder; babel__template/LICENSE000066600000002165150432033150010654 0ustar00 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 babel__template/package.json000066600000002517150432033150012136 0ustar00{ "name": "@types/babel__template", "version": "7.4.1", "description": "TypeScript definitions for @babel/template", "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/babel__template", "license": "MIT", "contributors": [ { "name": "Troy Gerwien", "url": "https://github.com/yortus", "githubUsername": "yortus" }, { "name": "Marvin Hagemeister", "url": "https://github.com/marvinhagemeister", "githubUsername": "marvinhagemeister" }, { "name": "Melvin Groenhoff", "url": "https://github.com/mgroenhoff", "githubUsername": "mgroenhoff" }, { "name": "ExE Boss", "url": "https://github.com/ExE-Boss", "githubUsername": "ExE-Boss" } ], "main": "", "types": "index.d.ts", "repository": { "type": "git", "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git", "directory": "types/babel__template" }, "scripts": {}, "dependencies": { "@babel/parser": "^7.1.0", "@babel/types": "^7.0.0" }, "typesPublisherContentHash": "8b488d3b882af8da43e3bb35fc9efcf3bd5fdaec465b98ed620d47b2231b62ed", "typeScriptVersion": "3.6" }parse-json/README.md000066600000000760150432033150010107 0ustar00# Installation > `npm install --save @types/parse-json` # Summary This package contains type definitions for parse-json (https://github.com/sindresorhus/parse-json). # Details Files were exported from https://www.github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/parse-json Additional Details * Last updated: Tue, 14 Nov 2017 00:30:05 GMT * Dependencies: none * Global values: none # Credits These definitions were written by mrmlnc . parse-json/index.d.ts000066600000000662150432033150010532 0ustar00// Type definitions for parse-json 4.0 // Project: https://github.com/sindresorhus/parse-json // Definitions by: mrmlnc // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped declare function parseJson(input: string | null, filepath?: string): any; declare function parseJson(input: string | null, reviver: (key: any, value: any) => any, filepath?: string): any; export = parseJson; parse-json/LICENSE000066600000002237150432033150007636 0ustar00 MIT License Copyright (c) Microsoft Corporation. All rights reserved. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE parse-json/package.json000066600000001161150432033150011112 0ustar00{ "name": "@types/parse-json", "version": "4.0.0", "description": "TypeScript definitions for parse-json", "license": "MIT", "contributors": [ { "name": "mrmlnc", "url": "https://github.com/mrmlnc", "githubUsername": "mrmlnc" } ], "main": "", "repository": { "type": "git", "url": "https://www.github.com/DefinitelyTyped/DefinitelyTyped.git" }, "scripts": {}, "dependencies": {}, "typesPublisherContentHash": "68b3120a3ffa0ae0c978a90b74a1e50adc0340a9d11f17cc1efb7bf2186e7751", "typeScriptVersion": "2.0" }imagemin-svgo/README.md000066600000001273150432033150010570 0ustar00# Installation > `npm install --save @types/imagemin-svgo` # Summary This package contains type definitions for imagemin-svgo (https://github.com/imagemin/imagemin-svgo#readme). # Details Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/imagemin-svgo. ### Additional Details * Last updated: Sun, 07 Mar 2021 10:09:12 GMT * Dependencies: [@types/svgo](https://npmjs.com/package/@types/svgo), [@types/imagemin](https://npmjs.com/package/@types/imagemin) * Global values: none # Credits These definitions were written by [Romain Faust](https://github.com/romain-faust), and [Piotr Błażejewicz](https://github.com/peterblazejewicz). imagemin-svgo/index.d.ts000066600000001120150432033150011201 0ustar00// Type definitions for imagemin-svgo 8.0 // Project: https://github.com/imagemin/imagemin-svgo#readme // Definitions by: Romain Faust // Piotr Błażejewicz // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped import { Plugin } from 'imagemin'; import { Options as SvgoOptions } from 'svgo'; /** * SVGO imagemin plugin */ declare function imageminSvgo(options?: imageminSvgo.Options): Plugin; declare namespace imageminSvgo { type Options = SvgoOptions; } export = imageminSvgo; imagemin-svgo/LICENSE000066600000002165150432033150010317 0ustar00 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 imagemin-svgo/package.json000066600000001670150432033150011600 0ustar00{ "name": "@types/imagemin-svgo", "version": "8.0.1", "description": "TypeScript definitions for imagemin-svgo", "license": "MIT", "contributors": [ { "name": "Romain Faust", "url": "https://github.com/romain-faust", "githubUsername": "romain-faust" }, { "name": "Piotr Błażejewicz", "url": "https://github.com/peterblazejewicz", "githubUsername": "peterblazejewicz" } ], "main": "", "types": "index.d.ts", "repository": { "type": "git", "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git", "directory": "types/imagemin-svgo" }, "scripts": {}, "dependencies": { "@types/imagemin": "*", "@types/svgo": "^1" }, "typesPublisherContentHash": "e1aaa696ba0d69c1db2211228694de895b78f42c78dc496d7b8c107b63148c02", "typeScriptVersion": "3.5" }babel__traverse/README.md000066600000001643150432033150011146 0ustar00# Installation > `npm install --save @types/babel__traverse` # Summary This package contains type definitions for @babel/traverse (https://github.com/babel/babel/tree/main/packages/babel-traverse). # Details Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/babel__traverse. ### Additional Details * Last updated: Mon, 28 Nov 2022 17:02:52 GMT * Dependencies: [@types/babel__types](https://npmjs.com/package/@types/babel__types) * Global values: none # Credits These definitions were written by [Troy Gerwien](https://github.com/yortus), [Marvin Hagemeister](https://github.com/marvinhagemeister), [Ryan Petrich](https://github.com/rpetrich), [Melvin Groenhoff](https://github.com/mgroenhoff), [Dean L.](https://github.com/dlgrit), [Ifiok Jr.](https://github.com/ifiokjr), [ExE Boss](https://github.com/ExE-Boss), and [Daniel Tschinder](https://github.com/danez). babel__traverse/index.d.ts000066600000167410150432033150011575 0ustar00// Type definitions for @babel/traverse 7.18 // Project: https://github.com/babel/babel/tree/main/packages/babel-traverse, https://babeljs.io // Definitions by: Troy Gerwien // Marvin Hagemeister // Ryan Petrich // Melvin Groenhoff // Dean L. // Ifiok Jr. // ExE Boss // Daniel Tschinder // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped import * as t from '@babel/types'; export import Node = t.Node; declare const traverse: { ( parent: Node | Node[] | null | undefined, opts: TraverseOptions, scope: Scope | undefined, state: S, parentPath?: NodePath, ): void; ( parent: Node | Node[] | null | undefined, opts?: TraverseOptions, scope?: Scope, state?: any, parentPath?: NodePath, ): void; visitors: typeof visitors; verify: typeof visitors.verify; explode: typeof visitors.explode; }; export namespace visitors { /** * `explode()` will take a `Visitor` object with all of the various shorthands * that we support, and validates & normalizes it into a common format, ready * to be used in traversal. * * The various shorthands are: * - `Identifier() { ... }` -> `Identifier: { enter() { ... } }` * - `"Identifier|NumericLiteral": { ... }` -> `Identifier: { ... }, NumericLiteral: { ... }` * - Aliases in `@babel/types`: e.g. `Property: { ... }` -> `ObjectProperty: { ... }, ClassProperty: { ... }` * * Other normalizations are: * - Visitors of virtual types are wrapped, so that they are only visited when their dynamic check passes * - `enter` and `exit` functions are wrapped in arrays, to ease merging of visitors */ function explode( visitor: Visitor, ): { [Type in Node['type']]?: VisitNodeObject>; }; function verify(visitor: Visitor): void; function merge(visitors: Array>, states?: S[]): Visitor; } export default traverse; export interface TraverseOptions extends Visitor { scope?: Scope | undefined; noScope?: boolean | undefined; } export type ArrayKeys = keyof { [P in keyof T as T[P] extends any[] ? P : never]: P }; export class Scope { constructor(path: NodePath, parentScope?: Scope); path: NodePath; block: Node; parentBlock: Node; parent: Scope; hub: HubInterface; bindings: { [name: string]: Binding }; /** Traverse node with current scope and path. */ traverse(node: Node | Node[], opts: TraverseOptions, state: S): void; traverse(node: Node | Node[], opts?: TraverseOptions, state?: any): void; /** Generate a unique identifier and add it to the current scope. */ generateDeclaredUidIdentifier(name?: string): t.Identifier; /** Generate a unique identifier. */ generateUidIdentifier(name?: string): t.Identifier; /** Generate a unique `_id1` binding. */ generateUid(name?: string): string; /** Generate a unique identifier based on a node. */ generateUidIdentifierBasedOnNode(parent: Node, defaultName?: string): t.Identifier; /** * Determine whether evaluating the specific input `node` is a consequenceless reference. ie. * evaluating it wont result in potentially arbitrary code from being ran. The following are * whitelisted and determined not to cause side effects: * * - `this` expressions * - `super` expressions * - Bound identifiers */ isStatic(node: Node): boolean; /** Possibly generate a memoised identifier if it is not static and has consequences. */ maybeGenerateMemoised(node: Node, dontPush?: boolean): t.Identifier; checkBlockScopedCollisions(local: Binding, kind: BindingKind, name: string, id: object): void; rename(oldName: string, newName?: string, block?: Node): void; dump(): void; toArray(node: Node, i?: number): Node; registerDeclaration(path: NodePath): void; buildUndefinedNode(): Node; registerConstantViolation(path: NodePath): void; registerBinding(kind: string, path: NodePath, bindingPath?: NodePath): void; addGlobal(node: Node): void; hasUid(name: string): boolean; hasGlobal(name: string): boolean; hasReference(name: string): boolean; isPure(node: Node, constantsOnly?: boolean): boolean; setData(key: string, val: any): any; getData(key: string): any; removeData(key: string): void; crawl(): void; push(opts: { id: t.LVal; init?: t.Expression | undefined; unique?: boolean | undefined; kind?: 'var' | 'let' | 'const' | undefined; }): void; getProgramParent(): Scope; getFunctionParent(): Scope | null; getBlockParent(): Scope; /** Walks the scope tree and gathers **all** bindings. */ getAllBindings(...kinds: string[]): object; bindingIdentifierEquals(name: string, node: Node): boolean; getBinding(name: string): Binding | undefined; getOwnBinding(name: string): Binding | undefined; getBindingIdentifier(name: string): t.Identifier; getOwnBindingIdentifier(name: string): t.Identifier; hasOwnBinding(name: string): boolean; hasBinding(name: string, noGlobals?: boolean): boolean; parentHasBinding(name: string, noGlobals?: boolean): boolean; /** Move a binding of `name` to another `scope`. */ moveBindingTo(name: string, scope: Scope): void; removeOwnBinding(name: string): void; removeBinding(name: string): void; } export type BindingKind = 'var' | 'let' | 'const' | 'module' | 'hoisted' | 'param' | 'local' | 'unknown'; export class Binding { constructor(opts: { identifier: t.Identifier; scope: Scope; path: NodePath; kind: BindingKind }); identifier: t.Identifier; scope: Scope; path: NodePath; kind: BindingKind; referenced: boolean; references: number; referencePaths: NodePath[]; constant: boolean; constantViolations: NodePath[]; hasDeoptedValue?: boolean; hasValue?: boolean; value?: any; deopValue(): void; setValue(value: any): void; clearValue(): void; reassign(path: NodePath): void; reference(path: NodePath): void; dereference(): void; } export type Visitor = VisitNodeObject & { [Type in Node['type']]?: VisitNode>; } & { [K in keyof t.Aliases]?: VisitNode; }; export type VisitNode = VisitNodeFunction | VisitNodeObject; export type VisitNodeFunction = (this: S, path: NodePath

, state: S) => void; type NodeType = Node['type'] | keyof t.Aliases; export interface VisitNodeObject { enter?: VisitNodeFunction | undefined; exit?: VisitNodeFunction | undefined; denylist?: NodeType[] | undefined; /** * @deprecated will be removed in Babel 8 */ blacklist?: NodeType[] | undefined; } export type NodePaths = T extends readonly Node[] ? { -readonly [K in keyof T]: NodePath> } : T extends Node ? [NodePath] : never; export class NodePath { constructor(hub: Hub, parent: Node); parent: Node; hub: Hub; contexts: TraversalContext[]; data: object; shouldSkip: boolean; shouldStop: boolean; removed: boolean; state: any; opts: object; skipKeys: object; parentPath: T extends t.Program ? null : NodePath; context: TraversalContext; container: object | object[]; listKey: string; inList: boolean; parentKey: string; key: string | number; node: T; scope: Scope; type: T extends null | undefined ? undefined : T extends Node ? T['type'] : string | undefined; typeAnnotation: object; getScope(scope: Scope): Scope; setData(key: string, val: any): any; getData(key: string, def?: any): any; hasNode(): this is NodePath>; buildCodeFrameError(msg: string, Error?: new (msg: string) => TError): TError; traverse(visitor: Visitor, state: T): void; traverse(visitor: Visitor): void; set(key: string, node: Node): void; getPathLocation(): string; // Example: https://github.com/babel/babel/blob/63204ae51e020d84a5b246312f5eeb4d981ab952/packages/babel-traverse/src/path/modification.js#L83 debug(buildMessage: () => string): void; static get(opts: { hub: HubInterface; parentPath: NodePath | null; parent: Node; container: C; listKey?: string | undefined; key: K; }): NodePath; //#region ------------------------- ancestry ------------------------- /** * Starting at the parent path of the current `NodePath` and going up the * tree, return the first `NodePath` that causes the provided `callback` * to return a truthy value, or `null` if the `callback` never returns a * truthy value. */ findParent(callback: (path: NodePath) => boolean): NodePath | null; /** * Starting at current `NodePath` and going up the tree, return the first * `NodePath` that causes the provided `callback` to return a truthy value, * or `null` if the `callback` never returns a truthy value. */ find(callback: (path: NodePath) => boolean): NodePath | null; /** Get the parent function of the current path. */ getFunctionParent(): NodePath | null; /** Walk up the tree until we hit a parent node path in a list. */ getStatementParent(): NodePath | null; /** * Get the deepest common ancestor and then from it, get the earliest relationship path * to that ancestor. * * Earliest is defined as being "before" all the other nodes in terms of list container * position and visiting key. */ getEarliestCommonAncestorFrom(paths: NodePath[]): NodePath; /** Get the earliest path in the tree where the provided `paths` intersect. */ getDeepestCommonAncestorFrom( paths: NodePath[], filter?: (deepest: Node, i: number, ancestries: NodePath[]) => NodePath, ): NodePath; /** * Build an array of node paths containing the entire ancestry of the current node path. * * NOTE: The current node path is included in this. */ getAncestry(): [this, ...NodePath[]]; /** * A helper to find if `this` path is an ancestor of `maybeDescendant` */ isAncestor(maybeDescendant: NodePath): boolean; /** * A helper to find if `this` path is a descendant of `maybeAncestor` */ isDescendant(maybeAncestor: NodePath): boolean; inType(...candidateTypes: string[]): boolean; //#endregion //#region ------------------------- inference ------------------------- /** Infer the type of the current `NodePath`. */ getTypeAnnotation(): t.FlowType; isBaseType(baseName: string, soft?: boolean): boolean; couldBeBaseType(name: string): boolean; baseTypeStrictlyMatches(right: NodePath): boolean; isGenericType(genericName: string): boolean; //#endregion //#region ------------------------- replacement ------------------------- /** * Replace a node with an array of multiple. This method performs the following steps: * * - Inherit the comments of first provided node with that of the current node. * - Insert the provided nodes after the current node. * - Remove the current node. */ replaceWithMultiple(nodes: Nodes): NodePaths; /** * Parse a string as an expression and replace the current node with the result. * * NOTE: This is typically not a good idea to use. Building source strings when * transforming ASTs is an antipattern and SHOULD NOT be encouraged. Even if it's * easier to use, your transforms will be extremely brittle. */ replaceWithSourceString(replacement: any): [NodePath]; /** Replace the current node with another. */ replaceWith(replacement: T | NodePath): [NodePath]; /** * This method takes an array of statements nodes and then explodes it * into expressions. This method retains completion records which is * extremely important to retain original semantics. */ replaceExpressionWithStatements(nodes: Nodes): NodePaths; replaceInline(nodes: Nodes): NodePaths; //#endregion //#region ------------------------- evaluation ------------------------- /** * Walk the input `node` and statically evaluate if it's truthy. * * Returning `true` when we're sure that the expression will evaluate to a * truthy value, `false` if we're sure that it will evaluate to a falsy * value and `undefined` if we aren't sure. Because of this please do not * rely on coercion when using this method and check with === if it's false. */ evaluateTruthy(): boolean; /** * Walk the input `node` and statically evaluate it. * * Returns an object in the form `{ confident, value }`. `confident` indicates * whether or not we had to drop out of evaluating the expression because of * hitting an unknown node that we couldn't confidently find the value of. * * Example: * * t.evaluate(parse("5 + 5")) // { confident: true, value: 10 } * t.evaluate(parse("!true")) // { confident: true, value: false } * t.evaluate(parse("foo + foo")) // { confident: false, value: undefined } */ evaluate(): { confident: boolean; value: any }; //#endregion //#region ------------------------- introspection ------------------------- /** * Match the current node if it matches the provided `pattern`. * * For example, given the match `React.createClass` it would match the * parsed nodes of `React.createClass` and `React["createClass"]`. */ matchesPattern(pattern: string, allowPartial?: boolean): boolean; /** * Check whether we have the input `key`. If the `key` references an array then we check * if the array has any items, otherwise we just check if it's falsy. */ has(key: string): boolean; isStatic(): boolean; /** Alias of `has`. */ is(key: string): boolean; /** Opposite of `has`. */ isnt(key: string): boolean; /** Check whether the path node `key` strict equals `value`. */ equals(key: string, value: any): boolean; /** * Check the type against our stored internal type of the node. This is handy when a node has * been removed yet we still internally know the type and need it to calculate node replacement. */ isNodeType(type: string): boolean; /** * This checks whether or not we're in one of the following positions: * * for (KEY in right); * for (KEY;;); * * This is because these spots allow VariableDeclarations AND normal expressions so we need * to tell the path replacement that it's ok to replace this with an expression. */ canHaveVariableDeclarationOrExpression(): boolean; /** * This checks whether we are swapping an arrow function's body between an * expression and a block statement (or vice versa). * * This is because arrow functions may implicitly return an expression, which * is the same as containing a block statement. */ canSwapBetweenExpressionAndStatement(replacement: Node): boolean; /** Check whether the current path references a completion record */ isCompletionRecord(allowInsideFunction?: boolean): boolean; /** * Check whether or not the current `key` allows either a single statement or block statement * so we can explode it if necessary. */ isStatementOrBlock(): boolean; /** Check if the currently assigned path references the `importName` of `moduleSource`. */ referencesImport(moduleSource: string, importName: string): boolean; /** Get the source code associated with this node. */ getSource(): string; /** Check if the current path will maybe execute before another path */ willIMaybeExecuteBefore(path: NodePath): boolean; //#endregion //#region ------------------------- context ------------------------- call(key: string): boolean; isBlacklisted(): boolean; visit(): boolean; skip(): void; skipKey(key: string): void; stop(): void; setScope(): void; setContext(context?: TraversalContext): this; popContext(): void; pushContext(context: TraversalContext): void; //#endregion //#region ------------------------- removal ------------------------- remove(): void; //#endregion //#region ------------------------- modification ------------------------- /** Insert the provided nodes before the current one. */ insertBefore(nodes: Nodes): NodePaths; /** * Insert the provided nodes after the current one. When inserting nodes after an * expression, ensure that the completion record is correct by pushing the current node. */ insertAfter(nodes: Nodes): NodePaths; /** Update all sibling node paths after `fromIndex` by `incrementBy`. */ updateSiblingKeys(fromIndex: number, incrementBy: number): void; /** * Insert child nodes at the start of the current node. * @param listKey - The key at which the child nodes are stored (usually body). * @param nodes - the nodes to insert. */ unshiftContainer(listKey: ArrayKeys, nodes: Nodes): NodePaths; /** * Insert child nodes at the end of the current node. * @param listKey - The key at which the child nodes are stored (usually body). * @param nodes - the nodes to insert. */ pushContainer(listKey: ArrayKeys, nodes: Nodes): NodePaths; /** Hoist the current node to the highest scope possible and return a UID referencing it. */ hoist(scope: Scope): void; //#endregion //#region ------------------------- family ------------------------- getOpposite(): NodePath; getCompletionRecords(): NodePath[]; getSibling(key: string | number): NodePath; getPrevSibling(): NodePath; getNextSibling(): NodePath; getAllPrevSiblings(): NodePath[]; getAllNextSiblings(): NodePath[]; get(key: K, context?: boolean | TraversalContext): NodePathResult; get(key: string, context?: boolean | TraversalContext): NodePath | NodePath[]; getBindingIdentifiers(duplicates: true): Record; getBindingIdentifiers(duplicates?: false): Record; getBindingIdentifiers(duplicates?: boolean): Record; getOuterBindingIdentifiers(duplicates: true): Record; getOuterBindingIdentifiers(duplicates?: false): Record; getOuterBindingIdentifiers(duplicates?: boolean): Record; getBindingIdentifierPaths(duplicates: true, outerOnly?: boolean): Record>>; getBindingIdentifierPaths(duplicates?: false, outerOnly?: boolean): Record>; getBindingIdentifierPaths( duplicates?: boolean, outerOnly?: boolean, ): Record | Array>>; getOuterBindingIdentifierPaths(duplicates: true): Record>>; getOuterBindingIdentifierPaths(duplicates?: false): Record>; getOuterBindingIdentifierPaths( duplicates?: boolean, outerOnly?: boolean, ): Record | Array>>; //#endregion //#region ------------------------- comments ------------------------- /** Share comments amongst siblings. */ shareCommentsWithSiblings(): void; addComment(type: string, content: string, line?: boolean): void; /** Give node `comments` of the specified `type`. */ addComments(type: string, comments: any[]): void; //#endregion //#region ------------------------- isXXX ------------------------- isAnyTypeAnnotation(props?: object | null): this is NodePath; isArrayExpression(props?: object | null): this is NodePath; isArrayPattern(props?: object | null): this is NodePath; isArrayTypeAnnotation(props?: object | null): this is NodePath; isArrowFunctionExpression(props?: object | null): this is NodePath; isAssignmentExpression(props?: object | null): this is NodePath; isAssignmentPattern(props?: object | null): this is NodePath; isAwaitExpression(props?: object | null): this is NodePath; isBigIntLiteral(props?: object | null): this is NodePath; isBinary(props?: object | null): this is NodePath; isBinaryExpression(props?: object | null): this is NodePath; isBindExpression(props?: object | null): this is NodePath; isBlock(props?: object | null): this is NodePath; isBlockParent(props?: object | null): this is NodePath; isBlockStatement(props?: object | null): this is NodePath; isBooleanLiteral(props?: object | null): this is NodePath; isBooleanLiteralTypeAnnotation(props?: object | null): this is NodePath; isBooleanTypeAnnotation(props?: object | null): this is NodePath; isBreakStatement(props?: object | null): this is NodePath; isCallExpression(props?: object | null): this is NodePath; isCatchClause(props?: object | null): this is NodePath; isClass(props?: object | null): this is NodePath; isClassBody(props?: object | null): this is NodePath; isClassDeclaration(props?: object | null): this is NodePath; isClassExpression(props?: object | null): this is NodePath; isClassImplements(props?: object | null): this is NodePath; isClassMethod(props?: object | null): this is NodePath; isClassPrivateMethod(props?: object | null): this is NodePath; isClassPrivateProperty(props?: object | null): this is NodePath; isClassProperty(props?: object | null): this is NodePath; isCompletionStatement(props?: object | null): this is NodePath; isConditional(props?: object | null): this is NodePath; isConditionalExpression(props?: object | null): this is NodePath; isContinueStatement(props?: object | null): this is NodePath; isDebuggerStatement(props?: object | null): this is NodePath; isDeclaration(props?: object | null): this is NodePath; isDeclareClass(props?: object | null): this is NodePath; isDeclareExportAllDeclaration(props?: object | null): this is NodePath; isDeclareExportDeclaration(props?: object | null): this is NodePath; isDeclareFunction(props?: object | null): this is NodePath; isDeclareInterface(props?: object | null): this is NodePath; isDeclareModule(props?: object | null): this is NodePath; isDeclareModuleExports(props?: object | null): this is NodePath; isDeclareOpaqueType(props?: object | null): this is NodePath; isDeclareTypeAlias(props?: object | null): this is NodePath; isDeclareVariable(props?: object | null): this is NodePath; isDeclaredPredicate(props?: object | null): this is NodePath; isDecorator(props?: object | null): this is NodePath; isDirective(props?: object | null): this is NodePath; isDirectiveLiteral(props?: object | null): this is NodePath; isDoExpression(props?: object | null): this is NodePath; isDoWhileStatement(props?: object | null): this is NodePath; isEmptyStatement(props?: object | null): this is NodePath; isEmptyTypeAnnotation(props?: object | null): this is NodePath; isExistsTypeAnnotation(props?: object | null): this is NodePath; isExportAllDeclaration(props?: object | null): this is NodePath; isExportDeclaration(props?: object | null): this is NodePath; isExportDefaultDeclaration(props?: object | null): this is NodePath; isExportDefaultSpecifier(props?: object | null): this is NodePath; isExportNamedDeclaration(props?: object | null): this is NodePath; isExportNamespaceSpecifier(props?: object | null): this is NodePath; isExportSpecifier(props?: object | null): this is NodePath; isExpression(props?: object | null): this is NodePath; isExpressionStatement(props?: object | null): this is NodePath; isExpressionWrapper(props?: object | null): this is NodePath; isFile(props?: object | null): this is NodePath; isFlow(props?: object | null): this is NodePath; isFlowBaseAnnotation(props?: object | null): this is NodePath; isFlowDeclaration(props?: object | null): this is NodePath; isFlowPredicate(props?: object | null): this is NodePath; isFlowType(props?: object | null): this is NodePath; isFor(props?: object | null): this is NodePath; isForInStatement(props?: object | null): this is NodePath; isForOfStatement(props?: object | null): this is NodePath; isForStatement(props?: object | null): this is NodePath; isForXStatement(props?: object | null): this is NodePath; isFunction(props?: object | null): this is NodePath; isFunctionDeclaration(props?: object | null): this is NodePath; isFunctionExpression(props?: object | null): this is NodePath; isFunctionParent(props?: object | null): this is NodePath; isFunctionTypeAnnotation(props?: object | null): this is NodePath; isFunctionTypeParam(props?: object | null): this is NodePath; isGenericTypeAnnotation(props?: object | null): this is NodePath; isIdentifier(props?: object | null): this is NodePath; isIfStatement(props?: object | null): this is NodePath; isImmutable(props?: object | null): this is NodePath; isImport(props?: object | null): this is NodePath; isImportDeclaration(props?: object | null): this is NodePath; isImportDefaultSpecifier(props?: object | null): this is NodePath; isImportNamespaceSpecifier(props?: object | null): this is NodePath; isImportSpecifier(props?: object | null): this is NodePath; isInferredPredicate(props?: object | null): this is NodePath; isInterfaceDeclaration(props?: object | null): this is NodePath; isInterfaceExtends(props?: object | null): this is NodePath; isInterfaceTypeAnnotation(props?: object | null): this is NodePath; isInterpreterDirective(props?: object | null): this is NodePath; isIntersectionTypeAnnotation(props?: object | null): this is NodePath; isJSX(props?: object | null): this is NodePath; isJSXAttribute(props?: object | null): this is NodePath; isJSXClosingElement(props?: object | null): this is NodePath; isJSXClosingFragment(props?: object | null): this is NodePath; isJSXElement(props?: object | null): this is NodePath; isJSXEmptyExpression(props?: object | null): this is NodePath; isJSXExpressionContainer(props?: object | null): this is NodePath; isJSXFragment(props?: object | null): this is NodePath; isJSXIdentifier(props?: object | null): this is NodePath; isJSXMemberExpression(props?: object | null): this is NodePath; isJSXNamespacedName(props?: object | null): this is NodePath; isJSXOpeningElement(props?: object | null): this is NodePath; isJSXOpeningFragment(props?: object | null): this is NodePath; isJSXSpreadAttribute(props?: object | null): this is NodePath; isJSXSpreadChild(props?: object | null): this is NodePath; isJSXText(props?: object | null): this is NodePath; isLVal(props?: object | null): this is NodePath; isLabeledStatement(props?: object | null): this is NodePath; isLiteral(props?: object | null): this is NodePath; isLogicalExpression(props?: object | null): this is NodePath; isLoop(props?: object | null): this is NodePath; isMemberExpression(props?: object | null): this is NodePath; isMetaProperty(props?: object | null): this is NodePath; isMethod(props?: object | null): this is NodePath; isMixedTypeAnnotation(props?: object | null): this is NodePath; isModuleDeclaration(props?: object | null): this is NodePath; isModuleSpecifier(props?: object | null): this is NodePath; isNewExpression(props?: object | null): this is NodePath; isNoop(props?: object | null): this is NodePath; isNullLiteral(props?: object | null): this is NodePath; isNullLiteralTypeAnnotation(props?: object | null): this is NodePath; isNullableTypeAnnotation(props?: object | null): this is NodePath; /** @deprecated Use `isNumericLiteral` */ isNumberLiteral(props?: object | null): this is NodePath; isNumberLiteralTypeAnnotation(props?: object | null): this is NodePath; isNumberTypeAnnotation(props?: object | null): this is NodePath; isNumericLiteral(props?: object | null): this is NodePath; isObjectExpression(props?: object | null): this is NodePath; isObjectMember(props?: object | null): this is NodePath; isObjectMethod(props?: object | null): this is NodePath; isObjectPattern(props?: object | null): this is NodePath; isObjectProperty(props?: object | null): this is NodePath; isObjectTypeAnnotation(props?: object | null): this is NodePath; isObjectTypeCallProperty(props?: object | null): this is NodePath; isObjectTypeIndexer(props?: object | null): this is NodePath; isObjectTypeInternalSlot(props?: object | null): this is NodePath; isObjectTypeProperty(props?: object | null): this is NodePath; isObjectTypeSpreadProperty(props?: object | null): this is NodePath; isOpaqueType(props?: object | null): this is NodePath; isOptionalCallExpression(props?: object | null): this is NodePath; isOptionalMemberExpression(props?: object | null): this is NodePath; isParenthesizedExpression(props?: object | null): this is NodePath; isPattern(props?: object | null): this is NodePath; isPatternLike(props?: object | null): this is NodePath; isPipelineBareFunction(props?: object | null): this is NodePath; isPipelinePrimaryTopicReference(props?: object | null): this is NodePath; isPipelineTopicExpression(props?: object | null): this is NodePath; isPrivate(props?: object | null): this is NodePath; isPrivateName(props?: object | null): this is NodePath; isProgram(props?: object | null): this is NodePath; isProperty(props?: object | null): this is NodePath; isPureish(props?: object | null): this is NodePath; isQualifiedTypeIdentifier(props?: object | null): this is NodePath; isRegExpLiteral(props?: object | null): this is NodePath; /** @deprecated Use `isRegExpLiteral` */ isRegexLiteral(props?: object | null): this is NodePath; isRestElement(props?: object | null): this is NodePath; /** @deprecated Use `isRestElement` */ isRestProperty(props?: object | null): this is NodePath; isReturnStatement(props?: object | null): this is NodePath; isScopable(props?: object | null): this is NodePath; isSequenceExpression(props?: object | null): this is NodePath; isSpreadElement(props?: object | null): this is NodePath; /** @deprecated Use `isSpreadElement` */ isSpreadProperty(props?: object | null): this is NodePath; isStatement(props?: object | null): this is NodePath; isStringLiteral(props?: object | null): this is NodePath; isStringLiteralTypeAnnotation(props?: object | null): this is NodePath; isStringTypeAnnotation(props?: object | null): this is NodePath; isSuper(props?: object | null): this is NodePath; isSwitchCase(props?: object | null): this is NodePath; isSwitchStatement(props?: object | null): this is NodePath; isTSAnyKeyword(props?: object | null): this is NodePath; isTSArrayType(props?: object | null): this is NodePath; isTSAsExpression(props?: object | null): this is NodePath; isTSBooleanKeyword(props?: object | null): this is NodePath; isTSCallSignatureDeclaration(props?: object | null): this is NodePath; isTSConditionalType(props?: object | null): this is NodePath; isTSConstructSignatureDeclaration(props?: object | null): this is NodePath; isTSConstructorType(props?: object | null): this is NodePath; isTSDeclareFunction(props?: object | null): this is NodePath; isTSDeclareMethod(props?: object | null): this is NodePath; isTSEntityName(props?: object | null): this is NodePath; isTSEnumDeclaration(props?: object | null): this is NodePath; isTSEnumMember(props?: object | null): this is NodePath; isTSExportAssignment(props?: object | null): this is NodePath; isTSExpressionWithTypeArguments(props?: object | null): this is NodePath; isTSExternalModuleReference(props?: object | null): this is NodePath; isTSFunctionType(props?: object | null): this is NodePath; isTSImportEqualsDeclaration(props?: object | null): this is NodePath; isTSImportType(props?: object | null): this is NodePath; isTSIndexSignature(props?: object | null): this is NodePath; isTSIndexedAccessType(props?: object | null): this is NodePath; isTSInferType(props?: object | null): this is NodePath; isTSInterfaceBody(props?: object | null): this is NodePath; isTSInterfaceDeclaration(props?: object | null): this is NodePath; isTSIntersectionType(props?: object | null): this is NodePath; isTSLiteralType(props?: object | null): this is NodePath; isTSMappedType(props?: object | null): this is NodePath; isTSMethodSignature(props?: object | null): this is NodePath; isTSModuleBlock(props?: object | null): this is NodePath; isTSModuleDeclaration(props?: object | null): this is NodePath; isTSNamespaceExportDeclaration(props?: object | null): this is NodePath; isTSNeverKeyword(props?: object | null): this is NodePath; isTSNonNullExpression(props?: object | null): this is NodePath; isTSNullKeyword(props?: object | null): this is NodePath; isTSNumberKeyword(props?: object | null): this is NodePath; isTSObjectKeyword(props?: object | null): this is NodePath; isTSOptionalType(props?: object | null): this is NodePath; isTSParameterProperty(props?: object | null): this is NodePath; isTSParenthesizedType(props?: object | null): this is NodePath; isTSPropertySignature(props?: object | null): this is NodePath; isTSQualifiedName(props?: object | null): this is NodePath; isTSRestType(props?: object | null): this is NodePath; isTSStringKeyword(props?: object | null): this is NodePath; isTSSymbolKeyword(props?: object | null): this is NodePath; isTSThisType(props?: object | null): this is NodePath; isTSTupleType(props?: object | null): this is NodePath; isTSType(props?: object | null): this is NodePath; isTSTypeAliasDeclaration(props?: object | null): this is NodePath; isTSTypeAnnotation(props?: object | null): this is NodePath; isTSTypeAssertion(props?: object | null): this is NodePath; isTSTypeElement(props?: object | null): this is NodePath; isTSTypeLiteral(props?: object | null): this is NodePath; isTSTypeOperator(props?: object | null): this is NodePath; isTSTypeParameter(props?: object | null): this is NodePath; isTSTypeParameterDeclaration(props?: object | null): this is NodePath; isTSTypeParameterInstantiation(props?: object | null): this is NodePath; isTSTypePredicate(props?: object | null): this is NodePath; isTSTypeQuery(props?: object | null): this is NodePath; isTSTypeReference(props?: object | null): this is NodePath; isTSUndefinedKeyword(props?: object | null): this is NodePath; isTSUnionType(props?: object | null): this is NodePath; isTSUnknownKeyword(props?: object | null): this is NodePath; isTSVoidKeyword(props?: object | null): this is NodePath; isTaggedTemplateExpression(props?: object | null): this is NodePath; isTemplateElement(props?: object | null): this is NodePath; isTemplateLiteral(props?: object | null): this is NodePath; isTerminatorless(props?: object | null): this is NodePath; isThisExpression(props?: object | null): this is NodePath; isThisTypeAnnotation(props?: object | null): this is NodePath; isThrowStatement(props?: object | null): this is NodePath; isTryStatement(props?: object | null): this is NodePath; isTupleTypeAnnotation(props?: object | null): this is NodePath; isTypeAlias(props?: object | null): this is NodePath; isTypeAnnotation(props?: object | null): this is NodePath; isTypeCastExpression(props?: object | null): this is NodePath; isTypeParameter(props?: object | null): this is NodePath; isTypeParameterDeclaration(props?: object | null): this is NodePath; isTypeParameterInstantiation(props?: object | null): this is NodePath; isTypeofTypeAnnotation(props?: object | null): this is NodePath; isUnaryExpression(props?: object | null): this is NodePath; isUnaryLike(props?: object | null): this is NodePath; isUnionTypeAnnotation(props?: object | null): this is NodePath; isUpdateExpression(props?: object | null): this is NodePath; isUserWhitespacable(props?: object | null): this is NodePath; isVariableDeclaration(props?: object | null): this is NodePath; isVariableDeclarator(props?: object | null): this is NodePath; isVariance(props?: object | null): this is NodePath; isVoidTypeAnnotation(props?: object | null): this is NodePath; isWhile(props?: object | null): this is NodePath; isWhileStatement(props?: object | null): this is NodePath; isWithStatement(props?: object | null): this is NodePath; isYieldExpression(props?: object | null): this is NodePath; isBindingIdentifier(props?: object | null): this is NodePath; isBlockScoped( props?: object | null, ): this is NodePath; isGenerated(props?: object | null): boolean; isPure(props?: object | null): boolean; isReferenced(props?: object | null): boolean; isReferencedIdentifier(props?: object | null): this is NodePath; isReferencedMemberExpression(props?: object | null): this is NodePath; isScope(props?: object | null): this is NodePath; isUser(props?: object | null): boolean; isVar(props?: object | null): this is NodePath; //#endregion //#region ------------------------- assertXXX ------------------------- assertAnyTypeAnnotation(props?: object | null): void; assertArrayExpression(props?: object | null): void; assertArrayPattern(props?: object | null): void; assertArrayTypeAnnotation(props?: object | null): void; assertArrowFunctionExpression(props?: object | null): void; assertAssignmentExpression(props?: object | null): void; assertAssignmentPattern(props?: object | null): void; assertAwaitExpression(props?: object | null): void; assertBigIntLiteral(props?: object | null): void; assertBinary(props?: object | null): void; assertBinaryExpression(props?: object | null): void; assertBindExpression(props?: object | null): void; assertBlock(props?: object | null): void; assertBlockParent(props?: object | null): void; assertBlockStatement(props?: object | null): void; assertBooleanLiteral(props?: object | null): void; assertBooleanLiteralTypeAnnotation(props?: object | null): void; assertBooleanTypeAnnotation(props?: object | null): void; assertBreakStatement(props?: object | null): void; assertCallExpression(props?: object | null): void; assertCatchClause(props?: object | null): void; assertClass(props?: object | null): void; assertClassBody(props?: object | null): void; assertClassDeclaration(props?: object | null): void; assertClassExpression(props?: object | null): void; assertClassImplements(props?: object | null): void; assertClassMethod(props?: object | null): void; assertClassPrivateMethod(props?: object | null): void; assertClassPrivateProperty(props?: object | null): void; assertClassProperty(props?: object | null): void; assertCompletionStatement(props?: object | null): void; assertConditional(props?: object | null): void; assertConditionalExpression(props?: object | null): void; assertContinueStatement(props?: object | null): void; assertDebuggerStatement(props?: object | null): void; assertDeclaration(props?: object | null): void; assertDeclareClass(props?: object | null): void; assertDeclareExportAllDeclaration(props?: object | null): void; assertDeclareExportDeclaration(props?: object | null): void; assertDeclareFunction(props?: object | null): void; assertDeclareInterface(props?: object | null): void; assertDeclareModule(props?: object | null): void; assertDeclareModuleExports(props?: object | null): void; assertDeclareOpaqueType(props?: object | null): void; assertDeclareTypeAlias(props?: object | null): void; assertDeclareVariable(props?: object | null): void; assertDeclaredPredicate(props?: object | null): void; assertDecorator(props?: object | null): void; assertDirective(props?: object | null): void; assertDirectiveLiteral(props?: object | null): void; assertDoExpression(props?: object | null): void; assertDoWhileStatement(props?: object | null): void; assertEmptyStatement(props?: object | null): void; assertEmptyTypeAnnotation(props?: object | null): void; assertExistsTypeAnnotation(props?: object | null): void; assertExportAllDeclaration(props?: object | null): void; assertExportDeclaration(props?: object | null): void; assertExportDefaultDeclaration(props?: object | null): void; assertExportDefaultSpecifier(props?: object | null): void; assertExportNamedDeclaration(props?: object | null): void; assertExportNamespaceSpecifier(props?: object | null): void; assertExportSpecifier(props?: object | null): void; assertExpression(props?: object | null): void; assertExpressionStatement(props?: object | null): void; assertExpressionWrapper(props?: object | null): void; assertFile(props?: object | null): void; assertFlow(props?: object | null): void; assertFlowBaseAnnotation(props?: object | null): void; assertFlowDeclaration(props?: object | null): void; assertFlowPredicate(props?: object | null): void; assertFlowType(props?: object | null): void; assertFor(props?: object | null): void; assertForInStatement(props?: object | null): void; assertForOfStatement(props?: object | null): void; assertForStatement(props?: object | null): void; assertForXStatement(props?: object | null): void; assertFunction(props?: object | null): void; assertFunctionDeclaration(props?: object | null): void; assertFunctionExpression(props?: object | null): void; assertFunctionParent(props?: object | null): void; assertFunctionTypeAnnotation(props?: object | null): void; assertFunctionTypeParam(props?: object | null): void; assertGenericTypeAnnotation(props?: object | null): void; assertIdentifier(props?: object | null): void; assertIfStatement(props?: object | null): void; assertImmutable(props?: object | null): void; assertImport(props?: object | null): void; assertImportDeclaration(props?: object | null): void; assertImportDefaultSpecifier(props?: object | null): void; assertImportNamespaceSpecifier(props?: object | null): void; assertImportSpecifier(props?: object | null): void; assertInferredPredicate(props?: object | null): void; assertInterfaceDeclaration(props?: object | null): void; assertInterfaceExtends(props?: object | null): void; assertInterfaceTypeAnnotation(props?: object | null): void; assertInterpreterDirective(props?: object | null): void; assertIntersectionTypeAnnotation(props?: object | null): void; assertJSX(props?: object | null): void; assertJSXAttribute(props?: object | null): void; assertJSXClosingElement(props?: object | null): void; assertJSXClosingFragment(props?: object | null): void; assertJSXElement(props?: object | null): void; assertJSXEmptyExpression(props?: object | null): void; assertJSXExpressionContainer(props?: object | null): void; assertJSXFragment(props?: object | null): void; assertJSXIdentifier(props?: object | null): void; assertJSXMemberExpression(props?: object | null): void; assertJSXNamespacedName(props?: object | null): void; assertJSXOpeningElement(props?: object | null): void; assertJSXOpeningFragment(props?: object | null): void; assertJSXSpreadAttribute(props?: object | null): void; assertJSXSpreadChild(props?: object | null): void; assertJSXText(props?: object | null): void; assertLVal(props?: object | null): void; assertLabeledStatement(props?: object | null): void; assertLiteral(props?: object | null): void; assertLogicalExpression(props?: object | null): void; assertLoop(props?: object | null): void; assertMemberExpression(props?: object | null): void; assertMetaProperty(props?: object | null): void; assertMethod(props?: object | null): void; assertMixedTypeAnnotation(props?: object | null): void; assertModuleDeclaration(props?: object | null): void; assertModuleSpecifier(props?: object | null): void; assertNewExpression(props?: object | null): void; assertNoop(props?: object | null): void; assertNullLiteral(props?: object | null): void; assertNullLiteralTypeAnnotation(props?: object | null): void; assertNullableTypeAnnotation(props?: object | null): void; /** @deprecated Use `assertNumericLiteral` */ assertNumberLiteral(props?: object | null): void; assertNumberLiteralTypeAnnotation(props?: object | null): void; assertNumberTypeAnnotation(props?: object | null): void; assertNumericLiteral(props?: object | null): void; assertObjectExpression(props?: object | null): void; assertObjectMember(props?: object | null): void; assertObjectMethod(props?: object | null): void; assertObjectPattern(props?: object | null): void; assertObjectProperty(props?: object | null): void; assertObjectTypeAnnotation(props?: object | null): void; assertObjectTypeCallProperty(props?: object | null): void; assertObjectTypeIndexer(props?: object | null): void; assertObjectTypeInternalSlot(props?: object | null): void; assertObjectTypeProperty(props?: object | null): void; assertObjectTypeSpreadProperty(props?: object | null): void; assertOpaqueType(props?: object | null): void; assertOptionalCallExpression(props?: object | null): void; assertOptionalMemberExpression(props?: object | null): void; assertParenthesizedExpression(props?: object | null): void; assertPattern(props?: object | null): void; assertPatternLike(props?: object | null): void; assertPipelineBareFunction(props?: object | null): void; assertPipelinePrimaryTopicReference(props?: object | null): void; assertPipelineTopicExpression(props?: object | null): void; assertPrivate(props?: object | null): void; assertPrivateName(props?: object | null): void; assertProgram(props?: object | null): void; assertProperty(props?: object | null): void; assertPureish(props?: object | null): void; assertQualifiedTypeIdentifier(props?: object | null): void; assertRegExpLiteral(props?: object | null): void; /** @deprecated Use `assertRegExpLiteral` */ assertRegexLiteral(props?: object | null): void; assertRestElement(props?: object | null): void; /** @deprecated Use `assertRestElement` */ assertRestProperty(props?: object | null): void; assertReturnStatement(props?: object | null): void; assertScopable(props?: object | null): void; assertSequenceExpression(props?: object | null): void; assertSpreadElement(props?: object | null): void; /** @deprecated Use `assertSpreadElement` */ assertSpreadProperty(props?: object | null): void; assertStatement(props?: object | null): void; assertStringLiteral(props?: object | null): void; assertStringLiteralTypeAnnotation(props?: object | null): void; assertStringTypeAnnotation(props?: object | null): void; assertSuper(props?: object | null): void; assertSwitchCase(props?: object | null): void; assertSwitchStatement(props?: object | null): void; assertTSAnyKeyword(props?: object | null): void; assertTSArrayType(props?: object | null): void; assertTSAsExpression(props?: object | null): void; assertTSBooleanKeyword(props?: object | null): void; assertTSCallSignatureDeclaration(props?: object | null): void; assertTSConditionalType(props?: object | null): void; assertTSConstructSignatureDeclaration(props?: object | null): void; assertTSConstructorType(props?: object | null): void; assertTSDeclareFunction(props?: object | null): void; assertTSDeclareMethod(props?: object | null): void; assertTSEntityName(props?: object | null): void; assertTSEnumDeclaration(props?: object | null): void; assertTSEnumMember(props?: object | null): void; assertTSExportAssignment(props?: object | null): void; assertTSExpressionWithTypeArguments(props?: object | null): void; assertTSExternalModuleReference(props?: object | null): void; assertTSFunctionType(props?: object | null): void; assertTSImportEqualsDeclaration(props?: object | null): void; assertTSImportType(props?: object | null): void; assertTSIndexSignature(props?: object | null): void; assertTSIndexedAccessType(props?: object | null): void; assertTSInferType(props?: object | null): void; assertTSInterfaceBody(props?: object | null): void; assertTSInterfaceDeclaration(props?: object | null): void; assertTSIntersectionType(props?: object | null): void; assertTSLiteralType(props?: object | null): void; assertTSMappedType(props?: object | null): void; assertTSMethodSignature(props?: object | null): void; assertTSModuleBlock(props?: object | null): void; assertTSModuleDeclaration(props?: object | null): void; assertTSNamespaceExportDeclaration(props?: object | null): void; assertTSNeverKeyword(props?: object | null): void; assertTSNonNullExpression(props?: object | null): void; assertTSNullKeyword(props?: object | null): void; assertTSNumberKeyword(props?: object | null): void; assertTSObjectKeyword(props?: object | null): void; assertTSOptionalType(props?: object | null): void; assertTSParameterProperty(props?: object | null): void; assertTSParenthesizedType(props?: object | null): void; assertTSPropertySignature(props?: object | null): void; assertTSQualifiedName(props?: object | null): void; assertTSRestType(props?: object | null): void; assertTSStringKeyword(props?: object | null): void; assertTSSymbolKeyword(props?: object | null): void; assertTSThisType(props?: object | null): void; assertTSTupleType(props?: object | null): void; assertTSType(props?: object | null): void; assertTSTypeAliasDeclaration(props?: object | null): void; assertTSTypeAnnotation(props?: object | null): void; assertTSTypeAssertion(props?: object | null): void; assertTSTypeElement(props?: object | null): void; assertTSTypeLiteral(props?: object | null): void; assertTSTypeOperator(props?: object | null): void; assertTSTypeParameter(props?: object | null): void; assertTSTypeParameterDeclaration(props?: object | null): void; assertTSTypeParameterInstantiation(props?: object | null): void; assertTSTypePredicate(props?: object | null): void; assertTSTypeQuery(props?: object | null): void; assertTSTypeReference(props?: object | null): void; assertTSUndefinedKeyword(props?: object | null): void; assertTSUnionType(props?: object | null): void; assertTSUnknownKeyword(props?: object | null): void; assertTSVoidKeyword(props?: object | null): void; assertTaggedTemplateExpression(props?: object | null): void; assertTemplateElement(props?: object | null): void; assertTemplateLiteral(props?: object | null): void; assertTerminatorless(props?: object | null): void; assertThisExpression(props?: object | null): void; assertThisTypeAnnotation(props?: object | null): void; assertThrowStatement(props?: object | null): void; assertTryStatement(props?: object | null): void; assertTupleTypeAnnotation(props?: object | null): void; assertTypeAlias(props?: object | null): void; assertTypeAnnotation(props?: object | null): void; assertTypeCastExpression(props?: object | null): void; assertTypeParameter(props?: object | null): void; assertTypeParameterDeclaration(props?: object | null): void; assertTypeParameterInstantiation(props?: object | null): void; assertTypeofTypeAnnotation(props?: object | null): void; assertUnaryExpression(props?: object | null): void; assertUnaryLike(props?: object | null): void; assertUnionTypeAnnotation(props?: object | null): void; assertUpdateExpression(props?: object | null): void; assertUserWhitespacable(props?: object | null): void; assertVariableDeclaration(props?: object | null): void; assertVariableDeclarator(props?: object | null): void; assertVariance(props?: object | null): void; assertVoidTypeAnnotation(props?: object | null): void; assertWhile(props?: object | null): void; assertWhileStatement(props?: object | null): void; assertWithStatement(props?: object | null): void; assertYieldExpression(props?: object | null): void; assertBindingIdentifier(props?: object | null): void; assertBlockScoped(props?: object | null): void; assertGenerated(props?: object | null): void; assertPure(props?: object | null): void; assertReferenced(props?: object | null): void; assertReferencedIdentifier(props?: object | null): void; assertReferencedMemberExpression(props?: object | null): void; assertScope(props?: object | null): void; assertUser(props?: object | null): void; assertVar(props?: object | null): void; //#endregion } export interface HubInterface { getCode(): string | undefined; getScope(): Scope | undefined; addHelper(name: string): any; buildError(node: Node, msg: string, Error: new (message?: string) => E): E; } export class Hub implements HubInterface { constructor(); getCode(): string | undefined; getScope(): Scope | undefined; addHelper(name: string): any; buildError(node: Node, msg: string, Constructor: new (message?: string) => E): E; } export interface TraversalContext { parentPath: NodePath; scope: Scope; state: any; opts: any; } export type NodePathResult = | (Extract extends never ? never : NodePath>) | (T extends Array ? Array> : never); babel__traverse/LICENSE000066600000002165150432033150010674 0ustar00 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 babel__traverse/package.json000066600000003555150432033150012161 0ustar00{ "name": "@types/babel__traverse", "version": "7.18.3", "description": "TypeScript definitions for @babel/traverse", "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/babel__traverse", "license": "MIT", "contributors": [ { "name": "Troy Gerwien", "url": "https://github.com/yortus", "githubUsername": "yortus" }, { "name": "Marvin Hagemeister", "url": "https://github.com/marvinhagemeister", "githubUsername": "marvinhagemeister" }, { "name": "Ryan Petrich", "url": "https://github.com/rpetrich", "githubUsername": "rpetrich" }, { "name": "Melvin Groenhoff", "url": "https://github.com/mgroenhoff", "githubUsername": "mgroenhoff" }, { "name": "Dean L.", "url": "https://github.com/dlgrit", "githubUsername": "dlgrit" }, { "name": "Ifiok Jr.", "url": "https://github.com/ifiokjr", "githubUsername": "ifiokjr" }, { "name": "ExE Boss", "url": "https://github.com/ExE-Boss", "githubUsername": "ExE-Boss" }, { "name": "Daniel Tschinder", "url": "https://github.com/danez", "githubUsername": "danez" } ], "main": "", "types": "index.d.ts", "repository": { "type": "git", "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git", "directory": "types/babel__traverse" }, "scripts": {}, "dependencies": { "@babel/types": "^7.3.0" }, "typesPublisherContentHash": "794d0cb7b862c906728252af03d0e0a3f87677ffe6a927640a79bbd482121d29", "typeScriptVersion": "4.1" }ws/README.md000066600000001502150432033150006452 0ustar00# Installation > `npm install --save @types/ws` # Summary This package contains type definitions for ws (https://github.com/websockets/ws). # Details Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/ws. ### Additional Details * Last updated: Fri, 30 Dec 2022 00:32:41 GMT * Dependencies: [@types/node](https://npmjs.com/package/@types/node) * Global values: none # Credits These definitions were written by [Paul Loyd](https://github.com/loyd), [Margus Lamp](https://github.com/mlamp), [Philippe D'Alva](https://github.com/TitaneBoy), [reduckted](https://github.com/reduckted), [teidesu](https://github.com/teidesu), [Bartosz Wojtkowiak](https://github.com/wojtkowiak), [Kyle Hensel](https://github.com/k-yle), and [Samuel Skeen](https://github.com/cwadrupldijjit). ws/index.d.mts000066600000000551150432033150007254 0ustar00export { createWebSocketStream, WebSocket, WebSocketServer, RawData, Data, CertMeta, VerifyClientCallbackSync, VerifyClientCallbackAsync, ClientOptions, PerMessageDeflateOptions, Event, ErrorEvent, CloseEvent, MessageEvent, EventListenerOptions, ServerOptions, AddressInfo } from "./index.js"; import WebSocket = require("./index.js"); export default WebSocket;ws/index.d.ts000066600000041362150432033150007104 0ustar00// Type definitions for ws 8.5 // Project: https://github.com/websockets/ws // Definitions by: Paul Loyd // Margus Lamp // Philippe D'Alva // reduckted // teidesu // Bartosz Wojtkowiak // Kyle Hensel // Samuel Skeen // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped /// import { EventEmitter } from "events"; import { Agent, ClientRequest, ClientRequestArgs, IncomingMessage, OutgoingHttpHeaders, Server as HTTPServer, } from "http"; import { Server as HTTPSServer } from "https"; import { Duplex, DuplexOptions } from "stream"; import { SecureContextOptions } from "tls"; import { URL } from "url"; import { ZlibOptions } from "zlib"; // can not get all overload of BufferConstructor['from'], need to copy all it's first arguments here // https://github.com/microsoft/TypeScript/issues/32164 type BufferLike = | string | Buffer | DataView | number | ArrayBufferView | Uint8Array | ArrayBuffer | SharedArrayBuffer | ReadonlyArray | ReadonlyArray | { valueOf(): ArrayBuffer } | { valueOf(): SharedArrayBuffer } | { valueOf(): Uint8Array } | { valueOf(): ReadonlyArray } | { valueOf(): string } | { [Symbol.toPrimitive](hint: string): string }; // WebSocket socket. declare class WebSocket extends EventEmitter { /** The connection is not yet open. */ static readonly CONNECTING: 0; /** The connection is open and ready to communicate. */ static readonly OPEN: 1; /** The connection is in the process of closing. */ static readonly CLOSING: 2; /** The connection is closed. */ static readonly CLOSED: 3; binaryType: "nodebuffer" | "arraybuffer" | "fragments"; readonly bufferedAmount: number; readonly extensions: string; /** Indicates whether the websocket is paused */ readonly isPaused: boolean; readonly protocol: string; /** The current state of the connection */ readonly readyState: | typeof WebSocket.CONNECTING | typeof WebSocket.OPEN | typeof WebSocket.CLOSING | typeof WebSocket.CLOSED; readonly url: string; /** The connection is not yet open. */ readonly CONNECTING: 0; /** The connection is open and ready to communicate. */ readonly OPEN: 1; /** The connection is in the process of closing. */ readonly CLOSING: 2; /** The connection is closed. */ readonly CLOSED: 3; onopen: ((event: WebSocket.Event) => void) | null; onerror: ((event: WebSocket.ErrorEvent) => void) | null; onclose: ((event: WebSocket.CloseEvent) => void) | null; onmessage: ((event: WebSocket.MessageEvent) => void) | null; constructor(address: null); constructor(address: string | URL, options?: WebSocket.ClientOptions | ClientRequestArgs); constructor( address: string | URL, protocols?: string | string[], options?: WebSocket.ClientOptions | ClientRequestArgs, ); close(code?: number, data?: string | Buffer): void; ping(data?: any, mask?: boolean, cb?: (err: Error) => void): void; pong(data?: any, mask?: boolean, cb?: (err: Error) => void): void; // https://github.com/websockets/ws/issues/2076#issuecomment-1250354722 send(data: BufferLike, cb?: (err?: Error) => void): void; send( data: BufferLike, options: { mask?: boolean | undefined; binary?: boolean | undefined; compress?: boolean | undefined; fin?: boolean | undefined }, cb?: (err?: Error) => void, ): void; terminate(): void; /** * Pause the websocket causing it to stop emitting events. Some events can still be * emitted after this is called, until all buffered data is consumed. This method * is a noop if the ready state is `CONNECTING` or `CLOSED`. */ pause(): void; /** * Make a paused socket resume emitting events. This method is a noop if the ready * state is `CONNECTING` or `CLOSED`. */ resume(): void; // HTML5 WebSocket events addEventListener( method: "message", cb: (event: WebSocket.MessageEvent) => void, options?: WebSocket.EventListenerOptions, ): void; addEventListener( method: "close", cb: (event: WebSocket.CloseEvent) => void, options?: WebSocket.EventListenerOptions, ): void; addEventListener( method: "error", cb: (event: WebSocket.ErrorEvent) => void, options?: WebSocket.EventListenerOptions, ): void; addEventListener( method: "open", cb: (event: WebSocket.Event) => void, options?: WebSocket.EventListenerOptions, ): void; removeEventListener(method: "message", cb: (event: WebSocket.MessageEvent) => void): void; removeEventListener(method: "close", cb: (event: WebSocket.CloseEvent) => void): void; removeEventListener(method: "error", cb: (event: WebSocket.ErrorEvent) => void): void; removeEventListener(method: "open", cb: (event: WebSocket.Event) => void): void; // Events on(event: "close", listener: (this: WebSocket, code: number, reason: Buffer) => void): this; on(event: "error", listener: (this: WebSocket, err: Error) => void): this; on(event: "upgrade", listener: (this: WebSocket, request: IncomingMessage) => void): this; on(event: "message", listener: (this: WebSocket, data: WebSocket.RawData, isBinary: boolean) => void): this; on(event: "open", listener: (this: WebSocket) => void): this; on(event: "ping" | "pong", listener: (this: WebSocket, data: Buffer) => void): this; on( event: "unexpected-response", listener: (this: WebSocket, request: ClientRequest, response: IncomingMessage) => void, ): this; on(event: string | symbol, listener: (this: WebSocket, ...args: any[]) => void): this; once(event: "close", listener: (this: WebSocket, code: number, reason: Buffer) => void): this; once(event: "error", listener: (this: WebSocket, err: Error) => void): this; once(event: "upgrade", listener: (this: WebSocket, request: IncomingMessage) => void): this; once(event: "message", listener: (this: WebSocket, data: WebSocket.RawData, isBinary: boolean) => void): this; once(event: "open", listener: (this: WebSocket) => void): this; once(event: "ping" | "pong", listener: (this: WebSocket, data: Buffer) => void): this; once( event: "unexpected-response", listener: (this: WebSocket, request: ClientRequest, response: IncomingMessage) => void, ): this; once(event: string | symbol, listener: (this: WebSocket, ...args: any[]) => void): this; off(event: "close", listener: (this: WebSocket, code: number, reason: Buffer) => void): this; off(event: "error", listener: (this: WebSocket, err: Error) => void): this; off(event: "upgrade", listener: (this: WebSocket, request: IncomingMessage) => void): this; off(event: "message", listener: (this: WebSocket, data: WebSocket.RawData, isBinary: boolean) => void): this; off(event: "open", listener: (this: WebSocket) => void): this; off(event: "ping" | "pong", listener: (this: WebSocket, data: Buffer) => void): this; off( event: "unexpected-response", listener: (this: WebSocket, request: ClientRequest, response: IncomingMessage) => void, ): this; off(event: string | symbol, listener: (this: WebSocket, ...args: any[]) => void): this; addListener(event: "close", listener: (code: number, reason: Buffer) => void): this; addListener(event: "error", listener: (err: Error) => void): this; addListener(event: "upgrade", listener: (request: IncomingMessage) => void): this; addListener(event: "message", listener: (data: WebSocket.RawData, isBinary: boolean) => void): this; addListener(event: "open", listener: () => void): this; addListener(event: "ping" | "pong", listener: (data: Buffer) => void): this; addListener( event: "unexpected-response", listener: (request: ClientRequest, response: IncomingMessage) => void, ): this; addListener(event: string | symbol, listener: (...args: any[]) => void): this; removeListener(event: "close", listener: (code: number, reason: Buffer) => void): this; removeListener(event: "error", listener: (err: Error) => void): this; removeListener(event: "upgrade", listener: (request: IncomingMessage) => void): this; removeListener(event: "message", listener: (data: WebSocket.RawData, isBinary: boolean) => void): this; removeListener(event: "open", listener: () => void): this; removeListener(event: "ping" | "pong", listener: (data: Buffer) => void): this; removeListener( event: "unexpected-response", listener: (request: ClientRequest, response: IncomingMessage) => void, ): this; removeListener(event: string | symbol, listener: (...args: any[]) => void): this; } declare const WebSocketAlias: typeof WebSocket; interface WebSocketAlias extends WebSocket {} // tslint:disable-line no-empty-interface declare namespace WebSocket { /** * Data represents the raw message payload received over the WebSocket. */ type RawData = Buffer | ArrayBuffer | Buffer[]; /** * Data represents the message payload received over the WebSocket. */ type Data = string | Buffer | ArrayBuffer | Buffer[]; /** * CertMeta represents the accepted types for certificate & key data. */ type CertMeta = string | string[] | Buffer | Buffer[]; /** * VerifyClientCallbackSync is a synchronous callback used to inspect the * incoming message. The return value (boolean) of the function determines * whether or not to accept the handshake. */ type VerifyClientCallbackSync = (info: { origin: string; secure: boolean; req: IncomingMessage }) => boolean; /** * VerifyClientCallbackAsync is an asynchronous callback used to inspect the * incoming message. The return value (boolean) of the function determines * whether or not to accept the handshake. */ type VerifyClientCallbackAsync = ( info: { origin: string; secure: boolean; req: IncomingMessage }, callback: (res: boolean, code?: number, message?: string, headers?: OutgoingHttpHeaders) => void, ) => void; interface ClientOptions extends SecureContextOptions { protocol?: string | undefined; followRedirects?: boolean | undefined; generateMask?(mask: Buffer): void; handshakeTimeout?: number | undefined; maxRedirects?: number | undefined; perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined; localAddress?: string | undefined; protocolVersion?: number | undefined; headers?: { [key: string]: string } | undefined; origin?: string | undefined; agent?: Agent | undefined; host?: string | undefined; family?: number | undefined; checkServerIdentity?(servername: string, cert: CertMeta): boolean; rejectUnauthorized?: boolean | undefined; maxPayload?: number | undefined; skipUTF8Validation?: boolean | undefined; } interface PerMessageDeflateOptions { serverNoContextTakeover?: boolean | undefined; clientNoContextTakeover?: boolean | undefined; serverMaxWindowBits?: number | undefined; clientMaxWindowBits?: number | undefined; zlibDeflateOptions?: { flush?: number | undefined; finishFlush?: number | undefined; chunkSize?: number | undefined; windowBits?: number | undefined; level?: number | undefined; memLevel?: number | undefined; strategy?: number | undefined; dictionary?: Buffer | Buffer[] | DataView | undefined; info?: boolean | undefined; } | undefined; zlibInflateOptions?: ZlibOptions | undefined; threshold?: number | undefined; concurrencyLimit?: number | undefined; } interface Event { type: string; target: WebSocket; } interface ErrorEvent { error: any; message: string; type: string; target: WebSocket; } interface CloseEvent { wasClean: boolean; code: number; reason: string; type: string; target: WebSocket; } interface MessageEvent { data: Data; type: string; target: WebSocket; } interface EventListenerOptions { once?: boolean | undefined; } interface ServerOptions { host?: string | undefined; port?: number | undefined; backlog?: number | undefined; server?: HTTPServer | HTTPSServer | undefined; verifyClient?: VerifyClientCallbackAsync | VerifyClientCallbackSync | undefined; handleProtocols?: (protocols: Set, request: IncomingMessage) => string | false; path?: string | undefined; noServer?: boolean | undefined; clientTracking?: boolean | undefined; perMessageDeflate?: boolean | PerMessageDeflateOptions | undefined; maxPayload?: number | undefined; skipUTF8Validation?: boolean | undefined; WebSocket?: typeof WebSocket.WebSocket | undefined; } interface AddressInfo { address: string; family: string; port: number; } // WebSocket Server class Server extends EventEmitter { options: ServerOptions; path: string; clients: Set; constructor(options?: ServerOptions, callback?: () => void); address(): AddressInfo | string; close(cb?: (err?: Error) => void): void; handleUpgrade( request: IncomingMessage, socket: Duplex, upgradeHead: Buffer, callback: (client: T, request: IncomingMessage) => void, ): void; shouldHandle(request: IncomingMessage): boolean | Promise; // Events on(event: "connection", cb: (this: Server, socket: T, request: IncomingMessage) => void): this; on(event: "error", cb: (this: Server, error: Error) => void): this; on(event: "headers", cb: (this: Server, headers: string[], request: IncomingMessage) => void): this; on(event: "close" | "listening", cb: (this: Server) => void): this; on(event: string | symbol, listener: (this: Server, ...args: any[]) => void): this; once(event: "connection", cb: (this: Server, socket: T, request: IncomingMessage) => void): this; once(event: "error", cb: (this: Server, error: Error) => void): this; once(event: "headers", cb: (this: Server, headers: string[], request: IncomingMessage) => void): this; once(event: "close" | "listening", cb: (this: Server) => void): this; once(event: string | symbol, listener: (this: Server, ...args: any[]) => void): this; off(event: "connection", cb: (this: Server, socket: T, request: IncomingMessage) => void): this; off(event: "error", cb: (this: Server, error: Error) => void): this; off(event: "headers", cb: (this: Server, headers: string[], request: IncomingMessage) => void): this; off(event: "close" | "listening", cb: (this: Server) => void): this; off(event: string | symbol, listener: (this: Server, ...args: any[]) => void): this; addListener(event: "connection", cb: (client: T, request: IncomingMessage) => void): this; addListener(event: "error", cb: (err: Error) => void): this; addListener(event: "headers", cb: (headers: string[], request: IncomingMessage) => void): this; addListener(event: "close" | "listening", cb: () => void): this; addListener(event: string | symbol, listener: (...args: any[]) => void): this; removeListener(event: "connection", cb: (client: T) => void): this; removeListener(event: "error", cb: (err: Error) => void): this; removeListener(event: "headers", cb: (headers: string[], request: IncomingMessage) => void): this; removeListener(event: "close" | "listening", cb: () => void): this; removeListener(event: string | symbol, listener: (...args: any[]) => void): this; } const WebSocketServer: typeof Server; interface WebSocketServer extends Server {} // tslint:disable-line no-empty-interface const WebSocket: typeof WebSocketAlias; interface WebSocket extends WebSocketAlias {} // tslint:disable-line no-empty-interface // WebSocket stream function createWebSocketStream(websocket: WebSocket, options?: DuplexOptions): Duplex; } export = WebSocket; ws/LICENSE000066600000002165150432033150006206 0ustar00 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 ws/package.json000066600000003773150432033150007475 0ustar00{ "name": "@types/ws", "version": "8.5.4", "description": "TypeScript definitions for ws", "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/ws", "license": "MIT", "contributors": [ { "name": "Paul Loyd", "url": "https://github.com/loyd", "githubUsername": "loyd" }, { "name": "Margus Lamp", "url": "https://github.com/mlamp", "githubUsername": "mlamp" }, { "name": "Philippe D'Alva", "url": "https://github.com/TitaneBoy", "githubUsername": "TitaneBoy" }, { "name": "reduckted", "url": "https://github.com/reduckted", "githubUsername": "reduckted" }, { "name": "teidesu", "url": "https://github.com/teidesu", "githubUsername": "teidesu" }, { "name": "Bartosz Wojtkowiak", "url": "https://github.com/wojtkowiak", "githubUsername": "wojtkowiak" }, { "name": "Kyle Hensel", "url": "https://github.com/k-yle", "githubUsername": "k-yle" }, { "name": "Samuel Skeen", "url": "https://github.com/cwadrupldijjit", "githubUsername": "cwadrupldijjit" } ], "main": "", "types": "index.d.ts", "repository": { "type": "git", "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git", "directory": "types/ws" }, "scripts": {}, "dependencies": { "@types/node": "*" }, "typesPublisherContentHash": "d78ccf27d7710f245ab25f9d4957067c8fc0f7aadc035919f7a890427d7360ca", "typeScriptVersion": "4.2", "exports": { ".": { "types": { "import": "./index.d.mts", "default": "./index.d.ts" } }, "./package.json": "./package.json" } }imagemin-optipng/README.md000066600000002533150432033150011272 0ustar00# Installation > `npm install --save @types/imagemin-optipng` # Summary This package contains type definitions for imagemin-optipng (https://github.com/imagemin/imagemin-optipng#readme). # Details Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/imagemin-optipng. ## [index.d.ts](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/imagemin-optipng/index.d.ts) ````ts // Type definitions for imagemin-optipng 5.2 // Project: https://github.com/imagemin/imagemin-optipng#readme // Definitions by: Romain Faust // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped import { Plugin } from 'imagemin'; declare function imageminOptipng(options?: imageminOptipng.Options): Plugin; declare namespace imageminOptipng { interface Options { bitDepthReduction?: boolean | undefined; colorTypeReduction?: boolean | undefined; optimizationLevel?: number | undefined; paletteReduction?: boolean | undefined; } } export = imageminOptipng; ```` ### Additional Details * Last updated: Tue, 06 Jul 2021 21:33:39 GMT * Dependencies: [@types/imagemin](https://npmjs.com/package/@types/imagemin) * Global values: none # Credits These definitions were written by [Romain Faust](https://github.com/romain-faust). imagemin-optipng/index.d.ts000066600000001207150432033150011711 0ustar00// Type definitions for imagemin-optipng 5.2 // Project: https://github.com/imagemin/imagemin-optipng#readme // Definitions by: Romain Faust // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped import { Plugin } from 'imagemin'; declare function imageminOptipng(options?: imageminOptipng.Options): Plugin; declare namespace imageminOptipng { interface Options { bitDepthReduction?: boolean | undefined; colorTypeReduction?: boolean | undefined; optimizationLevel?: number | undefined; paletteReduction?: boolean | undefined; } } export = imageminOptipng; imagemin-optipng/LICENSE000066600000002165150432033150011021 0ustar00 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 imagemin-optipng/package.json000066600000001542150432033150012300 0ustar00{ "name": "@types/imagemin-optipng", "version": "5.2.1", "description": "TypeScript definitions for imagemin-optipng", "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/imagemin-optipng", "license": "MIT", "contributors": [ { "name": "Romain Faust", "url": "https://github.com/romain-faust", "githubUsername": "romain-faust" } ], "main": "", "types": "index.d.ts", "repository": { "type": "git", "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git", "directory": "types/imagemin-optipng" }, "scripts": {}, "dependencies": { "@types/imagemin": "*" }, "typesPublisherContentHash": "2e7078c899e71193a0b391ae2ea5f4c5b53c84da309e2effcad98c75e4d02bac", "typeScriptVersion": "3.6" }imagemin-mozjpeg/README.md000066600000001114150432033150011257 0ustar00# Installation > `npm install --save @types/imagemin-mozjpeg` # Summary This package contains type definitions for imagemin-mozjpeg (https://github.com/imagemin/imagemin-mozjpeg#readme). # Details Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/imagemin-mozjpeg. ### Additional Details * Last updated: Tue, 06 Jul 2021 21:33:39 GMT * Dependencies: [@types/imagemin](https://npmjs.com/package/@types/imagemin) * Global values: none # Credits These definitions were written by [Jeff Chan](https://github.com/hkjeffchan). imagemin-mozjpeg/index.d.ts000066600000006543150432033150011714 0ustar00// Type definitions for imagemin-mozjpeg 8.0 // Project: https://github.com/imagemin/imagemin-mozjpeg#readme // Definitions by: Jeff Chan // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped import { Plugin } from 'imagemin'; declare function imageminMozjpeg(options?: imageminMozjpeg.Options): Plugin; declare namespace imageminMozjpeg { interface Options { /** Compression quality, in range 0 (worst) to 100 (perfect). */ quality?: number | undefined; /** * false creates baseline JPEG file. * @default true */ progressive?: boolean | undefined; /** * Input file is Targa format (usually not needed). * @default false */ targa?: boolean | undefined; /** * Revert to standard defaults instead of mozjpeg defaults. * @default false */ revert?: boolean | undefined; /** * Disable progressive scan optimization. * @default false */ fastCrush?: boolean | undefined; /** * Set DC scan optimization mode. * 0 One scan for all components * 1 One scan per component * 2 Optimize between one scan for all components and one scan for 1st component plus one scan for remaining components * @default 1 */ dcScanOpt?: number | undefined; /** * Trellis optimization. * @default true * */ trellis?: boolean | undefined; /** * Trellis optimization of DC coefficients. * @default true */ trellisDC?: boolean | undefined; /** * Set Trellis optimization method. Available methods: psnr, hvs-psnr, ssim, ms-ssim * @default 'hvs-psnr' */ tune?: 'psnr' | 'hvs-psnr' | 'ssim' | 'ms-ssim' | undefined; /** * Black-on-white deringing via overshoot. * @default true */ overshoot?: boolean | undefined; /** * Use arithmetic coding. * @default false */ arithmetic?: boolean | undefined; /** * Set DCT method: * int Use integer DCT * fast Use fast integer DCT (less accurate) * float Use floating-point DCT * @default 'int' */ dct?: 'int' | 'fast' | 'float' | undefined; /** * Use 8-bit quantization table entries for baseline JPEG compatibility. * @default false */ quantBaseline?: boolean | undefined; /** * Use predefined quantization table. * 0 JPEG Annex K * 1 Flat * 2 Custom, tuned for MS-SSIM * 3 ImageMagick table by N. Robidoux * 4 Custom, tuned for PSNR-HVS * 5 Table from paper by Klein, Silverstein and Carney */ quantTable?: number | undefined; /** * Set the strength of smooth dithered input. (1...100) */ smooth?: number | undefined; /** * Set the maximum memory to use in kilobytes. */ maxMemory?: number | undefined; /** * Set component sampling factors. Each item should be in the format HxV, for example 2x1. */ sample?: string[] | undefined; } } export = imageminMozjpeg; imagemin-mozjpeg/LICENSE000066600000002165150432033150011014 0ustar00 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 imagemin-mozjpeg/package.json000066600000001533150432033150012273 0ustar00{ "name": "@types/imagemin-mozjpeg", "version": "8.0.1", "description": "TypeScript definitions for imagemin-mozjpeg", "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/imagemin-mozjpeg", "license": "MIT", "contributors": [ { "name": "Jeff Chan", "url": "https://github.com/hkjeffchan", "githubUsername": "hkjeffchan" } ], "main": "", "types": "index.d.ts", "repository": { "type": "git", "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git", "directory": "types/imagemin-mozjpeg" }, "scripts": {}, "dependencies": { "@types/imagemin": "*" }, "typesPublisherContentHash": "2c722fd2a3e8a4604c328f6787ab72d6a501367c08448421dc7a096527387368", "typeScriptVersion": "3.6" }svgo/README.md000066600000001322150432033150006777 0ustar00# Installation > `npm install --save @types/svgo` # Summary This package contains type definitions for svgo (https://github.com/svg/svgo). # Details Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/svgo/v1. ### Additional Details * Last updated: Fri, 02 Jul 2021 22:33:14 GMT * Dependencies: none * Global values: none # Credits These definitions were written by [Bradley Ayers](https://github.com/bradleyayers), [Gilad Gray](https://github.com/giladgray), [Aankhen](https://github.com/Aankhen), [Jan Karres](https://github.com/jankarres), [Gavin Gregory](https://github.com/gavingregory), and [Piotr Błażejewicz](https://github.com/peterblazejewicz). svgo/index.d.ts000066600000023263150432033150007431 0ustar00// Type definitions for svgo 1.3 // Project: https://github.com/svg/svgo // Definitions by: Bradley Ayers // Gilad Gray // Aankhen // Jan Karres // Gavin Gregory // Piotr Błażejewicz // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped // TypeScript Version: 2.2 interface PluginCleanupAttrs { cleanupAttrs: boolean | object; } interface PluginInlineStyles { inlineStyles: boolean | object; } interface PluginRemoveDoctype { removeDoctype: boolean | object; } interface PluginRemoveXMLProcInst { removeXMLProcInst: boolean | object; } interface PluginRemoveComments { removeComments: boolean | object; } interface PluginRemoveMetadata { removeMetadata: boolean | object; } interface PluginRemoveTitle { removeTitle: boolean | object; } interface PluginRemoveDesc { removeDesc: boolean | object; } interface PluginRemoveUselessDefs { removeUselessDefs: boolean | object; } interface PluginRemoveXMLNS { removeXMLNS: boolean | object; } interface PluginRemoveEditorsNSData { removeEditorsNSData: boolean | object; } interface PluginRemoveEmptyAttrs { removeEmptyAttrs: boolean | object; } interface PluginRemoveHiddenElems { removeHiddenElems: boolean | object; } interface PluginRemoveEmptyText { removeEmptyText: boolean | object; } interface PluginRemoveEmptyContainers { removeEmptyContainers: boolean | object; } interface PluginRemoveViewBox { removeViewBox: boolean | object; } interface PluginCleanupEnableBackground { cleanupEnableBackground: boolean | object; } interface PluginMinifyStyles { minifyStyles: boolean | object; } interface PluginConvertStyleToAttrs { convertStyleToAttrs: boolean | object; } interface PluginConvertColors { convertColors: boolean | object; } interface PluginConvertEllipseToCircle { /** convert ellipse with equal radius measures to circle */ convertEllipseToCircle: boolean | object; } interface PluginConvertPathData { convertPathData: boolean | object; } interface PluginConvertTransform { convertTransform: boolean | object; } interface PluginRemoveUnknownsAndDefaults { removeUnknownsAndDefaults: boolean | object; } interface PluginRemoveNonInheritableGroupAttrs { removeNonInheritableGroupAttrs: boolean | object; } interface PluginRemoveUselessStrokeAndFill { removeUselessStrokeAndFill: boolean | object; } interface PluginRemoveUnusedNS { removeUnusedNS: boolean | object; } interface PluginPrefixIds { /** prefix IDs and classes with the SVG filename or an arbitrary string */ prefixIds: boolean | object; } interface PluginCleanupIDs { cleanupIDs: boolean | object; } interface PluginCleanupNumericValues { cleanupNumericValues: boolean | object; } interface PluginCleanupListOfValues { cleanupListOfValues: boolean | object; } interface PluginMoveElemsAttrsToGroup { moveElemsAttrsToGroup: boolean | object; } interface PluginMoveGroupAttrsToElems { moveGroupAttrsToElems: boolean | object; } interface PluginCollapseGroups { collapseGroups: boolean | object; } interface PluginRemoveRasterImages { removeRasterImages: boolean | object; } interface PluginMergePaths { mergePaths: boolean | object; } interface PluginConvertShapeToPath { convertShapeToPath: boolean | object; } interface PluginSortAttrs { sortAttrs: boolean | object; } interface PluginSortDefsChildren { /** sort children of in order to improve compression */ sortDefsChildren: boolean | object; } interface PluginRemoveDimensions { removeDimensions: boolean | object; } interface PluginRemoveAttrs { removeAttrs: boolean | object; } interface PluginRemoveAttributesBySelector { removeAttributesBySelector: boolean | object; } interface PluginRemoveElementsByAttr { removeElementsByAttr: boolean | object; } interface PluginAddClassesToSVGElement { addClassesToSVGElement: boolean | object; } interface PluginAddAttributesToSVGElement { addAttributesToSVGElement: boolean | object; } interface PluginRemoveOffCanvasPaths { removeOffCanvasPaths: boolean | object; } interface PluginRemoveStyleElement { removeStyleElement: boolean | object; } interface PluginRemoveScriptElement { removeScriptElement: boolean | object; } interface PluginReusePaths { reusePaths: boolean | object; } interface SvgInfo { path?: string | undefined; } interface OptimizedSvg { data: string; info: { width: string; height: string; }; path?: string | undefined; } declare class SVGO { static Config(config?: SVGO.Options): SVGO.Options; constructor(config?: SVGO.Options); optimize(svgString: string, info?: SvgInfo): Promise; } declare namespace SVGO { type PluginConfig = | PluginCleanupAttrs | PluginInlineStyles | PluginRemoveDoctype | PluginRemoveXMLProcInst | PluginRemoveComments | PluginRemoveMetadata | PluginRemoveTitle | PluginRemoveDesc | PluginRemoveUselessDefs | PluginRemoveXMLNS | PluginRemoveEditorsNSData | PluginRemoveEmptyAttrs | PluginRemoveHiddenElems | PluginRemoveEmptyText | PluginRemoveEmptyContainers | PluginRemoveViewBox | PluginCleanupEnableBackground | PluginMinifyStyles | PluginConvertStyleToAttrs | PluginConvertColors | PluginConvertEllipseToCircle | PluginConvertPathData | PluginConvertTransform | PluginRemoveUnknownsAndDefaults | PluginRemoveNonInheritableGroupAttrs | PluginRemoveUselessStrokeAndFill | PluginRemoveUnusedNS | PluginPrefixIds | PluginCleanupIDs | PluginCleanupNumericValues | PluginCleanupListOfValues | PluginMoveElemsAttrsToGroup | PluginMoveGroupAttrsToElems | PluginCollapseGroups | PluginRemoveRasterImages | PluginMergePaths | PluginConvertShapeToPath | PluginSortAttrs | PluginSortDefsChildren | PluginRemoveDimensions | PluginRemoveAttrs | PluginRemoveAttributesBySelector | PluginRemoveElementsByAttr | PluginAddClassesToSVGElement | PluginAddAttributesToSVGElement | PluginRemoveOffCanvasPaths | PluginRemoveStyleElement | PluginRemoveScriptElement | PluginReusePaths; interface Js2SvgOptions { /** @default '' */ doctypeEnd?: string | undefined; /** @default '' */ procInstEnd?: string | undefined; /** @default '<' */ tagOpenStart?: string | undefined; /** @default '>' */ tagOpenEnd?: string | undefined; /** @default '' */ tagCloseEnd?: string | undefined; /** @default '<' */ tagShortStart?: string | undefined; /** @default '/>' */ tagShortEnd?: string | undefined; /** @default '="' */ attrStart?: string | undefined; /** @default '"' */ attrEnd?: string | undefined; /** @default '' */ commentEnd?: string | undefined; /** @default '' */ cdataEnd?: string | undefined; /** @default '' */ textStart?: string | undefined; /** @default '' */ textEnd?: string | undefined; /** @default 4 */ indent?: number | undefined; /** @default /[&'"<>]/g */ regEntities?: RegExp | undefined; /** @default /[&"<>]/g */ regValEntities?: RegExp | undefined; /** @default encodeEntity */ encodeEntity?: ((char?: string) => string) | undefined; /** @default false */ pretty?: boolean | undefined; /** @default true */ useShortTags?: boolean | undefined; } interface Svg2JsOptions { /** @default true */ strict?: boolean | undefined; /** @default false */ trim?: boolean | undefined; /** @default true */ normalize?: boolean | undefined; /** @default true */ lowercase?: boolean | undefined; /** @default true */ xmlns?: boolean | undefined; /** @default true */ position?: boolean | undefined; } interface Options { /** Output as Data URI string. */ datauri?: 'base64' | 'enc' | 'unenc' | undefined; /** Precision of floating point numbers. Will be passed to each plugin that suppors this param. */ floatPrecision?: number | undefined; /** Use full set of plugins. */ full?: boolean | undefined; /** Pass over SVGs multiple times to ensure all optimizations are applied */ multipass?: boolean | undefined; /** Options for rendering optimized SVG from AST. */ js2svg?: Js2SvgOptions | undefined; /** * Individual plugin configurations. * For specific options, see plugin source in https://github.com/svg/svgo/tree/master/plugins. */ plugins?: PluginConfig[] | undefined; /** Options for parsing original SVG into AST. */ svg2js?: Svg2JsOptions | undefined; } } export = SVGO; svgo/LICENSE000066600000002165150432033150006533 0ustar00 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 svgo/package.json000066600000003014150432033150010006 0ustar00{ "name": "@types/svgo", "version": "1.3.6", "description": "TypeScript definitions for svgo", "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/svgo", "license": "MIT", "contributors": [ { "name": "Bradley Ayers", "url": "https://github.com/bradleyayers", "githubUsername": "bradleyayers" }, { "name": "Gilad Gray", "url": "https://github.com/giladgray", "githubUsername": "giladgray" }, { "name": "Aankhen", "url": "https://github.com/Aankhen", "githubUsername": "Aankhen" }, { "name": "Jan Karres", "url": "https://github.com/jankarres", "githubUsername": "jankarres" }, { "name": "Gavin Gregory", "url": "https://github.com/gavingregory", "githubUsername": "gavingregory" }, { "name": "Piotr Błażejewicz", "url": "https://github.com/peterblazejewicz", "githubUsername": "peterblazejewicz" } ], "main": "", "types": "index.d.ts", "repository": { "type": "git", "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git", "directory": "types/svgo" }, "scripts": {}, "dependencies": {}, "typesPublisherContentHash": "a1859e50480342db713c1b9e0739d99933148398dc6f0557a6a7429e58a46463", "typeScriptVersion": "3.6" }qs/README.md000066600000001473150432033150006453 0ustar00# Installation > `npm install --save @types/qs` # Summary This package contains type definitions for qs (https://github.com/ljharb/qs). # Details Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/qs. ### Additional Details * Last updated: Wed, 07 Jul 2021 17:02:42 GMT * Dependencies: none * Global values: `qs` # Credits These definitions were written by [Roman Korneev](https://github.com/RWander), [Leon Yu](https://github.com/leonyu), [Belinda Teh](https://github.com/tehbelinda), [Melvin Lee](https://github.com/zyml), [Arturs Vonda](https://github.com/artursvonda), [Carlos Bonetti](https://github.com/CarlosBonetti), [Dan Smith](https://github.com/dpsmith3), [Hunter Perrin](https://github.com/hperrin), and [Jordan Harband](https://github.com/ljharb). qs/index.d.ts000066600000006020150432033150007066 0ustar00// Type definitions for qs 6.9 // Project: https://github.com/ljharb/qs // Definitions by: Roman Korneev // Leon Yu // Belinda Teh // Melvin Lee // Arturs Vonda // Carlos Bonetti // Dan Smith // Hunter Perrin // Jordan Harband // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped export = QueryString; export as namespace qs; declare namespace QueryString { type defaultEncoder = (str: any, defaultEncoder?: any, charset?: string) => string; type defaultDecoder = (str: string, decoder?: any, charset?: string) => string; interface IStringifyOptions { delimiter?: string | undefined; strictNullHandling?: boolean | undefined; skipNulls?: boolean | undefined; encode?: boolean | undefined; encoder?: ((str: any, defaultEncoder: defaultEncoder, charset: string, type: 'key' | 'value') => string) | undefined; filter?: Array | ((prefix: string, value: any) => any) | undefined; arrayFormat?: 'indices' | 'brackets' | 'repeat' | 'comma' | undefined; indices?: boolean | undefined; sort?: ((a: any, b: any) => number) | undefined; serializeDate?: ((d: Date) => string) | undefined; format?: 'RFC1738' | 'RFC3986' | undefined; encodeValuesOnly?: boolean | undefined; addQueryPrefix?: boolean | undefined; allowDots?: boolean | undefined; charset?: 'utf-8' | 'iso-8859-1' | undefined; charsetSentinel?: boolean | undefined; } interface IParseOptions { comma?: boolean | undefined; delimiter?: string | RegExp | undefined; depth?: number | false | undefined; decoder?: ((str: string, defaultDecoder: defaultDecoder, charset: string, type: 'key' | 'value') => any) | undefined; arrayLimit?: number | undefined; parseArrays?: boolean | undefined; allowDots?: boolean | undefined; plainObjects?: boolean | undefined; allowPrototypes?: boolean | undefined; parameterLimit?: number | undefined; strictNullHandling?: boolean | undefined; ignoreQueryPrefix?: boolean | undefined; charset?: 'utf-8' | 'iso-8859-1' | undefined; charsetSentinel?: boolean | undefined; interpretNumericEntities?: boolean | undefined; } interface ParsedQs { [key: string]: undefined | string | string[] | ParsedQs | ParsedQs[] } function stringify(obj: any, options?: IStringifyOptions): string; function parse(str: string, options?: IParseOptions & { decoder?: never | undefined }): ParsedQs; function parse(str: string | Record, options?: IParseOptions): { [key: string]: unknown }; } qs/LICENSE000066600000002165150432033150006200 0ustar00 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 qs/package.json000066600000003631150432033150007460 0ustar00{ "name": "@types/qs", "version": "6.9.7", "description": "TypeScript definitions for qs", "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/qs", "license": "MIT", "contributors": [ { "name": "Roman Korneev", "url": "https://github.com/RWander", "githubUsername": "RWander" }, { "name": "Leon Yu", "url": "https://github.com/leonyu", "githubUsername": "leonyu" }, { "name": "Belinda Teh", "url": "https://github.com/tehbelinda", "githubUsername": "tehbelinda" }, { "name": "Melvin Lee", "url": "https://github.com/zyml", "githubUsername": "zyml" }, { "name": "Arturs Vonda", "url": "https://github.com/artursvonda", "githubUsername": "artursvonda" }, { "name": "Carlos Bonetti", "url": "https://github.com/CarlosBonetti", "githubUsername": "CarlosBonetti" }, { "name": "Dan Smith", "url": "https://github.com/dpsmith3", "githubUsername": "dpsmith3" }, { "name": "Hunter Perrin", "url": "https://github.com/hperrin", "githubUsername": "hperrin" }, { "name": "Jordan Harband", "url": "https://github.com/ljharb", "githubUsername": "ljharb" } ], "main": "", "types": "index.d.ts", "repository": { "type": "git", "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git", "directory": "types/qs" }, "scripts": {}, "dependencies": {}, "typesPublisherContentHash": "b33fed3eed022f94c7db53593571f370eaa77aa17b3e302dc1bd77304f03e56c", "typeScriptVersion": "3.6" }retry/README.md000066600000001021150432033150007162 0ustar00# Installation > `npm install --save @types/retry` # Summary This package contains type definitions for retry (https://github.com/tim-kos/node-retry). # Details Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/retry Additional Details * Last updated: Thu, 03 Jan 2019 17:45:51 GMT * Dependencies: none * Global values: none # Credits These definitions were written by Stan Goldmann , BendingBender . retry/index.d.ts000066600000012026150432033150007613 0ustar00// Type definitions for retry 0.12 // Project: https://github.com/tim-kos/node-retry // Definitions by: Stan Goldmann // BendingBender // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped // TypeScript Version: 2.3 export interface RetryOperation { /** * Returns an array of all errors that have been passed to `retryOperation.retry()` so far. * The returning array has the errors ordered chronologically based on when they were passed to * `retryOperation.retry()`, which means the first passed error is at index zero and the last is at the last index. */ errors(): Error[]; /** * A reference to the error object that occured most frequently. * Errors are compared using the `error.message` property. * If multiple error messages occured the same amount of time, the last error object with that message is returned. * * @return If no errors occured so far the value will be `null`. */ mainError(): Error | null; /** * Defines the function that is to be retried and executes it for the first time right away. * * @param fn The function that is to be retried. `currentAttempt` represents the number of attempts * callback has been executed so far. * @param [timeoutOps.timeout] A timeout in milliseconds. * @param [timeoutOps.callback] Callback to execute when the operation takes longer than the timeout. */ attempt(fn: (currentAttempt: number) => void, timeoutOps?: AttemptTimeoutOptions): void; /** * Returns `false` when no `error` value is given, or the maximum amount of retries has been reached. * Otherwise it returns `true`, and retries the operation after the timeout for the current attempt number. */ retry(err?: Error): boolean; /** * Stops the operation being retried. Useful for aborting the operation on a fatal error etc. */ stop(): void; /** * Resets the internal state of the operation object, so that you can call `attempt()` again as if * this was a new operation object. */ reset(): void; /** * Returns an int representing the number of attempts it took to call `fn` before it was successful. */ attempts(): number; } export interface AttemptTimeoutOptions { /** * A timeout in milliseconds. */ timeout?: number; /** * Callback to execute when the operation takes longer than the timeout. */ callback?(): void; } /** * Create a new RetryOperation object. * * @param [options.retries=10] The maximum amount of times to retry the operation. * @param [options.factor=2] The exponential factor to use. * @param [options.minTimeout=1000] The number of milliseconds before starting the first retry. * @param [options.maxTimeout=Infinity] The maximum number of milliseconds between two retries. * @param [options.randomize=false] Randomizes the timeouts by multiplying a factor between 1-2. * @param [options.forever=false] Wether to retry forever. * @param [options.unref=false] Wether to unref the setTimeout's. * */ export function operation(options?: OperationOptions): RetryOperation; export interface OperationOptions extends TimeoutsOptions { /** * Whether to retry forever. * @default false */ forever?: boolean; /** * Whether to [unref](https://nodejs.org/api/timers.html#timers_unref) the setTimeout's. * @default false */ unref?: boolean; /** * The maximum time (in milliseconds) that the retried operation is allowed to run. * @default Infinity */ maxRetryTime?: number; } /** Get an array with timeouts and their return values in milliseconds. */ export function timeouts(options?: TimeoutsOptions): number[]; export interface TimeoutsOptions extends CreateTimeoutOptions { /** * The maximum amount of times to retry the operation. * @default 10 */ retries?: number; } /** * Create a new timeout (in milliseconds) based on the given parameters. * * @param attempt Representing for which retry the timeout should be calculated. * @return timeout */ export function createTimeout(attempt: number, options?: CreateTimeoutOptions): number; export interface CreateTimeoutOptions { /** * The exponential factor to use. * @default 2 */ factor?: number; /** * The number of milliseconds before starting the first retry. * @default 1000 */ minTimeout?: number; /** * The maximum number of milliseconds between two retries. * @default Infinity */ maxTimeout?: number; /** * Randomizes the timeouts by multiplying a factor between 1-2. * @default false */ randomize?: boolean; } /** * Wrap all functions of the object with retry. * * @param object The object to be wrapped * @param methods Methods which need to be wrapped * */ export function wrap(object: object, methods?: string[]): void; export function wrap(object: object, options?: OperationOptions, methods?: string[]): void; retry/LICENSE000066600000002237150432033150006722 0ustar00 MIT License Copyright (c) Microsoft Corporation. All rights reserved. Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE retry/package.json000066600000001440150432033150010176 0ustar00{ "name": "@types/retry", "version": "0.12.0", "description": "TypeScript definitions for retry", "license": "MIT", "contributors": [ { "name": "Stan Goldmann", "url": "https://github.com/krenor", "githubUsername": "krenor" }, { "name": "BendingBender", "url": "https://github.com/BendingBender", "githubUsername": "BendingBender" } ], "main": "", "types": "index", "repository": { "type": "git", "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git" }, "scripts": {}, "dependencies": {}, "typesPublisherContentHash": "dc8156aa3c27632d2585c45d8951c4a0f7ae9122bd17190d8973018556d174f3", "typeScriptVersion": "2.3" }json-schema/README.md000066600000001223150432033150010230 0ustar00# Installation > `npm install --save @types/json-schema` # Summary This package contains type definitions for json-schema 4.0, 6.0 and (https://github.com/kriszyp/json-schema). # Details Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/json-schema. ### Additional Details * Last updated: Fri, 25 Mar 2022 14:01:45 GMT * Dependencies: none * Global values: none # Credits These definitions were written by [Boris Cherny](https://github.com/bcherny), [Lucian Buzzo](https://github.com/lucianbuzzo), [Roland Groza](https://github.com/rolandjitsu), and [Jason Kwok](https://github.com/JasonHK). json-schema/index.d.ts000066600000070762150432033150010670 0ustar00// Type definitions for json-schema 4.0, 6.0 and 7.0 // Project: https://github.com/kriszyp/json-schema // Definitions by: Boris Cherny // Lucian Buzzo // Roland Groza // Jason Kwok // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped // TypeScript Version: 2.2 //================================================================================================== // JSON Schema Draft 04 //================================================================================================== /** * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.1 */ export type JSONSchema4TypeName = | 'string' // | 'number' | 'integer' | 'boolean' | 'object' | 'array' | 'null' | 'any'; /** * @see https://tools.ietf.org/html/draft-zyp-json-schema-04#section-3.5 */ export type JSONSchema4Type = | string // | number | boolean | JSONSchema4Object | JSONSchema4Array | null; // Workaround for infinite type recursion export interface JSONSchema4Object { [key: string]: JSONSchema4Type; } // Workaround for infinite type recursion // https://github.com/Microsoft/TypeScript/issues/3496#issuecomment-128553540 export interface JSONSchema4Array extends Array {} /** * Meta schema * * Recommended values: * - 'http://json-schema.org/schema#' * - 'http://json-schema.org/hyper-schema#' * - 'http://json-schema.org/draft-04/schema#' * - 'http://json-schema.org/draft-04/hyper-schema#' * - 'http://json-schema.org/draft-03/schema#' * - 'http://json-schema.org/draft-03/hyper-schema#' * * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5 */ export type JSONSchema4Version = string; /** * JSON Schema V4 * @see https://tools.ietf.org/html/draft-zyp-json-schema-04 */ export interface JSONSchema4 { id?: string | undefined; $ref?: string | undefined; $schema?: JSONSchema4Version | undefined; /** * This attribute is a string that provides a short description of the * instance property. * * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.21 */ title?: string | undefined; /** * This attribute is a string that provides a full description of the of * purpose the instance property. * * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.22 */ description?: string | undefined; default?: JSONSchema4Type | undefined; multipleOf?: number | undefined; maximum?: number | undefined; exclusiveMaximum?: boolean | undefined; minimum?: number | undefined; exclusiveMinimum?: boolean | undefined; maxLength?: number | undefined; minLength?: number | undefined; pattern?: string | undefined; /** * May only be defined when "items" is defined, and is a tuple of JSONSchemas. * * This provides a definition for additional items in an array instance * when tuple definitions of the items is provided. This can be false * to indicate additional items in the array are not allowed, or it can * be a schema that defines the schema of the additional items. * * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.6 */ additionalItems?: boolean | JSONSchema4 | undefined; /** * This attribute defines the allowed items in an instance array, and * MUST be a schema or an array of schemas. The default value is an * empty schema which allows any value for items in the instance array. * * When this attribute value is a schema and the instance value is an * array, then all the items in the array MUST be valid according to the * schema. * * When this attribute value is an array of schemas and the instance * value is an array, each position in the instance array MUST conform * to the schema in the corresponding position for this array. This * called tuple typing. When tuple typing is used, additional items are * allowed, disallowed, or constrained by the "additionalItems" * (Section 5.6) attribute using the same rules as * "additionalProperties" (Section 5.4) for objects. * * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.5 */ items?: JSONSchema4 | JSONSchema4[] | undefined; maxItems?: number | undefined; minItems?: number | undefined; uniqueItems?: boolean | undefined; maxProperties?: number | undefined; minProperties?: number | undefined; /** * This attribute indicates if the instance must have a value, and not * be undefined. This is false by default, making the instance * optional. * * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.7 */ required?: boolean | string[] | undefined; /** * This attribute defines a schema for all properties that are not * explicitly defined in an object type definition. If specified, the * value MUST be a schema or a boolean. If false is provided, no * additional properties are allowed beyond the properties defined in * the schema. The default value is an empty schema which allows any * value for additional properties. * * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.4 */ additionalProperties?: boolean | JSONSchema4 | undefined; definitions?: { [k: string]: JSONSchema4; } | undefined; /** * This attribute is an object with property definitions that define the * valid values of instance object property values. When the instance * value is an object, the property values of the instance object MUST * conform to the property definitions in this object. In this object, * each property definition's value MUST be a schema, and the property's * name MUST be the name of the instance property that it defines. The * instance property value MUST be valid according to the schema from * the property definition. Properties are considered unordered, the * order of the instance properties MAY be in any order. * * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.2 */ properties?: { [k: string]: JSONSchema4; } | undefined; /** * This attribute is an object that defines the schema for a set of * property names of an object instance. The name of each property of * this attribute's object is a regular expression pattern in the ECMA * 262/Perl 5 format, while the value is a schema. If the pattern * matches the name of a property on the instance object, the value of * the instance's property MUST be valid against the pattern name's * schema value. * * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.3 */ patternProperties?: { [k: string]: JSONSchema4; } | undefined; dependencies?: { [k: string]: JSONSchema4 | string[]; } | undefined; /** * This provides an enumeration of all possible values that are valid * for the instance property. This MUST be an array, and each item in * the array represents a possible value for the instance value. If * this attribute is defined, the instance value MUST be one of the * values in the array in order for the schema to be valid. * * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.19 */ enum?: JSONSchema4Type[] | undefined; /** * A single type, or a union of simple types */ type?: JSONSchema4TypeName | JSONSchema4TypeName[] | undefined; allOf?: JSONSchema4[] | undefined; anyOf?: JSONSchema4[] | undefined; oneOf?: JSONSchema4[] | undefined; not?: JSONSchema4 | undefined; /** * The value of this property MUST be another schema which will provide * a base schema which the current schema will inherit from. The * inheritance rules are such that any instance that is valid according * to the current schema MUST be valid according to the referenced * schema. This MAY also be an array, in which case, the instance MUST * be valid for all the schemas in the array. A schema that extends * another schema MAY define additional attributes, constrain existing * attributes, or add other constraints. * * Conceptually, the behavior of extends can be seen as validating an * instance against all constraints in the extending schema as well as * the extended schema(s). * * @see https://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.26 */ extends?: string | string[] | undefined; /** * @see https://tools.ietf.org/html/draft-zyp-json-schema-04#section-5.6 */ [k: string]: any; format?: string | undefined; } //================================================================================================== // JSON Schema Draft 06 //================================================================================================== export type JSONSchema6TypeName = | 'string' // | 'number' | 'integer' | 'boolean' | 'object' | 'array' | 'null' | 'any'; export type JSONSchema6Type = | string // | number | boolean | JSONSchema6Object | JSONSchema6Array | null; // Workaround for infinite type recursion export interface JSONSchema6Object { [key: string]: JSONSchema6Type; } // Workaround for infinite type recursion // https://github.com/Microsoft/TypeScript/issues/3496#issuecomment-128553540 export interface JSONSchema6Array extends Array {} /** * Meta schema * * Recommended values: * - 'http://json-schema.org/schema#' * - 'http://json-schema.org/hyper-schema#' * - 'http://json-schema.org/draft-06/schema#' * - 'http://json-schema.org/draft-06/hyper-schema#' * * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5 */ export type JSONSchema6Version = string; /** * JSON Schema V6 * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01 */ export type JSONSchema6Definition = JSONSchema6 | boolean; export interface JSONSchema6 { $id?: string | undefined; $ref?: string | undefined; $schema?: JSONSchema6Version | undefined; /** * Must be strictly greater than 0. * A numeric instance is valid only if division by this keyword's value results in an integer. * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.1 */ multipleOf?: number | undefined; /** * Representing an inclusive upper limit for a numeric instance. * This keyword validates only if the instance is less than or exactly equal to "maximum". * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.2 */ maximum?: number | undefined; /** * Representing an exclusive upper limit for a numeric instance. * This keyword validates only if the instance is strictly less than (not equal to) to "exclusiveMaximum". * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.3 */ exclusiveMaximum?: number | undefined; /** * Representing an inclusive lower limit for a numeric instance. * This keyword validates only if the instance is greater than or exactly equal to "minimum". * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.4 */ minimum?: number | undefined; /** * Representing an exclusive lower limit for a numeric instance. * This keyword validates only if the instance is strictly greater than (not equal to) to "exclusiveMinimum". * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.5 */ exclusiveMinimum?: number | undefined; /** * Must be a non-negative integer. * A string instance is valid against this keyword if its length is less than, or equal to, the value of this keyword. * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.6 */ maxLength?: number | undefined; /** * Must be a non-negative integer. * A string instance is valid against this keyword if its length is greater than, or equal to, the value of this keyword. * Omitting this keyword has the same behavior as a value of 0. * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.7 */ minLength?: number | undefined; /** * Should be a valid regular expression, according to the ECMA 262 regular expression dialect. * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.8 */ pattern?: string | undefined; /** * This keyword determines how child instances validate for arrays, and does not directly validate the immediate instance itself. * Omitting this keyword has the same behavior as an empty schema. * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.9 */ items?: JSONSchema6Definition | JSONSchema6Definition[] | undefined; /** * This keyword determines how child instances validate for arrays, and does not directly validate the immediate instance itself. * If "items" is an array of schemas, validation succeeds if every instance element * at a position greater than the size of "items" validates against "additionalItems". * Otherwise, "additionalItems" MUST be ignored, as the "items" schema * (possibly the default value of an empty schema) is applied to all elements. * Omitting this keyword has the same behavior as an empty schema. * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.10 */ additionalItems?: JSONSchema6Definition | undefined; /** * Must be a non-negative integer. * An array instance is valid against "maxItems" if its size is less than, or equal to, the value of this keyword. * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.11 */ maxItems?: number | undefined; /** * Must be a non-negative integer. * An array instance is valid against "maxItems" if its size is greater than, or equal to, the value of this keyword. * Omitting this keyword has the same behavior as a value of 0. * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.12 */ minItems?: number | undefined; /** * If this keyword has boolean value false, the instance validates successfully. * If it has boolean value true, the instance validates successfully if all of its elements are unique. * Omitting this keyword has the same behavior as a value of false. * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.13 */ uniqueItems?: boolean | undefined; /** * An array instance is valid against "contains" if at least one of its elements is valid against the given schema. * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.14 */ contains?: JSONSchema6Definition | undefined; /** * Must be a non-negative integer. * An object instance is valid against "maxProperties" if its number of properties is less than, or equal to, the value of this keyword. * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.15 */ maxProperties?: number | undefined; /** * Must be a non-negative integer. * An object instance is valid against "maxProperties" if its number of properties is greater than, * or equal to, the value of this keyword. * Omitting this keyword has the same behavior as a value of 0. * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.16 */ minProperties?: number | undefined; /** * Elements of this array must be unique. * An object instance is valid against this keyword if every item in the array is the name of a property in the instance. * Omitting this keyword has the same behavior as an empty array. * * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.17 */ required?: string[] | undefined; /** * This keyword determines how child instances validate for objects, and does not directly validate the immediate instance itself. * Validation succeeds if, for each name that appears in both the instance and as a name within this keyword's value, * the child instance for that name successfully validates against the corresponding schema. * Omitting this keyword has the same behavior as an empty object. * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.18 */ properties?: { [k: string]: JSONSchema6Definition; } | undefined; /** * This attribute is an object that defines the schema for a set of property names of an object instance. * The name of each property of this attribute's object is a regular expression pattern in the ECMA 262, while the value is a schema. * If the pattern matches the name of a property on the instance object, the value of the instance's property * MUST be valid against the pattern name's schema value. * Omitting this keyword has the same behavior as an empty object. * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.19 */ patternProperties?: { [k: string]: JSONSchema6Definition; } | undefined; /** * This attribute defines a schema for all properties that are not explicitly defined in an object type definition. * If specified, the value MUST be a schema or a boolean. * If false is provided, no additional properties are allowed beyond the properties defined in the schema. * The default value is an empty schema which allows any value for additional properties. * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.20 */ additionalProperties?: JSONSchema6Definition | undefined; /** * This keyword specifies rules that are evaluated if the instance is an object and contains a certain property. * Each property specifies a dependency. * If the dependency value is an array, each element in the array must be unique. * Omitting this keyword has the same behavior as an empty object. * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.21 */ dependencies?: { [k: string]: JSONSchema6Definition | string[]; } | undefined; /** * Takes a schema which validates the names of all properties rather than their values. * Note the property name that the schema is testing will always be a string. * Omitting this keyword has the same behavior as an empty schema. * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.22 */ propertyNames?: JSONSchema6Definition | undefined; /** * This provides an enumeration of all possible values that are valid * for the instance property. This MUST be an array, and each item in * the array represents a possible value for the instance value. If * this attribute is defined, the instance value MUST be one of the * values in the array in order for the schema to be valid. * * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.23 */ enum?: JSONSchema6Type[] | undefined; /** * More readable form of a one-element "enum" * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.24 */ const?: JSONSchema6Type | undefined; /** * A single type, or a union of simple types * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.25 */ type?: JSONSchema6TypeName | JSONSchema6TypeName[] | undefined; /** * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.26 */ allOf?: JSONSchema6Definition[] | undefined; /** * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.27 */ anyOf?: JSONSchema6Definition[] | undefined; /** * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.28 */ oneOf?: JSONSchema6Definition[] | undefined; /** * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.29 */ not?: JSONSchema6Definition | undefined; /** * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.1 */ definitions?: { [k: string]: JSONSchema6Definition; } | undefined; /** * This attribute is a string that provides a short description of the instance property. * * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.2 */ title?: string | undefined; /** * This attribute is a string that provides a full description of the of purpose the instance property. * * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.2 */ description?: string | undefined; /** * This keyword can be used to supply a default JSON value associated with a particular schema. * It is RECOMMENDED that a default value be valid against the associated schema. * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.3 */ default?: JSONSchema6Type | undefined; /** * Array of examples with no validation effect the value of "default" is usable as an example without repeating it under this keyword * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.4 */ examples?: JSONSchema6Type[] | undefined; /** * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-8 */ format?: string | undefined; } //================================================================================================== // JSON Schema Draft 07 //================================================================================================== // https://tools.ietf.org/html/draft-handrews-json-schema-validation-01 //-------------------------------------------------------------------------------------------------- /** * Primitive type * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1.1 */ export type JSONSchema7TypeName = | 'string' // | 'number' | 'integer' | 'boolean' | 'object' | 'array' | 'null'; /** * Primitive type * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1.1 */ export type JSONSchema7Type = | string // | number | boolean | JSONSchema7Object | JSONSchema7Array | null; // Workaround for infinite type recursion export interface JSONSchema7Object { [key: string]: JSONSchema7Type; } // Workaround for infinite type recursion // https://github.com/Microsoft/TypeScript/issues/3496#issuecomment-128553540 export interface JSONSchema7Array extends Array {} /** * Meta schema * * Recommended values: * - 'http://json-schema.org/schema#' * - 'http://json-schema.org/hyper-schema#' * - 'http://json-schema.org/draft-07/schema#' * - 'http://json-schema.org/draft-07/hyper-schema#' * * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5 */ export type JSONSchema7Version = string; /** * JSON Schema v7 * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01 */ export type JSONSchema7Definition = JSONSchema7 | boolean; export interface JSONSchema7 { $id?: string | undefined; $ref?: string | undefined; $schema?: JSONSchema7Version | undefined; $comment?: string | undefined; /** * @see https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-00#section-8.2.4 * @see https://datatracker.ietf.org/doc/html/draft-bhutton-json-schema-validation-00#appendix-A */ $defs?: { [key: string]: JSONSchema7Definition; } | undefined; /** * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.1 */ type?: JSONSchema7TypeName | JSONSchema7TypeName[] | undefined; enum?: JSONSchema7Type[] | undefined; const?: JSONSchema7Type | undefined; /** * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.2 */ multipleOf?: number | undefined; maximum?: number | undefined; exclusiveMaximum?: number | undefined; minimum?: number | undefined; exclusiveMinimum?: number | undefined; /** * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.3 */ maxLength?: number | undefined; minLength?: number | undefined; pattern?: string | undefined; /** * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.4 */ items?: JSONSchema7Definition | JSONSchema7Definition[] | undefined; additionalItems?: JSONSchema7Definition | undefined; maxItems?: number | undefined; minItems?: number | undefined; uniqueItems?: boolean | undefined; contains?: JSONSchema7 | undefined; /** * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.5 */ maxProperties?: number | undefined; minProperties?: number | undefined; required?: string[] | undefined; properties?: { [key: string]: JSONSchema7Definition; } | undefined; patternProperties?: { [key: string]: JSONSchema7Definition; } | undefined; additionalProperties?: JSONSchema7Definition | undefined; dependencies?: { [key: string]: JSONSchema7Definition | string[]; } | undefined; propertyNames?: JSONSchema7Definition | undefined; /** * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.6 */ if?: JSONSchema7Definition | undefined; then?: JSONSchema7Definition | undefined; else?: JSONSchema7Definition | undefined; /** * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-6.7 */ allOf?: JSONSchema7Definition[] | undefined; anyOf?: JSONSchema7Definition[] | undefined; oneOf?: JSONSchema7Definition[] | undefined; not?: JSONSchema7Definition | undefined; /** * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-7 */ format?: string | undefined; /** * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-8 */ contentMediaType?: string | undefined; contentEncoding?: string | undefined; /** * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-9 */ definitions?: { [key: string]: JSONSchema7Definition; } | undefined; /** * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-10 */ title?: string | undefined; description?: string | undefined; default?: JSONSchema7Type | undefined; readOnly?: boolean | undefined; writeOnly?: boolean | undefined; examples?: JSONSchema7Type | undefined; } export interface ValidationResult { valid: boolean; errors: ValidationError[]; } export interface ValidationError { property: string; message: string; } /** * To use the validator call JSONSchema.validate with an instance object and an optional schema object. * If a schema is provided, it will be used to validate. If the instance object refers to a schema (self-validating), * that schema will be used to validate and the schema parameter is not necessary (if both exist, * both validations will occur). */ export function validate(instance: {}, schema: JSONSchema4 | JSONSchema6 | JSONSchema7): ValidationResult; /** * The checkPropertyChange method will check to see if an value can legally be in property with the given schema * This is slightly different than the validate method in that it will fail if the schema is readonly and it will * not check for self-validation, it is assumed that the passed in value is already internally valid. */ export function checkPropertyChange( value: any, schema: JSONSchema4 | JSONSchema6 | JSONSchema7, property: string, ): ValidationResult; /** * This checks to ensure that the result is valid and will throw an appropriate error message if it is not. */ export function mustBeValid(result: ValidationResult): void; json-schema/LICENSE000066600000002165150432033150007764 0ustar00 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 json-schema/package.json000066600000002362150432033150011244 0ustar00{ "name": "@types/json-schema", "version": "7.0.11", "description": "TypeScript definitions for json-schema 4.0, 6.0 and", "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/json-schema", "license": "MIT", "contributors": [ { "name": "Boris Cherny", "url": "https://github.com/bcherny", "githubUsername": "bcherny" }, { "name": "Lucian Buzzo", "url": "https://github.com/lucianbuzzo", "githubUsername": "lucianbuzzo" }, { "name": "Roland Groza", "url": "https://github.com/rolandjitsu", "githubUsername": "rolandjitsu" }, { "name": "Jason Kwok", "url": "https://github.com/JasonHK", "githubUsername": "JasonHK" } ], "main": "", "types": "index.d.ts", "repository": { "type": "git", "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git", "directory": "types/json-schema" }, "scripts": {}, "dependencies": {}, "typesPublisherContentHash": "84a402b9e31ddb097f08b5c07c08590bf087035c483db7a4071a04903775dc44", "typeScriptVersion": "3.9" }range-parser/README.md000066600000003517150432033150010417 0ustar00# Installation > `npm install --save @types/range-parser` # Summary This package contains type definitions for range-parser (https://github.com/jshttp/range-parser). # Details Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/range-parser. ## [index.d.ts](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/range-parser/index.d.ts) ````ts // Type definitions for range-parser 1.2 // Project: https://github.com/jshttp/range-parser // Definitions by: Tomek Łaziuk // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped /** * When ranges are returned, the array has a "type" property which is the type of * range that is required (most commonly, "bytes"). Each array element is an object * with a "start" and "end" property for the portion of the range. * * @returns `-1` when unsatisfiable and `-2` when syntactically invalid, ranges otherwise. */ declare function RangeParser(size: number, str: string, options?: RangeParser.Options): RangeParser.Result | RangeParser.Ranges; declare namespace RangeParser { interface Ranges extends Array { type: string; } interface Range { start: number; end: number; } interface Options { /** * The "combine" option can be set to `true` and overlapping & adjacent ranges * will be combined into a single range. */ combine?: boolean | undefined; } type ResultUnsatisfiable = -1; type ResultInvalid = -2; type Result = ResultUnsatisfiable | ResultInvalid; } export = RangeParser; ```` ### Additional Details * Last updated: Wed, 07 Jul 2021 17:02:53 GMT * Dependencies: none * Global values: none # Credits These definitions were written by [Tomek Łaziuk](https://github.com/tlaziuk). range-parser/index.d.ts000066600000002324150432033150011034 0ustar00// Type definitions for range-parser 1.2 // Project: https://github.com/jshttp/range-parser // Definitions by: Tomek Łaziuk // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped /** * When ranges are returned, the array has a "type" property which is the type of * range that is required (most commonly, "bytes"). Each array element is an object * with a "start" and "end" property for the portion of the range. * * @returns `-1` when unsatisfiable and `-2` when syntactically invalid, ranges otherwise. */ declare function RangeParser(size: number, str: string, options?: RangeParser.Options): RangeParser.Result | RangeParser.Ranges; declare namespace RangeParser { interface Ranges extends Array { type: string; } interface Range { start: number; end: number; } interface Options { /** * The "combine" option can be set to `true` and overlapping & adjacent ranges * will be combined into a single range. */ combine?: boolean | undefined; } type ResultUnsatisfiable = -1; type ResultInvalid = -2; type Result = ResultUnsatisfiable | ResultInvalid; } export = RangeParser; range-parser/LICENSE000066600000002165150432033150010143 0ustar00 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 range-parser/package.json000066600000001445150432033150011424 0ustar00{ "name": "@types/range-parser", "version": "1.2.4", "description": "TypeScript definitions for range-parser", "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/range-parser", "license": "MIT", "contributors": [ { "name": "Tomek Łaziuk", "url": "https://github.com/tlaziuk", "githubUsername": "tlaziuk" } ], "main": "", "types": "index.d.ts", "repository": { "type": "git", "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git", "directory": "types/range-parser" }, "scripts": {}, "dependencies": {}, "typesPublisherContentHash": "60a027a88ae9d7c5ae30935c98266f5033af3c38944121c975bf5e136b9053f3", "typeScriptVersion": "3.6" }minimatch/README.md000066600000001123150432033150007771 0ustar00# Installation > `npm install --save @types/minimatch` # Summary This package contains type definitions for minimatch (https://github.com/isaacs/minimatch). # Details Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/minimatch. ### Additional Details * Last updated: Wed, 31 Aug 2022 17:32:44 GMT * Dependencies: none * Global values: none # Credits These definitions were written by [vvakame](https://github.com/vvakame), [Shant Marouti](https://github.com/shantmarouti), and [BendingBender](https://github.com/BendingBender). minimatch/index.d.ts000066600000022723150432033150010424 0ustar00// Type definitions for minimatch 5.1 // Project: https://github.com/isaacs/minimatch // Definitions by: vvakame // Shant Marouti // BendingBender // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped /** * Tests a path against the pattern using the options. * * @example * import minimatch = require("minimatch"); * * const isJS = minimatch(file, "*.js", { matchBase: true }); */ declare function minimatch(target: string, pattern: string, options?: minimatch.IOptions): boolean; declare namespace minimatch { /** * Match against the list of files, in the style of fnmatch or glob. * If nothing is matched, and options.nonull is set, * then return a list containing the pattern itself. * * @example * import minimatch = require("minimatch"); * * const javascripts = minimatch.match(fileList, "*.js", {matchBase: true}); */ function match(list: readonly string[], pattern: string, options?: IOptions): string[]; /** * @return A function that tests its supplied argument, suitable for use with `Array.filter`. * * @example * import minimatch = require("minimatch"); * * const javascripts = fileList.filter(minimatch.filter("*.js", {matchBase: true})); */ function filter( pattern: string, options?: IOptions, ): (element: string, indexed: number, array: readonly string[]) => boolean; /** * Make a regular expression object from the pattern. */ function makeRe(pattern: string, options?: IOptions): RegExp | false; function defaults(defaultOptions: IOptions): typeof minimatch; function braceExpand(pattern: string, options?: IOptions): string[]; const sep: string; const GLOBSTAR: unique symbol; interface IOptions { /** * Dump a ton of stuff to stderr. * * @default false */ debug?: boolean | undefined; /** * Do not expand `{a,b}` and `{1..3}` brace sets. * * @default false */ nobrace?: boolean | undefined; /** * Disable `**` matching against multiple folder names. * * @default false */ noglobstar?: boolean | undefined; /** * Allow patterns to match filenames starting with a period, * even if the pattern does not explicitly have a period in that spot. * * Note that by default, `'a/**' + '/b'` will **not** match `a/.d/b`, unless `dot` is set. * * @default false */ dot?: boolean | undefined; /** * Disable "extglob" style patterns like `+(a|b)`. * * @default false */ noext?: boolean | undefined; /** * Perform a case-insensitive match. * * @default false */ nocase?: boolean | undefined; /** * When a match is not found by `minimatch.match`, * return a list containing the pattern itself if this option is set. * Otherwise, an empty list is returned if there are no matches. * * @default false */ nonull?: boolean | undefined; /** * If set, then patterns without slashes will be matched * against the basename of the path if it contains slashes. For example, * `a?b` would match the path `/xyz/123/acb`, but not `/xyz/acb/123`. * * @default false */ matchBase?: boolean | undefined; /** * Suppress the behavior of treating `#` at the start of a pattern as a comment. * * @default false */ nocomment?: boolean | undefined; /** * Suppress the behavior of treating a leading `!` character as negation. * * @default false */ nonegate?: boolean | undefined; /** * Returns from negate expressions the same as if they were not negated. * (Ie, true on a hit, false on a miss.) * * @default false */ flipNegate?: boolean | undefined; /** * Compare a partial path to a pattern. As long as the parts of the path that * are present are not contradicted by the pattern, it will be treated as a * match. This is useful in applications where you're walking through a * folder structure, and don't yet have the full path, but want to ensure that * you do not walk down paths that can never be a match. * * @default false * * @example * import minimatch = require("minimatch"); * * minimatch('/a/b', '/a/*' + '/c/d', { partial: true }) // true, might be /a/b/c/d * minimatch('/a/b', '/**' + '/d', { partial: true }) // true, might be /a/b/.../d * minimatch('/x/y/z', '/a/**' + '/z', { partial: true }) // false, because x !== a */ partial?: boolean; /** * Use `\\` as a path separator _only_, and _never_ as an escape * character. If set, all `\\` characters are replaced with `/` in * the pattern. Note that this makes it **impossible** to match * against paths containing literal glob pattern characters, but * allows matching with patterns constructed using `path.join()` and * `path.resolve()` on Windows platforms, mimicking the (buggy!) * behavior of earlier versions on Windows. Please use with * caution, and be mindful of the caveat about Windows paths * * For legacy reasons, this is also set if * `options.allowWindowsEscape` is set to the exact value `false`. * * @default false */ windowsPathsNoEscape?: boolean; } /** * @deprecated Keep legacy interface to prevent unnecessary breakage. */ type IMinimatchStatic = typeof Minimatch; /** * @deprecated Keep legacy interface to prevent unnecessary breakage. */ type IMinimatch = Minimatch; /** * Create a minimatch object by instantiating the `minimatch.Minimatch` class. * * @example * import { Minimatch } from "minimatch"; * * const mm = new Minimatch(pattern, options); */ class Minimatch { constructor(pattern: string, options?: IOptions); static defaults(defaultOptions: IOptions): typeof Minimatch; /** * The original pattern the minimatch object represents. */ pattern: string; /** * The options supplied to the constructor. */ options: IOptions; /** * A 2-dimensional array of regexp or string expressions. Each row in the array corresponds * to a brace-expanded pattern. Each item in the row corresponds to a single path-part. For * example, the pattern `{a,b/c}/d` would expand to a set of patterns like: * * ``` * [ [ a, d ] * , [ b, c, d ] ] * ``` * * If a portion of the pattern doesn't have any "magic" in it (that is, it's something like `"foo"`` * rather than `fo*o?`), then it will be left as a string rather than converted to a regular expression. */ set: Array>; /** * Created by the `makeRe` method. A single regular expression expressing the entire pattern. This is * useful in cases where you wish to use the pattern somewhat like `fnmatch(3)` with `FNM_PATH` enabled. */ regexp: RegExp | false | null; /** * True if the pattern is negated. */ negate: boolean; /** * True if the pattern is a comment. */ comment: boolean; /** * True if the pattern is `""`. */ empty: boolean; /** * True if windows path delimiters shouldn't be interpreted as escape characters. */ windowsPathsNoEscape: boolean; /** * True if partial paths should be compared to a pattern. */ partial: boolean; /** * Generate the `regexp` member if necessary, and return it. Will return `false` if the pattern is invalid. */ makeRe(): RegExp | false; /** * @return `true` if the filename matches the pattern, or `false` otherwise. */ match(fname: string, partial?: boolean): boolean; /** * Take a `/`-split filename, and match it against a single row in the `regExpSet`. * This method is mainly for internal use, but is exposed so that it can be used * by a glob-walker that needs to avoid excessive filesystem calls. */ matchOne(file: readonly string[], pattern: ReadonlyArray, partial: boolean): boolean; /** * @deprecated. For internal use. */ debug(): void; /** * @deprecated. For internal use. */ make(): void; /** * @deprecated. For internal use. */ parseNegate(): void; /** * @deprecated. For internal use. */ braceExpand(): string[]; /** * @deprecated. For internal use. */ parse(pattern: string, isSub?: boolean): string | false | [string, boolean] | RegExp | typeof GLOBSTAR; } } export = minimatch; minimatch/LICENSE000066600000002165150432033150007526 0ustar00 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 minimatch/package.json000066600000002117150432033150011004 0ustar00{ "name": "@types/minimatch", "version": "5.1.2", "description": "TypeScript definitions for minimatch", "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/minimatch", "license": "MIT", "contributors": [ { "name": "vvakame", "url": "https://github.com/vvakame", "githubUsername": "vvakame" }, { "name": "Shant Marouti", "url": "https://github.com/shantmarouti", "githubUsername": "shantmarouti" }, { "name": "BendingBender", "url": "https://github.com/BendingBender", "githubUsername": "BendingBender" } ], "main": "", "types": "index.d.ts", "repository": { "type": "git", "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git", "directory": "types/minimatch" }, "scripts": {}, "dependencies": {}, "typesPublisherContentHash": "266f2226f04264f59fb2aeb3afc253d311ddd99b4ae8534d2e27f8a1379203e4", "typeScriptVersion": "4.1" }body-parser/README.md000066600000001614150432033150010254 0ustar00# Installation > `npm install --save @types/body-parser` # Summary This package contains type definitions for body-parser (https://github.com/expressjs/body-parser). # Details Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/body-parser. ### Additional Details * Last updated: Tue, 16 Nov 2021 18:31:30 GMT * Dependencies: [@types/connect](https://npmjs.com/package/@types/connect), [@types/node](https://npmjs.com/package/@types/node) * Global values: none # Credits These definitions were written by [Santi Albo](https://github.com/santialbo), [Vilic Vane](https://github.com/vilic), [Jonathan Häberle](https://github.com/dreampulse), [Gevik Babakhani](https://github.com/blendsdk), [Tomasz Łaziuk](https://github.com/tlaziuk), [Jason Walton](https://github.com/jwalton), and [Piotr Błażejewicz](https://github.com/peterblazejewicz). body-parser/index.d.ts000066600000010566150432033150010704 0ustar00// Type definitions for body-parser 1.19 // Project: https://github.com/expressjs/body-parser // Definitions by: Santi Albo // Vilic Vane // Jonathan Häberle // Gevik Babakhani // Tomasz Łaziuk // Jason Walton // Piotr Błażejewicz // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped /// import { NextHandleFunction } from 'connect'; import * as http from 'http'; // for docs go to https://github.com/expressjs/body-parser/tree/1.19.0#body-parser declare namespace bodyParser { interface BodyParser { /** * @deprecated use individual json/urlencoded middlewares */ (options?: OptionsJson & OptionsText & OptionsUrlencoded): NextHandleFunction; /** * Returns middleware that only parses json and only looks at requests * where the Content-Type header matches the type option. */ json(options?: OptionsJson): NextHandleFunction; /** * Returns middleware that parses all bodies as a Buffer and only looks at requests * where the Content-Type header matches the type option. */ raw(options?: Options): NextHandleFunction; /** * Returns middleware that parses all bodies as a string and only looks at requests * where the Content-Type header matches the type option. */ text(options?: OptionsText): NextHandleFunction; /** * Returns middleware that only parses urlencoded bodies and only looks at requests * where the Content-Type header matches the type option */ urlencoded(options?: OptionsUrlencoded): NextHandleFunction; } interface Options { /** When set to true, then deflated (compressed) bodies will be inflated; when false, deflated bodies are rejected. Defaults to true. */ inflate?: boolean | undefined; /** * Controls the maximum request body size. If this is a number, * then the value specifies the number of bytes; if it is a string, * the value is passed to the bytes library for parsing. Defaults to '100kb'. */ limit?: number | string | undefined; /** * The type option is used to determine what media type the middleware will parse */ type?: string | string[] | ((req: http.IncomingMessage) => any) | undefined; /** * The verify option, if supplied, is called as verify(req, res, buf, encoding), * where buf is a Buffer of the raw request body and encoding is the encoding of the request. */ verify?(req: http.IncomingMessage, res: http.ServerResponse, buf: Buffer, encoding: string): void; } interface OptionsJson extends Options { /** * * The reviver option is passed directly to JSON.parse as the second argument. */ reviver?(key: string, value: any): any; /** * When set to `true`, will only accept arrays and objects; * when `false` will accept anything JSON.parse accepts. Defaults to `true`. */ strict?: boolean | undefined; } interface OptionsText extends Options { /** * Specify the default character set for the text content if the charset * is not specified in the Content-Type header of the request. * Defaults to `utf-8`. */ defaultCharset?: string | undefined; } interface OptionsUrlencoded extends Options { /** * The extended option allows to choose between parsing the URL-encoded data * with the querystring library (when `false`) or the qs library (when `true`). */ extended?: boolean | undefined; /** * The parameterLimit option controls the maximum number of parameters * that are allowed in the URL-encoded data. If a request contains more parameters than this value, * a 413 will be returned to the client. Defaults to 1000. */ parameterLimit?: number | undefined; } } declare const bodyParser: bodyParser.BodyParser; export = bodyParser; body-parser/LICENSE000066600000002165150432033150010004 0ustar00 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 body-parser/package.json000066600000003363150432033150011266 0ustar00{ "name": "@types/body-parser", "version": "1.19.2", "description": "TypeScript definitions for body-parser", "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/body-parser", "license": "MIT", "contributors": [ { "name": "Santi Albo", "url": "https://github.com/santialbo", "githubUsername": "santialbo" }, { "name": "Vilic Vane", "url": "https://github.com/vilic", "githubUsername": "vilic" }, { "name": "Jonathan Häberle", "url": "https://github.com/dreampulse", "githubUsername": "dreampulse" }, { "name": "Gevik Babakhani", "url": "https://github.com/blendsdk", "githubUsername": "blendsdk" }, { "name": "Tomasz Łaziuk", "url": "https://github.com/tlaziuk", "githubUsername": "tlaziuk" }, { "name": "Jason Walton", "url": "https://github.com/jwalton", "githubUsername": "jwalton" }, { "name": "Piotr Błażejewicz", "url": "https://github.com/peterblazejewicz", "githubUsername": "peterblazejewicz" } ], "main": "", "types": "index.d.ts", "repository": { "type": "git", "url": "https://github.com/DefinitelyTyped/DefinitelyTyped.git", "directory": "types/body-parser" }, "scripts": {}, "dependencies": { "@types/connect": "*", "@types/node": "*" }, "typesPublisherContentHash": "ad069aa8b9e8a95f66df025de11975c773540e4071000abdb7db565579b013ee", "typeScriptVersion": "3.7" }babel__generator/README.md000066600000001352150432033150011276 0ustar00# Installation > `npm install --save @types/babel__generator` # Summary This package contains type definitions for @babel/generator (https://github.com/babel/babel/tree/master/packages/babel-generator). # Details Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/babel__generator. ### Additional Details * Last updated: Thu, 23 Dec 2021 23:34:17 GMT * Dependencies: [@types/babel__types](https://npmjs.com/package/@types/babel__types) * Global values: none # Credits These definitions were written by [Troy Gerwien](https://github.com/yortus), [Melvin Groenhoff](https://github.com/mgroenhoff), [Cameron Yan](https://github.com/khell), and [Lyanbin](https://github.com/Lyanbin). babel__generator/index.d.ts000066600000020442150432033150011721 0ustar00// Type definitions for @babel/generator 7.6 // Project: https://github.com/babel/babel/tree/master/packages/babel-generator, https://babeljs.io // Definitions by: Troy Gerwien // Melvin Groenhoff // Cameron Yan // Lyanbin // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped // TypeScript Version: 2.9 import * as t from '@babel/types'; export interface GeneratorOptions { /** * Optional string to add as a block comment at the start of the output file. */ auxiliaryCommentBefore?: string | undefined; /** * Optional string to add as a block comment at the end of the output file. */ auxiliaryCommentAfter?: string | undefined; /** * Function that takes a comment (as a string) and returns true if the comment should be included in the output. * By default, comments are included if `opts.comments` is `true` or if `opts.minifed` is `false` and the comment * contains `@preserve` or `@license`. */ shouldPrintComment?(comment: string): boolean; /** * Attempt to use the same line numbers in the output code as in the source code (helps preserve stack traces). * Defaults to `false`. */ retainLines?: boolean | undefined; /** * Retain parens around function expressions (could be used to change engine parsing behavior) * Defaults to `false`. */ retainFunctionParens?: boolean | undefined; /** * Should comments be included in output? Defaults to `true`. */ comments?: boolean | undefined; /** * Set to true to avoid adding whitespace for formatting. Defaults to the value of `opts.minified`. */ compact?: boolean | 'auto' | undefined; /** * Should the output be minified. Defaults to `false`. */ minified?: boolean | undefined; /** * Set to true to reduce whitespace (but not as much as opts.compact). Defaults to `false`. */ concise?: boolean | undefined; /** * Used in warning messages */ filename?: string | undefined; /** * Enable generating source maps. Defaults to `false`. */ sourceMaps?: boolean | undefined; /** * A root for all relative URLs in the source map. */ sourceRoot?: string | undefined; /** * The filename for the source code (i.e. the code in the `code` argument). * This will only be used if `code` is a string. */ sourceFileName?: string | undefined; /** * Set to true to run jsesc with "json": true to print "\u00A9" vs. "©"; */ jsonCompatibleStrings?: boolean | undefined; /** * Set to true to enable support for experimental decorators syntax before module exports. * Defaults to `false`. */ decoratorsBeforeExport?: boolean | undefined; /** * Options for outputting jsesc representation. */ jsescOption?: { /** * The default value for the quotes option is 'single'. This means that any occurrences of ' in the input * string are escaped as \', so that the output can be used in a string literal wrapped in single quotes. */ quotes?: 'single' | 'double' | 'backtick' | undefined; /** * The default value for the numbers option is 'decimal'. This means that any numeric values are represented * using decimal integer literals. Other valid options are binary, octal, and hexadecimal, which result in * binary integer literals, octal integer literals, and hexadecimal integer literals, respectively. */ numbers?: 'binary' | 'octal' | 'decimal' | 'hexadecimal' | undefined; /** * The wrap option takes a boolean value (true or false), and defaults to false (disabled). When enabled, the * output is a valid JavaScript string literal wrapped in quotes. The type of quotes can be specified through * the quotes setting. */ wrap?: boolean | undefined; /** * The es6 option takes a boolean value (true or false), and defaults to false (disabled). When enabled, any * astral Unicode symbols in the input are escaped using ECMAScript 6 Unicode code point escape sequences * instead of using separate escape sequences for each surrogate half. If backwards compatibility with ES5 * environments is a concern, don’t enable this setting. If the json setting is enabled, the value for the es6 * setting is ignored (as if it was false). */ es6?: boolean | undefined; /** * The escapeEverything option takes a boolean value (true or false), and defaults to false (disabled). When * enabled, all the symbols in the output are escaped — even printable ASCII symbols. */ escapeEverything?: boolean | undefined; /** * The minimal option takes a boolean value (true or false), and defaults to false (disabled). When enabled, * only a limited set of symbols in the output are escaped: \0, \b, \t, \n, \f, \r, \\, \u2028, \u2029. */ minimal?: boolean | undefined; /** * The isScriptContext option takes a boolean value (true or false), and defaults to false (disabled). When * enabled, occurrences of or