pad_spa/node_modules/regexp-tree/index.d.ts

declare module 'regexp-tree/ast' {
  export type AstClass =
    | 'Char'
    | 'ClassRange'
    | 'CharacterClass'
    | 'Alternative'
    | 'Disjunction'
    | 'Group'
    | 'Backreference'
    | 'Repetition'
    | 'Quantifier'
    | 'Assertion'
    | 'RegExp';

  interface Base<T> {
    type: T;
    loc?: {
      source: string;
      start: number;
      end: number;
    };
  }

  export interface SimpleChar extends Base<'Char'> {
    value: string;
    kind: 'simple';
    escaped?: true;
  }

  export interface SpecialChar extends Base<'Char'> {
    value: string;
    kind: 'meta' | 'control' | 'hex' | 'decimal' | 'oct' | 'unicode';
  }

  export type Char = SimpleChar | SpecialChar;

  export interface ClassRange extends Base<'ClassRange'> {
    from: Char;
    to: Char;
  }

  export interface CharacterClass extends Base<'CharacterClass'> {
    negative?: true;
    expressions: (Char | ClassRange)[];
  }

  export interface Alternative extends Base<'Alternative'> {
    expressions: Expression[];
  }

  export interface Disjunction extends Base<'Disjunction'> {
    expressions: (Expression | null)[];
  }

  export interface CapturingGroup extends Base<'Group'> {
    capturing: true;
    number: number;
    name?: string;
    expression: Expression | null;
  }

  export interface NoncapturingGroup extends Base<'Group'> {
    capturing: false;
    expression: Expression | null;
  }

  export type Group = CapturingGroup | NoncapturingGroup;

  export interface NumericBackreference extends Base<'Backreference'> {
    kind: 'number';
    number: number;
    reference: number;
  }

  export interface NamedBackreference extends Base<'Backreference'> {
    kind: 'name';
    number: number;
    reference: string;
  }

  export type Backreference = NumericBackreference | NamedBackreference;

  export interface Repetition extends Base<'Repetition'> {
    expression: Expression;
    quantifier: Quantifier;
  }

  export interface SimpleQuantifier extends Base<'Quantifier'> {
    kind: '+' | '*' | '?';
    greedy: boolean;
  }

  export interface RangeQuantifier extends Base<'Quantifier'> {
    kind: 'Range';
    from: number;
    to?: number;
    greedy: boolean;
  }

  export type Quantifier = SimpleQuantifier | RangeQuantifier;

  export interface SimpleAssertion extends Base<'Assertion'> {
    kind: '^' | '$' | '\\b' | '\\B';
  }

  export interface LookaroundAssertion extends Base<'Assertion'> {
    kind: 'Lookahead' | 'Lookbehind';
    negative?: true;
    assertion: Expression | null;
  }

  export type Assertion = SimpleAssertion | LookaroundAssertion;

  export type Expression =
    | Char
    | CharacterClass
    | Alternative
    | Disjunction
    | Group
    | Backreference
    | Repetition
    | Assertion;

  export interface AstRegExp extends Base<'RegExp'> {
    body: Expression | null;
    flags: string;
  }
}

declare module 'regexp-tree' {
  import { AstRegExp } from 'regexp-tree/ast'
  interface ParserOptions {
    captureLocations?: boolean;
  }

  export function parse(s: string | RegExp, options?: ParserOptions): AstRegExp;

  export function generate(ast: AstRegExp): string;

  export function toRegExp(regexp: string): RegExp;
}