.config/coc/extensions/node_modules/coc-prettier/node_modules/regexpp/index.d.ts

   1 // Generated by dts-bundle v0.7.3\r
   2 \r
   3 declare module 'regexpp' {\r
   4     import * as AST from "regexpp/ast";\r
   5     import { RegExpParser } from "regexpp/parser";\r
   6     import { RegExpValidator } from "regexpp/validator";\r
   7     import { RegExpVisitor } from "regexpp/visitor";\r
   8     export { AST, RegExpParser, RegExpValidator };\r
   9     export function parseRegExpLiteral(source: string | RegExp, options?: RegExpParser.Options): AST.RegExpLiteral;\r
  10     export function validateRegExpLiteral(source: string, options?: RegExpValidator.Options): void;\r
  11     export function visitRegExpAST(node: AST.Node, handlers: RegExpVisitor.Handlers): void;\r
  12 }\r
  13 \r
  14 declare module 'regexpp/ast' {\r
  15     export type Node = BranchNode | LeafNode;\r
  16     export type BranchNode = RegExpLiteral | Pattern | Alternative | Group | CapturingGroup | Quantifier | CharacterClass | LookaroundAssertion | CharacterClassRange;\r
  17     export type LeafNode = BoundaryAssertion | CharacterSet | Character | Backreference | Flags;\r
  18     export type Element = Assertion | Quantifier | QuantifiableElement;\r
  19     export type QuantifiableElement = Group | CapturingGroup | CharacterClass | CharacterSet | Character | Backreference | LookaheadAssertion;\r
  20     export type CharacterClassElement = EscapeCharacterSet | UnicodePropertyCharacterSet | Character | CharacterClassRange;\r
  21     export interface NodeBase {\r
  22         type: Node["type"];\r
  23         parent: Node["parent"];\r
  24         start: number;\r
  25         end: number;\r
  26         raw: string;\r
  27     }\r
  28     export interface RegExpLiteral extends NodeBase {\r
  29         type: "RegExpLiteral";\r
  30         parent: null;\r
  31         pattern: Pattern;\r
  32         flags: Flags;\r
  33     }\r
  34     export interface Pattern extends NodeBase {\r
  35         type: "Pattern";\r
  36         parent: RegExpLiteral | null;\r
  37         alternatives: Alternative[];\r
  38     }\r
  39     export interface Alternative extends NodeBase {\r
  40         type: "Alternative";\r
  41         parent: Pattern | Group | CapturingGroup | LookaroundAssertion;\r
  42         elements: Element[];\r
  43     }\r
  44     export interface Group extends NodeBase {\r
  45         type: "Group";\r
  46         parent: Alternative | Quantifier;\r
  47         alternatives: Alternative[];\r
  48     }\r
  49     export interface CapturingGroup extends NodeBase {\r
  50         type: "CapturingGroup";\r
  51         parent: Alternative | Quantifier;\r
  52         name: string | null;\r
  53         alternatives: Alternative[];\r
  54         references: Backreference[];\r
  55     }\r
  56     export type LookaroundAssertion = LookaheadAssertion | LookbehindAssertion;\r
  57     export interface LookaheadAssertion extends NodeBase {\r
  58         type: "Assertion";\r
  59         parent: Alternative | Quantifier;\r
  60         kind: "lookahead";\r
  61         negate: boolean;\r
  62         alternatives: Alternative[];\r
  63     }\r
  64     export interface LookbehindAssertion extends NodeBase {\r
  65         type: "Assertion";\r
  66         parent: Alternative;\r
  67         kind: "lookbehind";\r
  68         negate: boolean;\r
  69         alternatives: Alternative[];\r
  70     }\r
  71     export interface Quantifier extends NodeBase {\r
  72         type: "Quantifier";\r
  73         parent: Alternative;\r
  74         min: number;\r
  75         max: number;\r
  76         greedy: boolean;\r
  77         element: QuantifiableElement;\r
  78     }\r
  79     export interface CharacterClass extends NodeBase {\r
  80         type: "CharacterClass";\r
  81         parent: Alternative | Quantifier;\r
  82         negate: boolean;\r
  83         elements: CharacterClassElement[];\r
  84     }\r
  85     export interface CharacterClassRange extends NodeBase {\r
  86         type: "CharacterClassRange";\r
  87         parent: CharacterClass;\r
  88         min: Character;\r
  89         max: Character;\r
  90     }\r
  91     export type Assertion = BoundaryAssertion | LookaroundAssertion;\r
  92     export type BoundaryAssertion = EdgeAssertion | WordBoundaryAssertion;\r
  93     export interface EdgeAssertion extends NodeBase {\r
  94         type: "Assertion";\r
  95         parent: Alternative | Quantifier;\r
  96         kind: "start" | "end";\r
  97     }\r
  98     export interface WordBoundaryAssertion extends NodeBase {\r
  99         type: "Assertion";\r
 100         parent: Alternative | Quantifier;\r
 101         kind: "word";\r
 102         negate: boolean;\r
 103     }\r
 104     export type CharacterSet = AnyCharacterSet | EscapeCharacterSet | UnicodePropertyCharacterSet;\r
 105     export interface AnyCharacterSet extends NodeBase {\r
 106         type: "CharacterSet";\r
 107         parent: Alternative | Quantifier;\r
 108         kind: "any";\r
 109     }\r
 110     export interface EscapeCharacterSet extends NodeBase {\r
 111         type: "CharacterSet";\r
 112         parent: Alternative | Quantifier | CharacterClass;\r
 113         kind: "digit" | "space" | "word";\r
 114         negate: boolean;\r
 115     }\r
 116     export interface UnicodePropertyCharacterSet extends NodeBase {\r
 117         type: "CharacterSet";\r
 118         parent: Alternative | Quantifier | CharacterClass;\r
 119         kind: "property";\r
 120         key: string;\r
 121         value: string | null;\r
 122         negate: boolean;\r
 123     }\r
 124     export interface Character extends NodeBase {\r
 125         type: "Character";\r
 126         parent: Alternative | Quantifier | CharacterClass | CharacterClassRange;\r
 127         value: number;\r
 128     }\r
 129     export interface Backreference extends NodeBase {\r
 130         type: "Backreference";\r
 131         parent: Alternative | Quantifier;\r
 132         ref: number | string;\r
 133         resolved: CapturingGroup;\r
 134     }\r
 135     export interface Flags extends NodeBase {\r
 136         type: "Flags";\r
 137         parent: RegExpLiteral | null;\r
 138         dotAll: boolean;\r
 139         global: boolean;\r
 140         ignoreCase: boolean;\r
 141         multiline: boolean;\r
 142         sticky: boolean;\r
 143         unicode: boolean;\r
 144     }\r
 145 }\r
 146 \r
 147 declare module 'regexpp/parser' {\r
 148     import { Flags, RegExpLiteral, Pattern } from "regexpp/ast";\r
 149     import { EcmaVersion } from "regexpp/ecma-versions";\r
 150     export namespace RegExpParser {\r
 151         interface Options {\r
 152             strict?: boolean;\r
 153             ecmaVersion?: EcmaVersion;\r
 154         }\r
 155     }\r
 156     export class RegExpParser {\r
 157         constructor(options?: RegExpParser.Options);\r
 158         parseLiteral(source: string, start?: number, end?: number): RegExpLiteral;\r
 159         parseFlags(source: string, start?: number, end?: number): Flags;\r
 160         parsePattern(source: string, start?: number, end?: number, uFlag?: boolean): Pattern;\r
 161     }\r
 162 }\r
 163 \r
 164 declare module 'regexpp/validator' {\r
 165     import { EcmaVersion } from "regexpp/ecma-versions";\r
 166     export namespace RegExpValidator {\r
 167         interface Options {\r
 168             strict?: boolean;\r
 169             ecmaVersion?: EcmaVersion;\r
 170             onLiteralEnter?(start: number): void;\r
 171             onLiteralLeave?(start: number, end: number): void;\r
 172             onFlags?(start: number, end: number, global: boolean, ignoreCase: boolean, multiline: boolean, unicode: boolean, sticky: boolean, dotAll: boolean): void;\r
 173             onPatternEnter?(start: number): void;\r
 174             onPatternLeave?(start: number, end: number): void;\r
 175             onDisjunctionEnter?(start: number): void;\r
 176             onDisjunctionLeave?(start: number, end: number): void;\r
 177             onAlternativeEnter?(start: number, index: number): void;\r
 178             onAlternativeLeave?(start: number, end: number, index: number): void;\r
 179             onGroupEnter?(start: number): void;\r
 180             onGroupLeave?(start: number, end: number): void;\r
 181             onCapturingGroupEnter?(start: number, name: string | null): void;\r
 182             onCapturingGroupLeave?(start: number, end: number, name: string | null): void;\r
 183             onQuantifier?(start: number, end: number, min: number, max: number, greedy: boolean): void;\r
 184             onLookaroundAssertionEnter?(start: number, kind: "lookahead" | "lookbehind", negate: boolean): void;\r
 185             onLookaroundAssertionLeave?(start: number, end: number, kind: "lookahead" | "lookbehind", negate: boolean): void;\r
 186             onEdgeAssertion?(start: number, end: number, kind: "start" | "end"): void;\r
 187             onWordBoundaryAssertion?(start: number, end: number, kind: "word", negate: boolean): void;\r
 188             onAnyCharacterSet?(start: number, end: number, kind: "any"): void;\r
 189             onEscapeCharacterSet?(start: number, end: number, kind: "digit" | "space" | "word", negate: boolean): void;\r
 190             onUnicodePropertyCharacterSet?(start: number, end: number, kind: "property", key: string, value: string | null, negate: boolean): void;\r
 191             onCharacter?(start: number, end: number, value: number): void;\r
 192             onBackreference?(start: number, end: number, ref: number | string): void;\r
 193             onCharacterClassEnter?(start: number, negate: boolean): void;\r
 194             onCharacterClassLeave?(start: number, end: number, negate: boolean): void;\r
 195             onCharacterClassRange?(start: number, end: number, min: number, max: number): void;\r
 196         }\r
 197     }\r
 198     export class RegExpValidator {\r
 199         constructor(options?: RegExpValidator.Options);\r
 200         validateLiteral(source: string, start?: number, end?: number): void;\r
 201         validateFlags(source: string, start?: number, end?: number): void;\r
 202         validatePattern(source: string, start?: number, end?: number, uFlag?: boolean): void;\r
 203     }\r
 204 }\r
 205 \r
 206 declare module 'regexpp/visitor' {\r
 207     import { Alternative, Assertion, Backreference, CapturingGroup, Character, CharacterClass, CharacterClassRange, CharacterSet, Flags, Group, Node, Pattern, Quantifier, RegExpLiteral } from "regexpp/ast";\r
 208     export class RegExpVisitor {\r
 209         constructor(handlers: RegExpVisitor.Handlers);\r
 210         visit(node: Node): void;\r
 211     }\r
 212     export namespace RegExpVisitor {\r
 213         interface Handlers {\r
 214             onAlternativeEnter?(node: Alternative): void;\r
 215             onAlternativeLeave?(node: Alternative): void;\r
 216             onAssertionEnter?(node: Assertion): void;\r
 217             onAssertionLeave?(node: Assertion): void;\r
 218             onBackreferenceEnter?(node: Backreference): void;\r
 219             onBackreferenceLeave?(node: Backreference): void;\r
 220             onCapturingGroupEnter?(node: CapturingGroup): void;\r
 221             onCapturingGroupLeave?(node: CapturingGroup): void;\r
 222             onCharacterEnter?(node: Character): void;\r
 223             onCharacterLeave?(node: Character): void;\r
 224             onCharacterClassEnter?(node: CharacterClass): void;\r
 225             onCharacterClassLeave?(node: CharacterClass): void;\r
 226             onCharacterClassRangeEnter?(node: CharacterClassRange): void;\r
 227             onCharacterClassRangeLeave?(node: CharacterClassRange): void;\r
 228             onCharacterSetEnter?(node: CharacterSet): void;\r
 229             onCharacterSetLeave?(node: CharacterSet): void;\r
 230             onFlagsEnter?(node: Flags): void;\r
 231             onFlagsLeave?(node: Flags): void;\r
 232             onGroupEnter?(node: Group): void;\r
 233             onGroupLeave?(node: Group): void;\r
 234             onPatternEnter?(node: Pattern): void;\r
 235             onPatternLeave?(node: Pattern): void;\r
 236             onQuantifierEnter?(node: Quantifier): void;\r
 237             onQuantifierLeave?(node: Quantifier): void;\r
 238             onRegExpLiteralEnter?(node: RegExpLiteral): void;\r
 239             onRegExpLiteralLeave?(node: RegExpLiteral): void;\r
 240         }\r
 241     }\r
 242 }\r
 243 \r
 244 declare module 'regexpp/ecma-versions' {\r
 245     export type EcmaVersion = 5 | 2015 | 2016 | 2017 | 2018 | 2019 | 2020;\r
 246 }\r
 247 \r