LiteExp (Litex)

--- Or ---

Regex'ing doesn't suck anymore

Litex is a minimalistic library of functions that help achieve the versatility of regex while making expressions remain simple and dev-friendly

General usage

All Litex does is basically returning a RegExp, via Litex.getExp(...) function.

Example usage:

myString.replace(Litex.getExp(...), 'something');

Here you can see that you can use Litex directly where you would normally use regex.

What to put inside of Litex.getExp() function

For typescript enjoyers, here's a simplified declaration

Litex.getExp(matchAll: boolean, expression: LiteExp): RegExp;

• matchAll is a boolean to define whether the expression will match all occurences or only first occurence.
• LiteExp is just an array of Litex charachters.

Litex charachters

These charachters are used to create your LiteExp.

First, example usage

const pythonCommentPattern = Litex.getExp(true, [
    Litex.linestart(),
    Litex.whitespace('0+'),
    Litex.char('#'),
    Litex.anychar('0+'),
    Litex.lineend()
]);

Here's the regex the previous code will produce:

/^\s{0,}#.{0,}$/gm

Basically, all you do is write a sequence of any Litex charachters to form the final expression.

Declaration of all Litex charachter funcs

NOTE: when you see '0+' or '1+' it is CharAmt argument in Litex charachter funcs. Here is how to use it and what is does:

| Arg | Occurences amount | | -------------------- | ------------------------------ | | unset | 1 | | Int | Int | | "Int+" | Int or more occurences | | "Int1..Int2" | In range from Int1 to Int2 |

Capture group

Declaration:

Litex.captureGroup(groupName: string, exp: LiteExp)

Define a capture group that you can later access via [<matches>].groups.[<groupName>].

Regex equivalent: (?<GROUPNAME>...)

See code snippets

Group

Declaration:

Litex.group(exp: LiteExp)

Group multiple Litex chars.

Regex equivalent: (...)

Not

Declaration:

Litex.not(exp: LiteExp)

Exclude some expressions from the match.

Regex equivalent: [^...]

Inside of

Declaration:

Litex.insideOf(boundaries: [string, string], exp: LiteExp)

Match expression inside of specified boundaries.

Regex equivalent: (BOUNDARY1(...)BOUNDARY2)

Any from list

Declaration:

Litex.anyFromList(exp: LiteExp)

Match any Litex char inside of the list.

Regex equivalent: [(ITEM1)(ITEM2)(...)]

Char

Declaration:

Litex.char(char: string, amt?: CharAmt)

Add regular charachter(s) to an expression.

Regex equivalent: MY CUSTOM CHARS

Anychar

Declaration:

Litex.anychar(amt?: CharAmt)

Match any charachter.

Regex equivalent: .

Linestart

Declaration:

Litex.linestart(amt?: CharAmt)

Match line start.

Regex equivalent: ^

Lineend

Declaration:

Litex.lineend(amt?: CharAmt)

Match line end.

Regex equivalent: $

Whitespace

Declaration:

Litex.whitespace(amt?: CharAmt)

Match any whitespace char.

Regex equivalent: \s

Newline

Declaration:

Litex.newline(amt?: CharAmt)

Match newline char.

Regex equivalent: \n

Tab

Declaration:

Litex.tab(amt?: CharAmt)

Match tab char.

Regex equivalent: \t

Return

Declaration:

Litex.return(amt?: CharAmt)

Match return char.

Regex equivalent: \r

Null

Declaration:

Litex.null(amt?: CharAmt)

Match null char.

Regex equivalent: \0

Digit

Declaration:

Litex.digit(amt?: CharAmt)

Match any digits.

Regex equivalent: 0-9

az

Declaration:

Litex.az(amt?: CharAmt)

Match latin lowercase letters.

Regex equivalent: a-z

AZ

Declaration:

Litex.AZ(amt?: CharAmt)

Match latin uppercase letters.

Regex equivalent: A-Z

Code snippets

Using captureGroup()

const myString = '<% sometext %>'
const match = myString.match(Litex.getExp(false, [
    Litex.char('<%'),
    Litex.whitespace('0+'),
    Litex.captureGroup('main', [
        Litex.anychar('0+')
    ]),
    Litex.whitespace('0+'),
    Litex.char('%>'),
]));

console.log(match.groups.main) //=> sometext