.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         hasIndices: boolean;\r
 141         ignoreCase: boolean;\r
 142         multiline: boolean;\r
 143         sticky: boolean;\r
 144         unicode: boolean;\r
 145     }\r
 146 }\r
 147 \r
 148 declare module 'regexpp/parser' {\r
 149     import { Flags, RegExpLiteral, Pattern } from "regexpp/ast";\r
 150     import { EcmaVersion } from "regexpp/ecma-versions";\r
 151     export namespace RegExpParser {\r
 152         interface Options {\r
 153             strict?: boolean;\r
 154             ecmaVersion?: EcmaVersion;\r
 155         }\r
 156     }\r
 157     export class RegExpParser {\r
 158         constructor(options?: RegExpParser.Options);\r
 159         parseLiteral(source: string, start?: number, end?: number): RegExpLiteral;\r
 160         parseFlags(source: string, start?: number, end?: number): Flags;\r
 161         parsePattern(source: string, start?: number, end?: number, uFlag?: boolean): Pattern;\r
 162     }\r
 163 }\r
 164 \r
 165 declare module 'regexpp/validator' {\r
 166     import { EcmaVersion } from "regexpp/ecma-versions";\r
 167     export namespace RegExpValidator {\r
 168         interface Options {\r
 169             strict?: boolean;\r
 170             ecmaVersion?: EcmaVersion;\r
 171             onLiteralEnter?(start: number): void;\r
 172             onLiteralLeave?(start: number, end: number): void;\r
 173             onFlags?(start: number, end: number, global: boolean, ignoreCase: boolean, multiline: boolean, unicode: boolean, sticky: boolean, dotAll: boolean, hasIndices: boolean): void;\r
 174             onPatternEnter?(start: number): void;\r
 175             onPatternLeave?(start: number, end: number): void;\r
 176             onDisjunctionEnter?(start: number): void;\r
 177             onDisjunctionLeave?(start: number, end: number): void;\r
 178             onAlternativeEnter?(start: number, index: number): void;\r
 179             onAlternativeLeave?(start: number, end: number, index: number): void;\r
 180             onGroupEnter?(start: number): void;\r
 181             onGroupLeave?(start: number, end: number): void;\r
 182             onCapturingGroupEnter?(start: number, name: string | null): void;\r
 183             onCapturingGroupLeave?(start: number, end: number, name: string | null): void;\r
 184             onQuantifier?(start: number, end: number, min: number, max: number, greedy: boolean): void;\r
 185             onLookaroundAssertionEnter?(start: number, kind: "lookahead" | "lookbehind", negate: boolean): void;\r
 186             onLookaroundAssertionLeave?(start: number, end: number, kind: "lookahead" | "lookbehind", negate: boolean): void;\r
 187             onEdgeAssertion?(start: number, end: number, kind: "start" | "end"): void;\r
 188             onWordBoundaryAssertion?(start: number, end: number, kind: "word", negate: boolean): void;\r
 189             onAnyCharacterSet?(start: number, end: number, kind: "any"): void;\r
 190             onEscapeCharacterSet?(start: number, end: number, kind: "digit" | "space" | "word", negate: boolean): void;\r
 191             onUnicodePropertyCharacterSet?(start: number, end: number, kind: "property", key: string, value: string | null, negate: boolean): void;\r
 192             onCharacter?(start: number, end: number, value: number): void;\r
 193             onBackreference?(start: number, end: number, ref: number | string): void;\r
 194             onCharacterClassEnter?(start: number, negate: boolean): void;\r
 195             onCharacterClassLeave?(start: number, end: number, negate: boolean): void;\r
 196             onCharacterClassRange?(start: number, end: number, min: number, max: number): void;\r
 197         }\r
 198     }\r
 199     export class RegExpValidator {\r
 200         constructor(options?: RegExpValidator.Options);\r
 201         validateLiteral(source: string, start?: number, end?: number): void;\r
 202         validateFlags(source: string, start?: number, end?: number): void;\r
 203         validatePattern(source: string, start?: number, end?: number, uFlag?: boolean): void;\r
 204     }\r
 205 }\r
 206 \r
 207 declare module 'regexpp/visitor' {\r
 208     import { Alternative, Assertion, Backreference, CapturingGroup, Character, CharacterClass, CharacterClassRange, CharacterSet, Flags, Group, Node, Pattern, Quantifier, RegExpLiteral } from "regexpp/ast";\r
 209     export class RegExpVisitor {\r
 210         constructor(handlers: RegExpVisitor.Handlers);\r
 211         visit(node: Node): void;\r
 212     }\r
 213     export namespace RegExpVisitor {\r
 214         interface Handlers {\r
 215             onAlternativeEnter?(node: Alternative): void;\r
 216             onAlternativeLeave?(node: Alternative): void;\r
 217             onAssertionEnter?(node: Assertion): void;\r
 218             onAssertionLeave?(node: Assertion): void;\r
 219             onBackreferenceEnter?(node: Backreference): void;\r
 220             onBackreferenceLeave?(node: Backreference): void;\r
 221             onCapturingGroupEnter?(node: CapturingGroup): void;\r
 222             onCapturingGroupLeave?(node: CapturingGroup): void;\r
 223             onCharacterEnter?(node: Character): void;\r
 224             onCharacterLeave?(node: Character): void;\r
 225             onCharacterClassEnter?(node: CharacterClass): void;\r
 226             onCharacterClassLeave?(node: CharacterClass): void;\r
 227             onCharacterClassRangeEnter?(node: CharacterClassRange): void;\r
 228             onCharacterClassRangeLeave?(node: CharacterClassRange): void;\r
 229             onCharacterSetEnter?(node: CharacterSet): void;\r
 230             onCharacterSetLeave?(node: CharacterSet): void;\r
 231             onFlagsEnter?(node: Flags): void;\r
 232             onFlagsLeave?(node: Flags): void;\r
 233             onGroupEnter?(node: Group): void;\r
 234             onGroupLeave?(node: Group): void;\r
 235             onPatternEnter?(node: Pattern): void;\r
 236             onPatternLeave?(node: Pattern): void;\r
 237             onQuantifierEnter?(node: Quantifier): void;\r
 238             onQuantifierLeave?(node: Quantifier): void;\r
 239             onRegExpLiteralEnter?(node: RegExpLiteral): void;\r
 240             onRegExpLiteralLeave?(node: RegExpLiteral): void;\r
 241         }\r
 242     }\r
 243 }\r
 244 \r
 245 declare module 'regexpp/ecma-versions' {\r
 246     export type EcmaVersion = 5 | 2015 | 2016 | 2017 | 2018 | 2019 | 2020 | 2021 | 2022;\r
 247 }\r
 248 \r