RegexParse

Regex-parse is a simple regular expression parser that parses a string of regular expression and outpus a json tree.

Usage from Deno

Parsing a string:

import { parse } from "https://deno.land/x/regex_parse/mod.ts"

console.log(JSON.stringify(parse("(?<group>hi34f){3,4}|$\n")));

Sample output:

{
  "type": "union",
  "left": {
    "type": "quntifier",
    "kind": "range",
    "from": 3,
    "to": 4,
    "child": {
      "type": "group",
      "kind": "named",
      "child": {
        "type": "concat",
        "left": {
          "type": "concat",
          "left": {
            "type": "concat",
            "left": {
              "type": "concat",
              "left": {
                "type": "char",
                "value": "h"
              },
              "right": {
                "type": "char",
                "value": "i"
              }
            },
            "right": {
              "type": "char",
              "value": "3"
            }
          },
          "right": {
            "type": "char",
            "value": "4"
          }
        },
        "right": {
          "type": "char",
          "value": "f"
        }
      },
      "name": "group"
    }
  },
  "right": {
    "type": "concat",
    "left": {
      "type": "anchor",
      "value": "$"
    },
    "right": {
      "type": "control",
      "value": "\n"
    }
  }
}

Api

Node

Any object that has a type attribute

interface Node {
  type: string;
}

Here are the interfaces to each kind of node that you can access:

Char

A simple literal character

interface Char {
  type: "char";
  value: string;
}

Anchor

Anchors $ or ^

interface Anchor {
  type: "anchor";
  value: "$" | "^";
}

Control

A control character

interface Control {
    type: "Control";
    value: string;
}

Escaped

A character escaped with /

interface Escaped {
  type: "escaped";
  value: string;
}

Null

This node represents nothing or the empty string

interface Null {
  type: "null";
}

CharacterClass

A character class within []

interface CharacterClass {
  type: "characterClass";
  negated: boolean;
  expressions: (Char | ClassRange)[];
}

ClassRange

Class range in the format of x-y in which the codepoint of x has to be smaller than y

interface ClassRange {
  type: "classRange";
  from: string;
  to: string;
}

Star

The kleene star

interface Star {
  type: "quntifier";
  kind: "star"
  child: Node;
}

Plus

The kleene plus

interface Plus {
  type: "quntifier";
  kind: "plus";
  child: Node;
}

Range

A range quntifier of the form x{min,max}

interface Range {
  type: "quntifier";
  kind: "string";
  from: number;
  to?: number;
}

Simple

An ordinar capturing group of the form (…)

interface Simple {
  type: "group";
  kind: "simple"
  child: Node;
}

LookAhead

Look ahead in the form (?=…) or negated (?!…)

interface LookAhead {
  type: "group";
  kind: "lookahead";
  negated: boolean;
  child: Node;
}

LookBehind

Look behind in the form (?<=…) or negated (?<!…)

interface LookBehind {
  type: "group";
  kind: "lookahead";
  negated: boolean;
  child: Node;
}

NonCapturing

Noncapturing group in the form (?:…)

interface NonCapturing {
  type: "group";
  kind: "nonCapturing";
  child: Node;
}

Named

A named group of the form (?<name>…)

interface Named {
  type: "group";
  kind: "named";
  child: Node;
}

User defined type guard

This module has built in type guard to help you check the type of a node. There is one for every type of node

example:

import { parse , guard, Node } from "./mod.ts";
let result = parse("(hi)+");

function walk(s: Node) {
  if (guard.isStar(s)) {
    ...
  }

  if (guard.isNamed(s)) {
    ...
  }
}