Gecko [ gandhischool.edu.np ]

Name	Size	Permission
bin	[ DIR ]	drwxr-xr-x
dist	[ DIR ]	drwxr-xr-x
LICENSE	1.05 KB	-rw-r--r--
README.md	40.98 KB	-rw-r--r--
index.d.ts	3.13 KB	-rw-r--r--
index.js	172 B	-rw-r--r--
package.json	1.18 KB	-rw-r--r--

Code Editor : 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 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;
}

${this.title}

Code Editor : index.d.ts