chore: update docs

Author: mdjastrzebski

README.md

@@ -104,23 +104,30 @@ See [Regex Builder API doc](./docs/API.md#builder) for more info.
 
 ### Regex Constructs
 
-| Construct           | Regex Syntax | Notes                           |
-| ------------------- | ------------ | ------------------------------- |
-| `capture(...)`      | `(...)`      | Create a capture group          |
-| `choiceOf(x, y, z)` | `x\|y\|z`    | Match one of provided sequences |
+| Construct                 | Regex Syntax | Notes                                       |
+| ------------------------- | ------------ | ------------------------------------------- |
+| `choiceOf(x, y, z)`       | `x\|y\|z`    | Match one of provided sequences             |
+| `capture(...)`            | `(...)`      | Create a capture group                      |
+| `lookahead(...)`          | `(?=...)`    | Match subsequent text without consuming it  |
+| `negativeLookhead(...)`   | `(?!...)`    | Reject subsequent text without consuming it |
+| `lookbehind(...)`         | `(?<=...)`   | Match preceding text without consuming it   |
+| `negativeLookbehind(...)` | `(?<!...)`   | Reject preceding text without consuming it  |
 
 See [Regex Constructs API doc](./docs/API.md#constructs) for more info.
 
+> [!NOTE]
+> TS Regex Builder does not have a construct for non-capturing groups. Such groups are implicitly added when required.
+
 ### Quantifiers
 
-| Quantifier                                      | Regex Syntax | Description                                                    |
-| ----------------------------------------------- | ------------ | -------------------------------------------------------------- |
-| `zeroOrMore(x)`                                 | `x*`         | Zero or more occurence of a pattern                            |
-| `oneOrMore(x)`                                  | `x+`         | One or more occurence of a pattern                             |
-| `optional(x)`                                   | `x?`         | Zero or one occurence of a pattern                             |
-| `repeat(x, n)`                                  | `x{n}`       | Pattern repeats exact number of times                          |
-| `repeat(x, { min: n, })`                        | `x{n,}`      | Pattern repeats at least given number of times                 |
-| `repeat(x, { min: n, max: n2 })`                | `x{n1,n2}`   | Pattern repeats between n1 and n2 number of times              |
+| Quantifier                       | Regex Syntax | Description                                       |
+| -------------------------------- | ------------ | ------------------------------------------------- |
+| `zeroOrMore(x)`                  | `x*`         | Zero or more occurence of a pattern               |
+| `oneOrMore(x)`                   | `x+`         | One or more occurence of a pattern                |
+| `optional(x)`                    | `x?`         | Zero or one occurence of a pattern                |
+| `repeat(x, n)`                   | `x{n}`       | Pattern repeats exact number of times             |
+| `repeat(x, { min: n, })`         | `x{n,}`      | Pattern repeats at least given number of times    |
+| `repeat(x, { min: n, max: n2 })` | `x{n1,n2}`   | Pattern repeats between n1 and n2 number of times |
 
 See [Quantifiers API doc](./docs/API.md#quantifiers) for more info.
 

docs/API.md

@@ -46,41 +46,46 @@ It optionally accepts a list of regex flags:
 
 These functions and objects represent available regex constructs.
 
-### `capture()`
+### `choiceOf()`
 
 ```ts
-function capture(
-  sequence: RegexSequence
-): Capture
+function choiceOf(
+  ...alternatives: RegexSequence[]
+): ChoiceOf {
 ```
 
-Regex syntax: `(...)`.
+Regex syntax: `a|b|c`.
 
-Captures, also known as capturing groups, extract and store parts of the matched string for later use.
+The `choiceOf` (disjunction) construct matches one out of several possible sequences. It functions similarly to a logical OR operator in programming. It can match simple string options as well as complex patterns.
+
+Example: `choiceOf("color", "colour")` matches either `color` or `colour` pattern.
 
-### `nonCaptureGroup()`
+### `capture()`
 
 ```ts
-function nonCaptureGroup(
+function capture(
   sequence: RegexSequence
-): NonCaptureGroup
+): Capture
 ```
 
-Regex syntax: `(?:...)`.
+Regex syntax: `(...)`.
+
+Captures, also known as capturing groups, extract and store parts of the matched string for later use.
 
-Groups multiple tokens together without creating a capture group.
+> [!NOTE]
+> TS Regex Builder does not have a construct for non-capturing groups. Such groups are implicitly added when required. E.g., `zeroOrMore(["abc"])` is encoded as `(?:abc)+`.
 
-### `positiveLookahead()`
+### `lookahead()`
 
 ```ts
-function positiveLookahead(
+function lookahead(
   sequence: RegexSequence
-): PositiveLookahead
+): Lookahead
 ```
 
 Regex syntax: `(?=...)`.
 
-Matches a group after the main expression without including it in the result.
+Allows for conditional matching by checking for subsequent patterns in regexes without consuming them.
 
 ### `negativeLookahead()`
 
@@ -92,19 +97,19 @@ function negativeLookahead(
 
 Regex syntax: `(?!...)`.
 
-Specifies a group that can not match after the main expression (if it matches, the result is discarded).
+Allows for matches to be rejected if a specified subsequent pattern is present, without consuming any characters.
 
-### `positiveLookbehind()`
+### `lookbehind()`
 
 ```ts
-function positiveLookahead(
+function lookbehind(
   sequence: RegexSequence
-): PositiveLookahead
+): Lookahead
 ```
 
 Regex syntax: `(?<=...)`.
 
-Matches a group before the main expression without including it in the result.
+Allows for conditional matching by checking for preceeding patterns in regexes without consuming them.
 
 ### `negativeLookbehind()`
 
@@ -116,20 +121,7 @@ function negativeLookahead(
 
 Regex syntax: `(?<!...)`.
 
-Specifies a group that can not match before the main expression (if it matches, the result is discarded).
-### `choiceOf()`
-
-```ts
-function choiceOf(
-  ...alternatives: RegexSequence[]
-): ChoiceOf {
-```
-
-Regex syntax: `a|b|c`.
-
-The `choiceOf` (disjunction) construct matches one out of several possible sequences. It functions similarly to a logical OR operator in programming. It can match simple string options as well as complex patterns.
-
-Example: `choiceOf("color", "colour")` matches either `color` or `colour` pattern.
+Allows for matches to be rejected if a specified preceeding pattern is present, without consuming any characters.
 
 ## Quantifiers
 

src/index.ts

@@ -22,6 +22,5 @@ export { lookahead } from './constructs/lookahead';
 export { lookbehind } from './constructs/lookbehind';
 export { negativeLookahead } from './constructs/negative-lookahead';
 export { negativeLookbehind } from './constructs/negative-lookbehind';
-export { nonCaptureGroup } from './constructs/non-capture-group';
 export { oneOrMore, optional, zeroOrMore } from './constructs/quantifiers';
 export { repeat } from './constructs/repeat';