feat: add wordBoundary helper input (#20)

Author: didavid61202

docs/content/2.getting-started/2.usage.md

@@ -39,8 +39,8 @@ There are a range of helpers that can be used to activate pattern matching, and
 | --------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- |
 | `charIn`, `charNotIn`                                                                   | this matches or doesn't match any character in the string provided.                                                                     |
 | `anyOf`                                                                                 | this takes an array of inputs and matches any of them.                                                                                  |
-| `char`, `word`, `digit`, `whitespace`, `letter`, `tab`, `linefeed` and `carriageReturn` | these are helpers for specific RegExp characters.                                                                                       |
-| `not`                                                                                   | this can prefix `word`, `digit`, `whitespace`, `letter`, `tab`, `linefeed` or `carriageReturn`. For example `createRegExp(not.letter)`. |
+| `char`, `word`, `wordBoundary`, `digit`, `whitespace`, `letter`, `tab`, `linefeed` and `carriageReturn` | these are helpers for specific RegExp characters.                                                                                       |
+| `not`                                                                                   | this can prefix `word`, `wordBoundary`, `digit`, `whitespace`, `letter`, `tab`, `linefeed` or `carriageReturn`. For example `createRegExp(not.letter)`. |
 | `maybe`                                                                                 | equivalent to `?` - this marks the input as optional.                                                                                   |
 | `oneOrMore`                                                                             | Equivalent to `+` - this marks the input as repeatable, any number of times but at least once.                                          |
 | `exactly`                                                                               | This escapes a string input to match it exactly.                                                                                        |

src/core/inputs.ts

@@ -24,6 +24,7 @@ export const anyOf = <New extends InputSource<V, T>[], V extends string, T exten
 
 export const char = createInput('.')
 export const word = createInput('\\w')
+export const wordBoundary = createInput('\\b')
 export const digit = createInput('\\d')
 export const whitespace = createInput('\\s')
 export const letter = createInput('[a-zA-Z]')
@@ -33,6 +34,7 @@ export const carriageReturn = createInput('\\r')
 
 export const not = {
   word: createInput('\\W'),
+  wordBoundary: createInput('\\B'),
   digit: createInput('\\D'),
   whitespace: createInput('\\S'),
   letter: createInput('[^a-zA-Z]'),

test/inputs.test.ts

@@ -11,6 +11,7 @@ import {
   maybe,
   oneOrMore,
   word,
+  wordBoundary,
   digit,
   whitespace,
   letter,
@@ -76,6 +77,11 @@ describe('inputs', () => {
     expect(new RegExp(input as any)).toMatchInlineSnapshot('/\\\\d/')
     expectTypeOf(extractRegExp(input)).toMatchTypeOf<'\\d'>()
   })
+  it('wordBoundary', () => {
+    const input = wordBoundary
+    expect(new RegExp(input as any)).toMatchInlineSnapshot('/\\\\b/')
+    expectTypeOf(extractRegExp(input)).toMatchTypeOf<'\\b'>()
+  })
   it('whitespace', () => {
     const input = whitespace
     expect(new RegExp(input as any)).toMatchInlineSnapshot('/\\\\s/')
@@ -104,6 +110,8 @@ describe('inputs', () => {
   it('not', () => {
     expect(not.word.toString()).toMatchInlineSnapshot('"\\\\W"')
     expectTypeOf(extractRegExp(not.word)).toMatchTypeOf<'\\W'>()
+    expect(not.wordBoundary.toString()).toMatchInlineSnapshot('"\\\\B"')
+    expectTypeOf(extractRegExp(not.wordBoundary)).toMatchTypeOf<'\\B'>()
     expect(not.digit.toString()).toMatchInlineSnapshot('"\\\\D"')
     expectTypeOf(extractRegExp(not.digit)).toMatchTypeOf<'\\D'>()
     expect(not.whitespace.toString()).toMatchInlineSnapshot('"\\\\S"')