Socket
Socket
Sign inDemoInstall

@eslint-community/regexpp

Package Overview
Dependencies
0
Maintainers
2
Versions
21
Alerts
File Explorer

Advanced tools

npm Scripts
License

Install Socket

Detect and block malicious and high-risk dependencies

Install

Comparing version 4.4.1 to 4.5.0

1004

index.d.ts
// Generated by dts-bundle v0.7.3
declare module '@eslint-community/regexpp' {
import * as AST from "@eslint-community/regexpp/ast";
import { RegExpParser } from "@eslint-community/regexpp/parser";
import { RegExpValidator } from "@eslint-community/regexpp/validator";
import { RegExpVisitor } from "@eslint-community/regexpp/visitor";
export { AST, RegExpParser, RegExpValidator };
export function parseRegExpLiteral(source: RegExp | string, options?: RegExpParser.Options): AST.RegExpLiteral;
export function validateRegExpLiteral(source: string, options?: RegExpValidator.Options): void;
export function visitRegExpAST(node: AST.Node, handlers: RegExpVisitor.Handlers): void;
declare module "@eslint-community/regexpp" {
import * as AST from "@eslint-community/regexpp/ast";
import { RegExpParser } from "@eslint-community/regexpp/parser";
import { RegExpValidator } from "@eslint-community/regexpp/validator";
import { RegExpVisitor } from "@eslint-community/regexpp/visitor";
export { AST, RegExpParser, RegExpValidator };
/**
* Parse a given regular expression literal then make AST object.
* @param source The source code to parse.
* @param options The options to parse.
* @returns The AST of the regular expression.
*/
export function parseRegExpLiteral(
source: RegExp | string,
options?: RegExpParser.Options
): AST.RegExpLiteral;
/**
* Validate a given regular expression literal.
* @param source The source code to validate.
* @param options The options to validate.
*/
export function validateRegExpLiteral(
source: string,
options?: RegExpValidator.Options
): void;
export function visitRegExpAST(
node: AST.Node,
handlers: RegExpVisitor.Handlers
): void;
}
declare module '@eslint-community/regexpp/ast' {
export type Node = BranchNode | LeafNode;
export type BranchNode = Alternative | CapturingGroup | CharacterClass | CharacterClassRange | Group | LookaroundAssertion | Pattern | Quantifier | RegExpLiteral;
export type LeafNode = Backreference | BoundaryAssertion | Character | CharacterSet | Flags;
export type Element = Assertion | QuantifiableElement | Quantifier;
export type QuantifiableElement = Backreference | CapturingGroup | Character | CharacterClass | CharacterSet | Group | LookaheadAssertion;
export type CharacterClassElement = Character | CharacterClassRange | EscapeCharacterSet | UnicodePropertyCharacterSet;
export interface NodeBase {
type: Node["type"];
parent: Node["parent"];
start: number;
end: number;
raw: string;
}
export interface RegExpLiteral extends NodeBase {
type: "RegExpLiteral";
parent: null;
pattern: Pattern;
flags: Flags;
}
export interface Pattern extends NodeBase {
type: "Pattern";
parent: RegExpLiteral | null;
alternatives: Alternative[];
}
export interface Alternative extends NodeBase {
type: "Alternative";
parent: CapturingGroup | Group | LookaroundAssertion | Pattern;
elements: Element[];
}
export interface Group extends NodeBase {
type: "Group";
parent: Alternative | Quantifier;
alternatives: Alternative[];
}
export interface CapturingGroup extends NodeBase {
type: "CapturingGroup";
parent: Alternative | Quantifier;
name: string | null;
alternatives: Alternative[];
references: Backreference[];
}
export type LookaroundAssertion = LookaheadAssertion | LookbehindAssertion;
export interface LookaheadAssertion extends NodeBase {
type: "Assertion";
parent: Alternative | Quantifier;
kind: "lookahead";
negate: boolean;
alternatives: Alternative[];
}
export interface LookbehindAssertion extends NodeBase {
type: "Assertion";
parent: Alternative;
kind: "lookbehind";
negate: boolean;
alternatives: Alternative[];
}
export interface Quantifier extends NodeBase {
type: "Quantifier";
parent: Alternative;
min: number;
max: number;
greedy: boolean;
element: QuantifiableElement;
}
export interface CharacterClass extends NodeBase {
type: "CharacterClass";
parent: Alternative | Quantifier;
negate: boolean;
elements: CharacterClassElement[];
}
export interface CharacterClassRange extends NodeBase {
type: "CharacterClassRange";
parent: CharacterClass;
min: Character;
max: Character;
}
export type Assertion = BoundaryAssertion | LookaroundAssertion;
export type BoundaryAssertion = EdgeAssertion | WordBoundaryAssertion;
export interface EdgeAssertion extends NodeBase {
type: "Assertion";
parent: Alternative | Quantifier;
kind: "end" | "start";
}
export interface WordBoundaryAssertion extends NodeBase {
type: "Assertion";
parent: Alternative | Quantifier;
kind: "word";
negate: boolean;
}
export type CharacterSet = AnyCharacterSet | EscapeCharacterSet | UnicodePropertyCharacterSet;
export interface AnyCharacterSet extends NodeBase {
type: "CharacterSet";
parent: Alternative | Quantifier;
kind: "any";
}
export interface EscapeCharacterSet extends NodeBase {
type: "CharacterSet";
parent: Alternative | CharacterClass | Quantifier;
kind: "digit" | "space" | "word";
negate: boolean;
}
export interface UnicodePropertyCharacterSet extends NodeBase {
type: "CharacterSet";
parent: Alternative | CharacterClass | Quantifier;
kind: "property";
key: string;
value: string | null;
negate: boolean;
}
export interface Character extends NodeBase {
type: "Character";
parent: Alternative | CharacterClass | CharacterClassRange | Quantifier;
value: number;
}
export interface Backreference extends NodeBase {
type: "Backreference";
parent: Alternative | Quantifier;
ref: number | string;
resolved: CapturingGroup;
}
export interface Flags extends NodeBase {
type: "Flags";
parent: RegExpLiteral | null;
dotAll: boolean;
global: boolean;
hasIndices: boolean;
ignoreCase: boolean;
multiline: boolean;
sticky: boolean;
unicode: boolean;
}
declare module "@eslint-community/regexpp/ast" {
/**
* The type which includes all nodes.
*/
export type Node = BranchNode | LeafNode;
/**
* The type which includes all branch nodes.
*/
export type BranchNode =
| Alternative
| CapturingGroup
| CharacterClass
| CharacterClassRange
| Group
| LookaroundAssertion
| Pattern
| Quantifier
| RegExpLiteral;
/**
* The type which includes all leaf nodes.
*/
export type LeafNode =
| Backreference
| BoundaryAssertion
| Character
| CharacterSet
| Flags;
/**
* The type which includes all atom nodes.
*/
export type Element = Assertion | QuantifiableElement | Quantifier;
/**
* The type which includes all atom nodes that Quantifier node can have as children.
*/
export type QuantifiableElement =
| Backreference
| CapturingGroup
| Character
| CharacterClass
| CharacterSet
| Group
| LookaheadAssertion;
/**
* The type which includes all character class atom nodes.
*/
export type CharacterClassElement =
| Character
| CharacterClassRange
| EscapeCharacterSet
| UnicodePropertyCharacterSet;
/**
* The type which defines common properties for all node types.
*/
export interface NodeBase {
/** The node type. */
type: Node["type"];
/** The parent node. */
parent: Node["parent"];
/** The 0-based index that this node starts. */
start: number;
/** The 0-based index that this node ends. */
end: number;
/** The raw text of this node. */
raw: string;
}
/**
* The root node.
*/
export interface RegExpLiteral extends NodeBase {
type: "RegExpLiteral";
parent: null;
pattern: Pattern;
flags: Flags;
}
/**
* The pattern.
*/
export interface Pattern extends NodeBase {
type: "Pattern";
parent: RegExpLiteral | null;
alternatives: Alternative[];
}
/**
* The alternative.
* E.g. `a|b`
*/
export interface Alternative extends NodeBase {
type: "Alternative";
parent: CapturingGroup | Group | LookaroundAssertion | Pattern;
elements: Element[];
}
/**
* The uncapturing group.
* E.g. `(?:ab)`
*/
export interface Group extends NodeBase {
type: "Group";
parent: Alternative | Quantifier;
alternatives: Alternative[];
}
/**
* The capturing group.
* E.g. `(ab)`, `(?<name>ab)`
*/
export interface CapturingGroup extends NodeBase {
type: "CapturingGroup";
parent: Alternative | Quantifier;
name: string | null;
alternatives: Alternative[];
references: Backreference[];
}
/**
* The lookaround assertion.
*/
export type LookaroundAssertion = LookaheadAssertion | LookbehindAssertion;
/**
* The lookahead assertion.
* E.g. `(?=ab)`, `(?!ab)`
*/
export interface LookaheadAssertion extends NodeBase {
type: "Assertion";
parent: Alternative | Quantifier;
kind: "lookahead";
negate: boolean;
alternatives: Alternative[];
}
/**
* The lookbehind assertion.
* E.g. `(?<=ab)`, `(?<!ab)`
*/
export interface LookbehindAssertion extends NodeBase {
type: "Assertion";
parent: Alternative;
kind: "lookbehind";
negate: boolean;
alternatives: Alternative[];
}
/**
* The quantifier.
* E.g. `a?`, `a*`, `a+`, `a{1,2}`, `a??`, `a*?`, `a+?`, `a{1,2}?`
*/
export interface Quantifier extends NodeBase {
type: "Quantifier";
parent: Alternative;
min: number;
max: number;
greedy: boolean;
element: QuantifiableElement;
}
/**
* The character class.
* E.g. `[ab]`, `[^ab]`
*/
export interface CharacterClass extends NodeBase {
type: "CharacterClass";
parent: Alternative | Quantifier;
negate: boolean;
elements: CharacterClassElement[];
}
/**
* The character class.
* E.g. `[a-b]`
*/
export interface CharacterClassRange extends NodeBase {
type: "CharacterClassRange";
parent: CharacterClass;
min: Character;
max: Character;
}
/**
* The assertion.
*/
export type Assertion = BoundaryAssertion | LookaroundAssertion;
/**
* The boundary assertion.
*/
export type BoundaryAssertion = EdgeAssertion | WordBoundaryAssertion;
/**
* The edge boundary assertion.
* E.g. `^`, `$`
*/
export interface EdgeAssertion extends NodeBase {
type: "Assertion";
parent: Alternative | Quantifier;
kind: "end" | "start";
}
/**
* The word bondary assertion.
* E.g. `\b`, `\B`
*/
export interface WordBoundaryAssertion extends NodeBase {
type: "Assertion";
parent: Alternative | Quantifier;
kind: "word";
negate: boolean;
}
/**
* The character set.
*/
export type CharacterSet =
| AnyCharacterSet
| EscapeCharacterSet
| UnicodePropertyCharacterSet;
/**
* The dot.
* E.g. `.`
*/
export interface AnyCharacterSet extends NodeBase {
type: "CharacterSet";
parent: Alternative | Quantifier;
kind: "any";
}
/**
* The character class escape.
* E.g. `\d`, `\s`, `\w`, `\D`, `\S`, `\W`
*/
export interface EscapeCharacterSet extends NodeBase {
type: "CharacterSet";
parent: Alternative | CharacterClass | Quantifier;
kind: "digit" | "space" | "word";
negate: boolean;
}
/**
* The unicode property escape.
* E.g. `\p{ASCII}`, `\P{ASCII}`, `\p{Script=Hiragana}`
*/
export interface UnicodePropertyCharacterSet extends NodeBase {
type: "CharacterSet";
parent: Alternative | CharacterClass | Quantifier;
kind: "property";
key: string;
value: string | null;
negate: boolean;
}
/**
* The character.
* This includes escape sequences which mean a character.
* E.g. `a`, `あ`, `✿`, `\x65`, `\u0065`, `\u{65}`, `\/`
*/
export interface Character extends NodeBase {
type: "Character";
parent: Alternative | CharacterClass | CharacterClassRange | Quantifier;
value: number;
}
/**
* The backreference.
* E.g. `\1`, `\k<name>`
*/
export interface Backreference extends NodeBase {
type: "Backreference";
parent: Alternative | Quantifier;
ref: number | string;
resolved: CapturingGroup;
}
/**
* The flags.
*/
export interface Flags extends NodeBase {
type: "Flags";
parent: RegExpLiteral | null;
dotAll: boolean;
global: boolean;
hasIndices: boolean;
ignoreCase: boolean;
multiline: boolean;
sticky: boolean;
unicode: boolean;
}
}
declare module '@eslint-community/regexpp/parser' {
import type { Flags, RegExpLiteral, Pattern } from "@eslint-community/regexpp/ast";
import type { EcmaVersion } from "@eslint-community/regexpp/ecma-versions";
export namespace RegExpParser {
interface Options {
strict?: boolean;
ecmaVersion?: EcmaVersion;
}
declare module "@eslint-community/regexpp/parser" {
import type {
Flags,
RegExpLiteral,
Pattern,
} from "@eslint-community/regexpp/ast";
import type { EcmaVersion } from "@eslint-community/regexpp/ecma-versions";
export namespace RegExpParser {
/**
* The options for RegExpParser construction.
*/
interface Options {
/**
* The flag to disable Annex B syntax. Default is `false`.
*/
strict?: boolean;
/**
* ECMAScript version. Default is `2023`.
* - `2015` added `u` and `y` flags.
* - `2018` added `s` flag, Named Capturing Group, Lookbehind Assertion,
* and Unicode Property Escape.
* - `2019`, `2020`, and `2021` added more valid Unicode Property Escapes.
* - `2022` added `d` flag.
* - `2023` added more valid Unicode Property Escapes.
*/
ecmaVersion?: EcmaVersion;
}
export class RegExpParser {
constructor(options?: RegExpParser.Options);
parseLiteral(source: string, start?: number, end?: number): RegExpLiteral;
parseFlags(source: string, start?: number, end?: number): Flags;
parsePattern(source: string, start?: number, end?: number, uFlag?: boolean): Pattern;
}
}
export class RegExpParser {
/**
* Initialize this parser.
* @param options The options of parser.
*/
constructor(options?: RegExpParser.Options);
/**
* Parse a regular expression literal. E.g. "/abc/g"
* @param source The source code to parse.
* @param start The start index in the source code.
* @param end The end index in the source code.
* @returns The AST of the given regular expression.
*/
parseLiteral(source: string, start?: number, end?: number): RegExpLiteral;
/**
* Parse a regular expression flags. E.g. "gim"
* @param source The source code to parse.
* @param start The start index in the source code.
* @param end The end index in the source code.
* @returns The AST of the given flags.
*/
parseFlags(source: string, start?: number, end?: number): Flags;
/**
* Parse a regular expression pattern. E.g. "abc"
* @param source The source code to parse.
* @param start The start index in the source code.
* @param end The end index in the source code.
* @param uFlag The flag to set unicode mode.
* @returns The AST of the given pattern.
*/
parsePattern(
source: string,
start?: number,
end?: number,
uFlag?: boolean
): Pattern;
}
}
declare module '@eslint-community/regexpp/validator' {
import type { EcmaVersion } from "@eslint-community/regexpp/ecma-versions";
export namespace RegExpValidator {
interface Options {
strict?: boolean;
ecmaVersion?: EcmaVersion;
onLiteralEnter?: (start: number) => void;
onLiteralLeave?: (start: number, end: number) => void;
onRegExpFlags?: (start: number, end: number, flags: {
global: boolean;
ignoreCase: boolean;
multiline: boolean;
unicode: boolean;
sticky: boolean;
dotAll: boolean;
hasIndices: boolean;
}) => void;
onFlags?: (start: number, end: number, global: boolean, ignoreCase: boolean, multiline: boolean, unicode: boolean, sticky: boolean, dotAll: boolean, hasIndices: boolean) => void;
onPatternEnter?: (start: number) => void;
onPatternLeave?: (start: number, end: number) => void;
onDisjunctionEnter?: (start: number) => void;
onDisjunctionLeave?: (start: number, end: number) => void;
onAlternativeEnter?: (start: number, index: number) => void;
onAlternativeLeave?: (start: number, end: number, index: number) => void;
onGroupEnter?: (start: number) => void;
onGroupLeave?: (start: number, end: number) => void;
onCapturingGroupEnter?: (start: number, name: string | null) => void;
onCapturingGroupLeave?: (start: number, end: number, name: string | null) => void;
onQuantifier?: (start: number, end: number, min: number, max: number, greedy: boolean) => void;
onLookaroundAssertionEnter?: (start: number, kind: "lookahead" | "lookbehind", negate: boolean) => void;
onLookaroundAssertionLeave?: (start: number, end: number, kind: "lookahead" | "lookbehind", negate: boolean) => void;
onEdgeAssertion?: (start: number, end: number, kind: "end" | "start") => void;
onWordBoundaryAssertion?: (start: number, end: number, kind: "word", negate: boolean) => void;
onAnyCharacterSet?: (start: number, end: number, kind: "any") => void;
onEscapeCharacterSet?: (start: number, end: number, kind: "digit" | "space" | "word", negate: boolean) => void;
onUnicodePropertyCharacterSet?: (start: number, end: number, kind: "property", key: string, value: string | null, negate: boolean) => void;
onCharacter?: (start: number, end: number, value: number) => void;
onBackreference?: (start: number, end: number, ref: number | string) => void;
onCharacterClassEnter?: (start: number, negate: boolean) => void;
onCharacterClassLeave?: (start: number, end: number, negate: boolean) => void;
onCharacterClassRange?: (start: number, end: number, min: number, max: number) => void;
declare module "@eslint-community/regexpp/validator" {
import type { EcmaVersion } from "@eslint-community/regexpp/ecma-versions";
export namespace RegExpValidator {
/**
* The options for RegExpValidator construction.
*/
interface Options {
/**
* The flag to disable Annex B syntax. Default is `false`.
*/
strict?: boolean;
/**
* ECMAScript version. Default is `2023`.
* - `2015` added `u` and `y` flags.
* - `2018` added `s` flag, Named Capturing Group, Lookbehind Assertion,
* and Unicode Property Escape.
* - `2019`, `2020`, and `2021` added more valid Unicode Property Escapes.
* - `2022` added `d` flag.
* - `2023` added more valid Unicode Property Escapes.
*/
ecmaVersion?: EcmaVersion;
/**
* A function that is called when the validator entered a RegExp literal.
* @param start The 0-based index of the first character.
*/
onLiteralEnter?: (start: number) => void;
/**
* A function that is called when the validator left a RegExp literal.
* @param start The 0-based index of the first character.
* @param end The next 0-based index of the last character.
*/
onLiteralLeave?: (start: number, end: number) => void;
/**
* A function that is called when the validator found flags.
* @param start The 0-based index of the first character.
* @param end The next 0-based index of the last character.
* @param flags.global `g` flag.
* @param flags.ignoreCase `i` flag.
* @param flags.multiline `m` flag.
* @param flags.unicode `u` flag.
* @param flags.sticky `y` flag.
* @param flags.dotAll `s` flag.
* @param flags.hasIndices `d` flag.
*/
onRegExpFlags?: (
start: number,
end: number,
flags: {
global: boolean;
ignoreCase: boolean;
multiline: boolean;
unicode: boolean;
sticky: boolean;
dotAll: boolean;
hasIndices: boolean;
}
) => void;
/**
* A function that is called when the validator found flags.
* @param start The 0-based index of the first character.
* @param end The next 0-based index of the last character.
* @param global `g` flag.
* @param ignoreCase `i` flag.
* @param multiline `m` flag.
* @param unicode `u` flag.
* @param sticky `y` flag.
* @param dotAll `s` flag.
* @param hasIndices `d` flag.
*
* @deprecated Use `onRegExpFlags` instead.
*/
onFlags?: (
start: number,
end: number,
global: boolean,
ignoreCase: boolean,
multiline: boolean,
unicode: boolean,
sticky: boolean,
dotAll: boolean,
hasIndices: boolean
) => void;
/**
* A function that is called when the validator entered a pattern.
* @param start The 0-based index of the first character.
*/
onPatternEnter?: (start: number) => void;
/**
* A function that is called when the validator left a pattern.
* @param start The 0-based index of the first character.
* @param end The next 0-based index of the last character.
*/
onPatternLeave?: (start: number, end: number) => void;
/**
* A function that is called when the validator entered a disjunction.
* @param start The 0-based index of the first character.
*/
onDisjunctionEnter?: (start: number) => void;
/**
* A function that is called when the validator left a disjunction.
* @param start The 0-based index of the first character.
* @param end The next 0-based index of the last character.
*/
onDisjunctionLeave?: (start: number, end: number) => void;
/**
* A function that is called when the validator entered an alternative.
* @param start The 0-based index of the first character.
* @param index The 0-based index of alternatives in a disjunction.
*/
onAlternativeEnter?: (start: number, index: number) => void;
/**
* A function that is called when the validator left an alternative.
* @param start The 0-based index of the first character.
* @param end The next 0-based index of the last character.
* @param index The 0-based index of alternatives in a disjunction.
*/
onAlternativeLeave?: (start: number, end: number, index: number) => void;
/**
* A function that is called when the validator entered an uncapturing group.
* @param start The 0-based index of the first character.
*/
onGroupEnter?: (start: number) => void;
/**
* A function that is called when the validator left an uncapturing group.
* @param start The 0-based index of the first character.
* @param end The next 0-based index of the last character.
*/
onGroupLeave?: (start: number, end: number) => void;
/**
* A function that is called when the validator entered a capturing group.
* @param start The 0-based index of the first character.
* @param name The group name.
*/
onCapturingGroupEnter?: (start: number, name: string | null) => void;
/**
* A function that is called when the validator left a capturing group.
* @param start The 0-based index of the first character.
* @param end The next 0-based index of the last character.
* @param name The group name.
*/
onCapturingGroupLeave?: (
start: number,
end: number,
name: string | null
) => void;
/**
* A function that is called when the validator found a quantifier.
* @param start The 0-based index of the first character.
* @param end The next 0-based index of the last character.
* @param min The minimum number of repeating.
* @param max The maximum number of repeating.
* @param greedy The flag to choose the longest matching.
*/
onQuantifier?: (
start: number,
end: number,
min: number,
max: number,
greedy: boolean
) => void;
/**
* A function that is called when the validator entered a lookahead/lookbehind assertion.
* @param start The 0-based index of the first character.
* @param kind The kind of the assertion.
* @param negate The flag which represents that the assertion is negative.
*/
onLookaroundAssertionEnter?: (
start: number,
kind: "lookahead" | "lookbehind",
negate: boolean
) => void;
/**
* A function that is called when the validator left a lookahead/lookbehind assertion.
* @param start The 0-based index of the first character.
* @param end The next 0-based index of the last character.
* @param kind The kind of the assertion.
* @param negate The flag which represents that the assertion is negative.
*/
onLookaroundAssertionLeave?: (
start: number,
end: number,
kind: "lookahead" | "lookbehind",
negate: boolean
) => void;
/**
* A function that is called when the validator found an edge boundary assertion.
* @param start The 0-based index of the first character.
* @param end The next 0-based index of the last character.
* @param kind The kind of the assertion.
*/
onEdgeAssertion?: (
start: number,
end: number,
kind: "end" | "start"
) => void;
/**
* A function that is called when the validator found a word boundary assertion.
* @param start The 0-based index of the first character.
* @param end The next 0-based index of the last character.
* @param kind The kind of the assertion.
* @param negate The flag which represents that the assertion is negative.
*/
onWordBoundaryAssertion?: (
start: number,
end: number,
kind: "word",
negate: boolean
) => void;
/**
* A function that is called when the validator found a dot.
* @param start The 0-based index of the first character.
* @param end The next 0-based index of the last character.
* @param kind The kind of the character set.
*/
onAnyCharacterSet?: (start: number, end: number, kind: "any") => void;
/**
* A function that is called when the validator found a character set escape.
* @param start The 0-based index of the first character.
* @param end The next 0-based index of the last character.
* @param kind The kind of the character set.
* @param negate The flag which represents that the character set is negative.
*/
onEscapeCharacterSet?: (
start: number,
end: number,
kind: "digit" | "space" | "word",
negate: boolean
) => void;
/**
* A function that is called when the validator found a Unicode proerty escape.
* @param start The 0-based index of the first character.
* @param end The next 0-based index of the last character.
* @param kind The kind of the character set.
* @param key The property name.
* @param value The property value.
* @param negate The flag which represents that the character set is negative.
*/
onUnicodePropertyCharacterSet?: (
start: number,
end: number,
kind: "property",
key: string,
value: string | null,
negate: boolean
) => void;
/**
* A function that is called when the validator found a character.
* @param start The 0-based index of the first character.
* @param end The next 0-based index of the last character.
* @param value The code point of the character.
*/
onCharacter?: (start: number, end: number, value: number) => void;
/**
* A function that is called when the validator found a backreference.
* @param start The 0-based index of the first character.
* @param end The next 0-based index of the last character.
* @param ref The key of the referred capturing group.
*/
onBackreference?: (
start: number,
end: number,
ref: number | string
) => void;
/**
* A function that is called when the validator entered a character class.
* @param start The 0-based index of the first character.
* @param negate The flag which represents that the character class is negative.
*/
onCharacterClassEnter?: (start: number, negate: boolean) => void;
/**
* A function that is called when the validator left a character class.
* @param start The 0-based index of the first character.
* @param end The next 0-based index of the last character.
* @param negate The flag which represents that the character class is negative.
*/
onCharacterClassLeave?: (
start: number,
end: number,
negate: boolean
) => void;
/**
* A function that is called when the validator found a character class range.
* @param start The 0-based index of the first character.
* @param end The next 0-based index of the last character.
* @param min The minimum code point of the range.
* @param max The maximum code point of the range.
*/
onCharacterClassRange?: (
start: number,
end: number,
min: number,
max: number
) => void;
}
export class RegExpValidator {
constructor(options?: RegExpValidator.Options);
validateLiteral(source: string, start?: number, end?: number): void;
validateFlags(source: string, start?: number, end?: number): void;
validatePattern(source: string, start?: number, end?: number, uFlag?: boolean): void;
}
}
/**
* The regular expression validator.
*/
export class RegExpValidator {
/**
* Initialize this validator.
* @param options The options of validator.
*/
constructor(options?: RegExpValidator.Options);
/**
* Validate a regular expression literal. E.g. "/abc/g"
* @param source The source code to validate.
* @param start The start index in the source code.
* @param end The end index in the source code.
*/
validateLiteral(source: string, start?: number, end?: number): void;
/**
* Validate a regular expression flags. E.g. "gim"
* @param source The source code to validate.
* @param start The start index in the source code.
* @param end The end index in the source code.
*/
validateFlags(source: string, start?: number, end?: number): void;
/**
* Validate a regular expression pattern. E.g. "abc"
* @param source The source code to validate.
* @param start The start index in the source code.
* @param end The end index in the source code.
* @param uFlag The flag to set unicode mode.
*/
validatePattern(
source: string,
start?: number,
end?: number,
uFlag?: boolean
): void;
}
}
declare module '@eslint-community/regexpp/visitor' {
import type { Alternative, Assertion, Backreference, CapturingGroup, Character, CharacterClass, CharacterClassRange, CharacterSet, Flags, Group, Node, Pattern, Quantifier, RegExpLiteral } from "@eslint-community/regexpp/ast";
export class RegExpVisitor {
constructor(handlers: RegExpVisitor.Handlers);
visit(node: Node): void;
declare module "@eslint-community/regexpp/visitor" {
import type {
Alternative,
Assertion,
Backreference,
CapturingGroup,
Character,
CharacterClass,
CharacterClassRange,
CharacterSet,
Flags,
Group,
Node,
Pattern,
Quantifier,
RegExpLiteral,
} from "@eslint-community/regexpp/ast";
/**
* The visitor to walk on AST.
*/
export class RegExpVisitor {
/**
* Initialize this visitor.
* @param handlers Callbacks for each node.
*/
constructor(handlers: RegExpVisitor.Handlers);
/**
* Visit a given node and descendant nodes.
* @param node The root node to visit tree.
*/
visit(node: Node): void;
}
export namespace RegExpVisitor {
interface Handlers {
onAlternativeEnter?: (node: Alternative) => void;
onAlternativeLeave?: (node: Alternative) => void;
onAssertionEnter?: (node: Assertion) => void;
onAssertionLeave?: (node: Assertion) => void;
onBackreferenceEnter?: (node: Backreference) => void;
onBackreferenceLeave?: (node: Backreference) => void;
onCapturingGroupEnter?: (node: CapturingGroup) => void;
onCapturingGroupLeave?: (node: CapturingGroup) => void;
onCharacterEnter?: (node: Character) => void;
onCharacterLeave?: (node: Character) => void;
onCharacterClassEnter?: (node: CharacterClass) => void;
onCharacterClassLeave?: (node: CharacterClass) => void;
onCharacterClassRangeEnter?: (node: CharacterClassRange) => void;
onCharacterClassRangeLeave?: (node: CharacterClassRange) => void;
onCharacterSetEnter?: (node: CharacterSet) => void;
onCharacterSetLeave?: (node: CharacterSet) => void;
onFlagsEnter?: (node: Flags) => void;
onFlagsLeave?: (node: Flags) => void;
onGroupEnter?: (node: Group) => void;
onGroupLeave?: (node: Group) => void;
onPatternEnter?: (node: Pattern) => void;
onPatternLeave?: (node: Pattern) => void;
onQuantifierEnter?: (node: Quantifier) => void;
onQuantifierLeave?: (node: Quantifier) => void;
onRegExpLiteralEnter?: (node: RegExpLiteral) => void;
onRegExpLiteralLeave?: (node: RegExpLiteral) => void;
}
export namespace RegExpVisitor {
interface Handlers {
onAlternativeEnter?: (node: Alternative) => void;
onAlternativeLeave?: (node: Alternative) => void;
onAssertionEnter?: (node: Assertion) => void;
onAssertionLeave?: (node: Assertion) => void;
onBackreferenceEnter?: (node: Backreference) => void;
onBackreferenceLeave?: (node: Backreference) => void;
onCapturingGroupEnter?: (node: CapturingGroup) => void;
onCapturingGroupLeave?: (node: CapturingGroup) => void;
onCharacterEnter?: (node: Character) => void;
onCharacterLeave?: (node: Character) => void;
onCharacterClassEnter?: (node: CharacterClass) => void;
onCharacterClassLeave?: (node: CharacterClass) => void;
onCharacterClassRangeEnter?: (node: CharacterClassRange) => void;
onCharacterClassRangeLeave?: (node: CharacterClassRange) => void;
onCharacterSetEnter?: (node: CharacterSet) => void;
onCharacterSetLeave?: (node: CharacterSet) => void;
onFlagsEnter?: (node: Flags) => void;
onFlagsLeave?: (node: Flags) => void;
onGroupEnter?: (node: Group) => void;
onGroupLeave?: (node: Group) => void;
onPatternEnter?: (node: Pattern) => void;
onPatternLeave?: (node: Pattern) => void;
onQuantifierEnter?: (node: Quantifier) => void;
onQuantifierLeave?: (node: Quantifier) => void;
onRegExpLiteralEnter?: (node: RegExpLiteral) => void;
onRegExpLiteralLeave?: (node: RegExpLiteral) => void;
}
}
}
}
declare module '@eslint-community/regexpp/ecma-versions' {
export type EcmaVersion = 5 | 2015 | 2016 | 2017 | 2018 | 2019 | 2020 | 2021 | 2022;
declare module "@eslint-community/regexpp/ecma-versions" {
export type EcmaVersion =
| 5
| 2015
| 2016
| 2017
| 2018
| 2019
| 2020
| 2021
| 2022
| 2023;
}

6

package.json
{
"name": "@eslint-community/regexpp",
"version": "4.4.1",
"version": "4.5.0",
"description": "Regular expression parser for ECMAScript.",

@@ -51,3 +51,3 @@ "keywords": [

"build:rollup": "rollup -c",
"build:dts": "dts-bundle --name @eslint-community/regexpp --main .temp/index.d.ts --out ../index.d.ts",
"build:dts": "npm run -s build:tsc -- --removeComments false && dts-bundle --name @eslint-community/regexpp --main .temp/index.d.ts --out ../index.d.ts && prettier --write index.d.ts",
"clean": "rimraf .temp index.*",

@@ -83,3 +83,3 @@ "lint": "eslint . --ext .ts",

"ts-node": "^10.9.1",
"typescript": "~4.9.4"
"typescript": "~5.0.2"
},

@@ -86,0 +86,0 @@ "engines": {

index.js

Sorry, the diff of this file is too big to display

index.js.map

Sorry, the diff of this file is not supported yet

index.mjs

Sorry, the diff of this file is not supported yet

index.mjs.map

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap

About

Packages

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc