::alert
By default, all helpers from magic-regexp assume that input that is passed should be escaped - so no special RegExp characters apply. So createRegExp('foo.\d') will not match food3 but only foo.\d exactly.
::
Creating inputs  Copy Chapter
There are a range of helpers that can be used to activate pattern matching, and they can be chained. Each one of these returns an object of type Input that can be passed directly to new RegExp, createRegExp, to another helper or chained to produce more complex patterns.
|                                                                                                                     |                                                                                                                                                                     |
| ------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| charIn, charNotIn                                                                                               | this matches or doesn't match any character in the string provided.                                                                                                 |
| anyOf                                                                                                             | this takes a variable number of inputs and matches any of them.                                                                                                              |
| char, word, wordChar, wordBoundary, digit, whitespace, letter, letter.lowercase, letter.uppercase, tab, linefeed and carriageReturn | these are helpers for specific RegExp characters.                                                                                                                   |
| not                                                                                                               | this can prefix word, wordChar, wordBoundary, digit, whitespace, letter, letter.lowercase, letter.uppercase, tab, linefeed or carriageReturn. For example createRegExp(not.letter). |
| maybe                                                                                                             | equivalent to ? - this takes a variable number of inputs and marks them as optional.                                                                                                               |
| oneOrMore                                                                                                         | Equivalent to + - this takes a variable number of inputs and marks them as repeatable, any number of times but at least once.                                                                      |
| exactly                                                                                                           | This takes a variable number of inputs and concatenate their patterns, and escapes string inputs to match it exactly.                                                                                                                    |
::alert
All helpers that takes string and Input are variadic functions, so you can pass in one or multiple arguments of string or Input to them and they will be concatenated to one pattern. for example, exactly('foo', maybe('bar')) is equivalent to exactly('foo').and(maybe('bar')).
::
Chaining inputs  Copy Chapter
All of the helpers above return an object of type Input that can be chained with the following helpers:
|                                               |                                                                                                                                                                                                                                                                                                                                                                               |
| --------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| and                                         | this takes a variable number of inputs and adds them as new pattern to the current input, or you can use and.referenceTo(groupName) to adds a new pattern referencing to a named group.                                                                                                                                                                                     |
| or                                          | this takes a variable number of inputs and provides as an alternative to the current input.                                                                                                                                                                                                                                                                                   |
| after, before, notAfter and notBefore | these takes a variable number of inputs and activate positive/negative lookahead/lookbehinds. Make sure to check browser support as not all browsers support lookbehinds (notably Safari).                                                                   |
| times                                       | this is a function you can call directly to repeat the previous pattern an exact number of times, or you can use times.between(min, max) to specify a range, times.atLeast(x) to indicate it must repeat at least x times, times.atMost(x) to indicate it must repeat at most x times or times.any() to indicate it can repeat any number of times, _including none_. |
| optionally                                  | this is a function you can call to mark the current input as optional.                                                                                                                                                                                                                                                                                                        |
| as                                          | alias for groupedAs                                                                                                                                                                                                                                                                                                                                                         |
| groupedAs                                   | this defines the entire input so far as a named capture group. You will get type safety when using the resulting RegExp with String.match().                                                                                                                                                                                                                                |
| grouped                                     | this defines the entire input so far as an anonymous group.                                                                                                                                                                                                                                                                                                                   |
| at                                          | this allows you to match beginning/ends of lines with at.lineStart() and at.lineEnd().                                                                                                                                                                                                                                                                                    |
::alert
By default, for better regex performance, creation input helpers such as anyOf, maybe, oneOrMore, and chaining input helpers such as or, times(.between/atLeast/any), or optionally will wrap the input in a non-capturing group with (?:). You can use chaining input helper grouped after any Input type to capture it as an anonymous group.
::
Debugging  Copy Chapter
When using magic-regexp, a TypeScript generic is generated for you that should show the RegExp that you are constructing, as you go.
This is true not just for the final RegExp, but also for the pieces you create along the way.
So, for example:

When matching dynamic string, the result will be union of possible matches