hexo/node_modules/regjsparser/parser.d.ts

type _If<Test, Then, Else> = Test extends true ? Then : Else;

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

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

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

export 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;

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

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

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

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

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

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

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

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

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

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

export type ModifierFlags = {
  enabling: string,
  disabling: string
}

export 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;
        }
      >)
  );


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

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

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

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

export type Dot = Base<"dot">;

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

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

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

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