regjsparser

parse: <F extends Features = {}>(
    str: string,
    flags: string,
    features?: F
) => RootNode<F>;

type Alternative<F extends Features = {}> = Base<'alternative'> & {
    body: RootNode<F>[];
};

type Anchor = Base<'anchor'> & {
    kind: 'boundary' | 'end' | 'not-boundary' | 'start';
};

type AstNode<F extends Features = {}> =
    | Alternative<F>
    | Anchor
    | CharacterClass<F>
    | CharacterClassEscape
    | CharacterClassRange
    | Disjunction<F>
    | Dot
    | Group<F>
    | Quantifier<F>
    | Reference<F>
    | _If<F['unicodePropertyEscape'], UnicodePropertyEscape, never>
    | Value;

type AstNodeType =
    | 'alternative'
    | 'anchor'
    | 'characterClass'
    | 'characterClassEscape'
    | 'characterClassRange'
    | 'disjunction'
    | 'dot'
    | 'group'
    | 'quantifier'
    | 'reference'
    | 'unicodePropertyEscape'
    | 'value';

type Base<T extends AstNodeType> = {
    range: [number, number];
    raw: string;
    type: T;
};

type CapturingGroup<F extends Features = {}> = Base<'group'> & {
    behavior: 'normal';
    body: RootNode<F>[];
} & _If<
        F['namedGroups'],
        {
            name?: Identifier;
        },
        {
            name: undefined;
        }
    >;

type CharacterClass<F extends Features = {}> = Base<'characterClass'> & {
    body: CharacterClassBody[];
    negative: boolean;
    kind: 'union' | _If<F['unicodeSet'], 'intersection' | 'subtraction', never>;
};

type CharacterClassBody =
    | CharacterClassEscape
    | CharacterClassRange
    | UnicodePropertyEscape
    | Value;

type CharacterClassEscape = Base<'characterClassEscape'> & {
    value: string;
};

type CharacterClassRange = Base<'characterClassRange'> & {
    max: Value;
    min: Value;
};

type Disjunction<F extends Features = {}> = Base<'disjunction'> & {
    body: [RootNode<F>, RootNode<F>, ...RootNode<F>[]];
};

type Dot = Base<'dot'>;

type Features = {
    lookbehind?: boolean;
    namedGroups?: boolean;
    unicodePropertyEscape?: boolean;
    unicodeSet?: boolean;
    modifiers?: boolean;
};

type Group<F extends Features = {}> = CapturingGroup<F> | NonCapturingGroup<F>;

type Identifier = Base<'value'> & {
    value: string;
};

type IndexReference = Base<'reference'> & {
    matchIndex: number;
    name: undefined;
};

type ModifierFlags = {
    enabling: string;
    disabling: string;
};

type NamedReference = Base<'reference'> & {
    matchIndex: undefined;
    name: Identifier;
};

type NonCapturingGroup<F extends Features = {}> = Base<'group'> &
    (
        | {
              behavior:
                  | 'lookahead'
                  | 'lookbehind'
                  | 'negativeLookahead'
                  | 'negativeLookbehind';
              body: RootNode<F>[];
          }
        | ({
              behavior: 'ignore';
              body: RootNode<F>[];
          } & _If<
              F['modifiers'],
              {
                  modifierFlags?: ModifierFlags;
              },
              {
                  modifierFlags: undefined;
              }
          >)
    );

type Quantifier<F extends Features = {}> = Base<'quantifier'> & {
    body: [RootNode<F>];
    greedy: boolean;
    max?: number;
    min: number;
    symbol?: '?' | '*' | '+';
};

type Reference<F extends Features = {}> = _If<
    F['namedGroups'],
    NamedReference,
    IndexReference
>;

type RootNode<F extends Features = {}> = Exclude<AstNode<F>, CharacterClassRange>;

type UnicodePropertyEscape = Base<'unicodePropertyEscape'> & {
    negative: boolean;
    value: string;
};

type Value = Base<'value'> & {
    codePoint: number;
    kind:
        | 'controlLetter'
        | 'hexadecimalEscape'
        | 'identifier'
        | 'null'
        | 'octal'
        | 'singleEscape'
        | 'symbol'
        | 'unicodeCodePointEscape'
        | 'unicodeEscape';
};