v-regexp/lib/parse.d.ts

JavaScript Regular Expression Parser and Visualizer.

/**
AST:
  Node = { // Base Node interface
    type:NodeType,      // Node type string
    raw:String,         // Raw regex string
    repeat:{
      min:Int,max:Int,  // Repeat times. [min,max] means "{min,max}".
                        // Set max=Infinity forms a "{min,}" range
                        // Set max=undefined forms a "{min}" range
      nonGreedy:Boolean // If this repeat is non-greedy,viz. had a "?" quantifier
    },
    indices:[Int,Int]   // Raw string in original regex index range [start,end)
                        // You can use regexStr.slice(start,end) to retrieve node.raw string
  }

  NodeType = exact|dot|charset|choice|empty|group|assert|backref

  ExactNode = { // Literal match chars string
    type:"exact",
    chars:"c",
    raw:"c{1,2}"   // When repeat or escape,raw will diff from chars
  }
  DotNode = {type:"dot"} //viz. "." , dot match any char but newline "\n\r"

  // Because of IgnoreCase flag,
  // The client code need to compute disjoint ranges itself.
  CharsetNode = {
    type:"charset",
    exclude:Boolean,   // True only if it is "[^abc]" form
    classes:[Char],  // Named character classes. e.g. [\d].
                       // All names: d(Digit),D(Non-digit),w,W,s,S
    chars:String,      // Literal chars. e.g. [abc] repr as 'abc'
    ranges:[Range]     // Range: a-z repr as 'az'
  }

  ChoiceNode = {
    type:"choice",
    branches:[[Node]] // Choice more branches,e.g. /a|b|c/
  }

  EmptyNode = {  // This node will match any input,include empty string
    type:"empty" //new RegExp("") will give an empty node. /a|/ will give branches with an empty node
  }

  GroupNode = {
    type:"group",
    nonCapture:false, // true means:"(?:abc)",default is false
    num:Int, // If capture is true.It is group's int index(>=1).
    endParenIndex:Int, // /(a)+/ will generate only one node,so indices is [0,4],endParenIndex is 3
    sub:[Node]   // Sub pattern nodes
  }

  AssertNode = {
    type:"assert",
    assertionType:String, //See Assertion Type Constants
    sub:[Node]            //Optional,\b \B ^ $ Assertion this property is empty
  }
  Only AssertLookahead,AssertNegativeLookahead has `sub` property
  "(?=(abc))" repr as {
    type:"assert", assertionType:AssertLookahead,
    sub:[{
      type:"group",
      sub:[{type:"exact",raw:"abc"}]
    }]
  }

  BackrefNode = {
    type:"backref",
    num:Int     // Back references index.Correspond to group.num
  }

*/
export function AST(a: any): void;
export class AST {
    /**
    AST:
      Node = { // Base Node interface
        type:NodeType,      // Node type string
        raw:String,         // Raw regex string
        repeat:{
          min:Int,max:Int,  // Repeat times. [min,max] means "{min,max}".
                            // Set max=Infinity forms a "{min,}" range
                            // Set max=undefined forms a "{min}" range
          nonGreedy:Boolean // If this repeat is non-greedy,viz. had a "?" quantifier
        },
        indices:[Int,Int]   // Raw string in original regex index range [start,end)
                            // You can use regexStr.slice(start,end) to retrieve node.raw string
      }
    
      NodeType = exact|dot|charset|choice|empty|group|assert|backref
    
      ExactNode = { // Literal match chars string
        type:"exact",
        chars:"c",
        raw:"c{1,2}"   // When repeat or escape,raw will diff from chars
      }
      DotNode = {type:"dot"} //viz. "." , dot match any char but newline "\n\r"
    
      // Because of IgnoreCase flag,
      // The client code need to compute disjoint ranges itself.
      CharsetNode = {
        type:"charset",
        exclude:Boolean,   // True only if it is "[^abc]" form
        classes:[Char],  // Named character classes. e.g. [\d].
                           // All names: d(Digit),D(Non-digit),w,W,s,S
        chars:String,      // Literal chars. e.g. [abc] repr as 'abc'
        ranges:[Range]     // Range: a-z repr as 'az'
      }
    
      ChoiceNode = {
        type:"choice",
        branches:[[Node]] // Choice more branches,e.g. /a|b|c/
      }
    
      EmptyNode = {  // This node will match any input,include empty string
        type:"empty" //new RegExp("") will give an empty node. /a|/ will give branches with an empty node
      }
    
      GroupNode = {
        type:"group",
        nonCapture:false, // true means:"(?:abc)",default is false
        num:Int, // If capture is true.It is group's int index(>=1).
        endParenIndex:Int, // /(a)+/ will generate only one node,so indices is [0,4],endParenIndex is 3
        sub:[Node]   // Sub pattern nodes
      }
    
      AssertNode = {
        type:"assert",
        assertionType:String, //See Assertion Type Constants
        sub:[Node]            //Optional,\b \B ^ $ Assertion this property is empty
      }
      Only AssertLookahead,AssertNegativeLookahead has `sub` property
      "(?=(abc))" repr as {
        type:"assert", assertionType:AssertLookahead,
        sub:[{
          type:"group",
          sub:[{type:"exact",raw:"abc"}]
        }]
      }
    
      BackrefNode = {
        type:"backref",
        num:Int     // Back references index.Correspond to group.num
      }
    
    */
    constructor(a: any);
    raw: any;
    tree: any;
    groupCount: any;
    traverse(f: any, nodeType: any): void;
}
export default parse;
/**
  re  input regex as string
 [options]
  @option {Boolean} options.debug   If enable debug log
  @option {Boolean} options.strict  If enable strict mode

{
  raw:String,     // original re
  groupCount:Int, //Total group count
  tree:Array      // AST Tree Stack
}
*/
declare function parse(re: any): AST;
declare namespace parse {
    export { RegexSyntaxError };
    export { getNFAParser };
}
declare function RegexSyntaxError(e: any): void;
declare class RegexSyntaxError {
    constructor(e: any);
    name: string;
    type: any;
    lastIndex: any;
    lastState: any;
    astStack: any;
    message: any;
    toString(): string;
}
declare function getNFAParser(): any;