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