@ptolemy2002/rgx 7.5.0 → 7.7.0

package/README.md

@@ -110,6 +110,10 @@ type RGXWalkerOptions<R> = {
 type RGXWOptions<R = unknown> = Omit<RGXWalkerOptions<R>, "startingSourcePosition"> & {
     multiline?: boolean;
 };
+
+// See src/constants.ts for the actual mapping of predefined constant names to their token values
+type RGXPredefinedConstant = keyof typeof RGX_PREDEFINED_CONSTANTS;
+type RGXConstantName = RGXPredefinedConstant | (string & {});
 ```
 
 ## Classes
@@ -680,7 +684,7 @@ constructor(source: string, tokens: RGXTokenCollectionInput, options?: RGXWalker
 - `stopped` (`boolean`, readonly): Whether the walker has been stopped, either by a Part's `beforeCapture` returning `"stop"` or by calling `stop()` in an `afterCapture` callback.
 
 #### Methods
-- `stop() => void`: Sets `stopped` to `true`, causing any active `stepToToken`, `stepToPart`, or `walk` loop to halt after the current iteration. Typically called from an `afterCapture` callback to stop walking after the current capture.
+- `stop() => this`: Sets `stopped` to `true`, causing any active `stepToToken`, `stepToPart`, or `walk` loop to halt after the current iteration. Typically called from an `afterCapture` callback to stop walking after the current capture.
 - `atTokenEnd() => boolean`: Returns `true` if the token position is at or past the end of the token collection.
 - `hasNextToken(predicate?: (token: RGXToken) => boolean) => boolean`: Returns `true` if there is a current token and it satisfies the optional predicate (defaults to `() => true`).
 - `atSourceEnd() => boolean`: Returns `true` if the source has been fully consumed (`sourcePosition >= source.length`).
@@ -691,9 +695,9 @@ constructor(source: string, tokens: RGXTokenCollectionInput, options?: RGXWalker
 - `capture(token: RGXToken, includeMatch?: false) => string`: Resolves the token to a regex, asserts that it matches at the current source position (throwing `RGXRegexNotMatchedAtPositionError` if not), and advances the source position by the match length. Returns the matched string.
 - `capture(token: RGXToken, includeMatch: true) => RegExpExecArray`: Same as above, but returns the full `RegExpExecArray` from the match instead of just the matched string.
 - `step() => RGXCapture | null`: Steps through the next token in the collection. If the token is an `RGXPart`, calls `beforeCapture` first — if it returns `"stop"`, sets `stopped` and returns `null` without advancing; if `"skip"`, advances the token position and returns `null` without capturing; if `"silent"`, captures but does not add to `captures` or `namedCaptures`. After capturing, validates. After validating, calls `afterCapture` if present. Returns the `RGXCapture` result, or `null` if there are no more tokens (or no more source in `infinite`/`looping` mode), the step was skipped, or the walker was stopped.
-- `stepToToken(predicate: (token: RGXToken) => boolean) => void`: Steps through tokens until the predicate returns `true` for the current token or the walker is stopped. The matching token is not consumed.
-- `stepToPart(predicate?: (part: RGXPart<R>) => boolean) => void`: Steps through tokens until the next `RGXPart` satisfying the predicate is reached. If already at a Part, steps once first to move past it. The matching Part is not consumed.
-- `walk() => void`: Steps through all remaining tokens until the end of the token collection (or until the source is consumed in `infinite`/`looping` mode) or the walker is stopped.
+- `stepToToken(predicate: (token: RGXToken) => boolean) => this`: Steps through tokens until the predicate returns `true` for the current token or the walker is stopped. The matching token is not consumed.
+- `stepToPart(predicate?: (part: RGXPart<R>) => boolean) => this`: Steps through tokens until the next `RGXPart` satisfying the predicate is reached. If already at a Part, steps once first to move past it. The matching Part is not consumed.
+- `walk() => this`: Steps through all remaining tokens until the end of the token collection (or until the source is consumed in `infinite`/`looping` mode) or the walker is stopped.
 - `toRgx() => RGXToken`: Returns the internal `RGXTokenCollection`, allowing the walker to be used as a convertible token.
 - `clone(depth: CloneDepth = "max") => RGXWalker`: Creates a clone of the walker. When `depth` is `0`, returns `this`; otherwise, creates a new `RGXWalker` with cloned tokens, source position, reduced value, captures, stopped state, and the `infinite`/`looping` flags.
 
@@ -1551,6 +1555,13 @@ Creates a clone of the given RGX token to the given depth, provided that the tok
 #### Returns
 - `T`: The cloned token.
 
+### RGX_PREDEFINED_CONSTANTS
+```typescript
+const RGX_PREDEFINED_CONSTANTS: Record<RGXPredefinedConstant, RGXToken>
+```
+
+A read-only object containing all of the library's built-in constant definitions, keyed by their `RGXPredefinedConstant` name. This is the source from which the predefined constants are registered at module load time. It can be used to inspect available constant names at compile time (via `keyof typeof RGX_PREDEFINED_CONSTANTS`) or to iterate over the predefined set without calling `listRGXConstants`.
+
 ### listRGXConstants
 ```typescript
 function listRGXConstants(): string[]
@@ -1563,52 +1574,52 @@ Returns the names of all currently defined RGX constants.
 
 ### hasRGXConstant
 ```typescript
-function hasRGXConstant(name: string): boolean
+function hasRGXConstant(name: RGXConstantName): boolean
 ```
 
 Checks if an RGX constant with the given name exists.
 
 #### Parameters
-  - `name` (`string`): The constant name to check.
+  - `name` (`RGXConstantName`): The constant name to check.
 
 #### Returns
 - `boolean`: `true` if the constant exists, otherwise `false`.
 
 ### assertHasRGXConstant
 ```typescript
-function assertHasRGXConstant(name: string): void
+function assertHasRGXConstant(name: RGXConstantName): void
 ```
 
 Asserts that an RGX constant with the given name exists. If the assertion fails, an `RGXInvalidConstantKeyError` will be thrown.
 
 #### Parameters
-  - `name` (`string`): The constant name to assert.
+  - `name` (`RGXConstantName`): The constant name to assert.
 
 #### Returns
 - `void`: This function does not return a value, but will throw an error if the assertion fails.
 
 ### assertNotHasRGXConstant
 ```typescript
-function assertNotHasRGXConstant(name: string): void
+function assertNotHasRGXConstant(name: RGXConstantName): void
 ```
 
 Asserts that an RGX constant with the given name does not exist. If the assertion fails, an `RGXConstantConflictError` will be thrown.
 
 #### Parameters
-  - `name` (`string`): The constant name to assert.
+  - `name` (`RGXConstantName`): The constant name to assert.
 
 #### Returns
 - `void`: This function does not return a value, but will throw an error if the assertion fails.
 
 ### defineRGXConstant
 ```typescript
-function defineRGXConstant(name: string, value: RGXToken): RGXToken
+function defineRGXConstant(name: RGXConstantName, value: RGXToken): RGXToken
 ```
 
 Defines a new RGX constant with the given name and value. If the value is a native token (string, number, boolean, or no-op), it is automatically wrapped in an `RGXClassWrapperToken` before being stored. This ensures that native-valued constants are not stripped by multiline template processing in `rgx`, since only the literal string parts of the template are affected by multiline mode. Throws an `RGXConstantConflictError` if a constant with the same name already exists.
 
 #### Parameters
-  - `name` (`string`): The name for the constant.
+  - `name` (`RGXConstantName`): The name for the constant.
   - `value` (`RGXToken`): The token value to associate with the name. Native tokens are automatically wrapped in `RGXClassWrapperToken`.
 
 #### Returns
@@ -1616,26 +1627,26 @@ Defines a new RGX constant with the given name and value. If the value is a nati
 
 ### rgxConstant
 ```typescript
-function rgxConstant(name: string): RGXToken
+function rgxConstant(name: RGXConstantName): RGXToken
 ```
 
 Retrieves the value of an RGX constant by name. Throws an `RGXInvalidConstantKeyError` if no constant with the given name exists.
 
 #### Parameters
-  - `name` (`string`): The constant name to retrieve.
+  - `name` (`RGXConstantName`): The constant name to retrieve.
 
 #### Returns
 - `RGXToken`: The token value associated with the constant name.
 
 ### deleteRGXConstant
 ```typescript
-function deleteRGXConstant(name: string): void
+function deleteRGXConstant(name: RGXConstantName): void
 ```
 
 Deletes an existing RGX constant by name. Throws an `RGXInvalidConstantKeyError` if no constant with the given name exists.
 
 #### Parameters
-  - `name` (`string`): The constant name to delete.
+  - `name` (`RGXConstantName`): The constant name to delete.
 
 #### Returns
 - `void`: This function does not return a value, but will throw an error if the constant does not exist.
@@ -1657,7 +1668,8 @@ Since these are defined as native tokens (strings), they are automatically wrapp
 ### Special Characters
 | Name | Resolves To | Description |
 | --- | --- | --- |
-| `"any"` | `.` | Matches any single character (except newline by default) |
+| `"any"` | `(?s:.)` | Matches any single character, including newlines |
+| `"non-newline"` | `.` | Matches any single character except newlines |
 | `"start"` | `^` | Start of string anchor |
 | `"line-start"` | `^` (with `m` flag) | Start of line anchor |
 | `"end"` | `$` | End of string anchor |

package/dist/constants.d.ts

@@ -1,8 +1,133 @@
 import { RGXToken } from "./types";
+export declare const RGX_PREDEFINED_CONSTANTS: {
+    readonly newline: "\n";
+    readonly "carriage-return": "\r";
+    readonly tab: "\t";
+    readonly null: "\0";
+    readonly "form-feed": "\f";
+    readonly any: {
+        readonly rgxGroupWrap: false;
+        readonly toRgx: () => RegExp;
+    };
+    readonly "non-newline": {
+        readonly rgxGroupWrap: false;
+        readonly toRgx: () => RegExp;
+    };
+    readonly start: {
+        readonly rgxGroupWrap: false;
+        readonly rgxIsRepeatable: false;
+        readonly toRgx: () => RegExp;
+    };
+    readonly "line-start": {
+        readonly rgxGroupWrap: false;
+        readonly rgxIsRepeatable: false;
+        readonly toRgx: () => RegExp;
+    };
+    readonly end: {
+        readonly rgxGroupWrap: false;
+        readonly rgxIsRepeatable: false;
+        readonly toRgx: () => RegExp;
+    };
+    readonly "line-end": {
+        readonly rgxGroupWrap: false;
+        readonly rgxIsRepeatable: false;
+        readonly toRgx: () => RegExp;
+    };
+    readonly "word-bound": {
+        readonly rgxGroupWrap: false;
+        readonly rgxIsRepeatable: false;
+        readonly toRgx: () => RegExp;
+    };
+    readonly "non-word-bound": {
+        readonly rgxGroupWrap: false;
+        readonly rgxIsRepeatable: false;
+        readonly toRgx: () => RegExp;
+    };
+    readonly "word-bound-start": {
+        readonly rgxGroupWrap: false;
+        readonly rgxIsRepeatable: false;
+        readonly toRgx: () => RegExp;
+    };
+    readonly "word-bound-end": {
+        readonly rgxGroupWrap: false;
+        readonly rgxIsRepeatable: false;
+        readonly toRgx: () => RegExp;
+    };
+    readonly letter: {
+        readonly rgxIsGroup: true;
+        readonly rgxGroupWrap: false;
+        readonly toRgx: () => RegExp;
+    };
+    readonly "lowercase-letter": {
+        readonly rgxIsGroup: true;
+        readonly rgxGroupWrap: false;
+        readonly toRgx: () => RegExp;
+    };
+    readonly "uppercase-letter": {
+        readonly rgxIsGroup: true;
+        readonly rgxGroupWrap: false;
+        readonly toRgx: () => RegExp;
+    };
+    readonly "non-letter": {
+        readonly rgxIsGroup: true;
+        readonly rgxGroupWrap: false;
+        readonly toRgx: () => RegExp;
+    };
+    readonly alphanumeric: {
+        readonly rgxIsGroup: true;
+        readonly rgxGroupWrap: false;
+        readonly toRgx: () => RegExp;
+    };
+    readonly "non-alphanumeric": {
+        readonly rgxIsGroup: true;
+        readonly rgxGroupWrap: false;
+        readonly toRgx: () => RegExp;
+    };
+    readonly digit: {
+        readonly rgxGroupWrap: false;
+        readonly toRgx: () => RegExp;
+    };
+    readonly "non-digit": {
+        readonly rgxGroupWrap: false;
+        readonly toRgx: () => RegExp;
+    };
+    readonly whitespace: {
+        readonly rgxGroupWrap: false;
+        readonly toRgx: () => RegExp;
+    };
+    readonly "non-whitespace": {
+        readonly rgxGroupWrap: false;
+        readonly toRgx: () => RegExp;
+    };
+    readonly "vertical-whitespace": {
+        readonly rgxGroupWrap: false;
+        readonly toRgx: () => RegExp;
+    };
+    readonly "word-char": {
+        readonly rgxGroupWrap: false;
+        readonly toRgx: () => RegExp;
+    };
+    readonly "non-word-char": {
+        readonly rgxGroupWrap: false;
+        readonly toRgx: () => RegExp;
+    };
+    readonly backspace: {
+        readonly rgxIsGroup: true;
+        readonly rgxGroupWrap: false;
+        readonly toRgx: () => RegExp;
+    };
+    readonly "non-escape-bound": {
+        readonly rgxGroupWrap: false;
+        readonly rgxIsRepeatable: false;
+        readonly toRgx: () => RegExp;
+    };
+};
+export type RGXPredefinedConstant = keyof typeof RGX_PREDEFINED_CONSTANTS;
+export type RGXConstantName = RGXPredefinedConstant | (string & {});
 export declare function listRGXConstants(): string[];
-export declare function hasRGXConstant(name: string): boolean;
-export declare function assertHasRGXConstant(name: string): void;
-export declare function assertNotHasRGXConstant(name: string): void;
-export declare function defineRGXConstant(name: string, value: RGXToken): RegExp | import("./types").RGXConvertibleToken | RGXToken[];
-export declare function rgxConstant(name: string): RGXToken;
-export declare function deleteRGXConstant(name: string): void;
+export declare function hasRGXConstant(name: RGXConstantName): boolean;
+export declare function assertHasRGXConstant(name: RGXConstantName): void;
+export declare function assertNotHasRGXConstant(name: RGXConstantName): void;
+export declare function defineRGXConstant(name: RGXConstantName, value: RGXToken): RegExp | import("./types").RGXConvertibleToken | RGXToken[];
+export declare function rgxConstant(name: RGXConstantName): RGXToken;
+export declare function deleteRGXConstant(name: RGXConstantName): void;

package/dist/constants.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RGX_PREDEFINED_CONSTANTS = void 0;
 exports.listRGXConstants = listRGXConstants;
 exports.hasRGXConstant = hasRGXConstant;
 exports.assertHasRGXConstant = assertHasRGXConstant;
@@ -11,6 +12,143 @@ const class_1 = require("./class");
 const errors_1 = require("./errors");
 const typeGuards_1 = require("./typeGuards");
 const rgxConstants = {};
+exports.RGX_PREDEFINED_CONSTANTS = {
+    // Control Characters
+    "newline": "\n",
+    "carriage-return": "\r",
+    "tab": "\t",
+    "null": "\0",
+    "form-feed": "\f",
+    // Special Characters
+    "any": {
+        rgxGroupWrap: false,
+        toRgx() { return /./s; }
+    },
+    "non-newline": {
+        rgxGroupWrap: false,
+        toRgx() { return /./; }
+    },
+    "start": {
+        rgxGroupWrap: false,
+        rgxIsRepeatable: false,
+        toRgx() { return /^/; }
+    },
+    "line-start": {
+        rgxGroupWrap: false,
+        rgxIsRepeatable: false,
+        toRgx() { return /^/m; }
+    },
+    "end": {
+        rgxGroupWrap: false,
+        rgxIsRepeatable: false,
+        toRgx() { return /$/; }
+    },
+    "line-end": {
+        rgxGroupWrap: false,
+        rgxIsRepeatable: false,
+        toRgx() { return /$/m; }
+    },
+    "word-bound": {
+        rgxGroupWrap: false,
+        rgxIsRepeatable: false,
+        toRgx() { return /\b/; }
+    },
+    "non-word-bound": {
+        rgxGroupWrap: false,
+        rgxIsRepeatable: false,
+        toRgx() { return /\B/; }
+    },
+    "word-bound-start": {
+        rgxGroupWrap: false,
+        rgxIsRepeatable: false,
+        toRgx() {
+            // Make sure there is a non-word character before and a word character after
+            return /(?<=\W)(?=\w)/;
+        }
+    },
+    "word-bound-end": {
+        rgxGroupWrap: false,
+        rgxIsRepeatable: false,
+        toRgx() {
+            // Make sure there is a word character before and a non-word character after
+            return /(?<=\w)(?=\W)/;
+        }
+    },
+    // Character Sets
+    "letter": {
+        rgxIsGroup: true,
+        rgxGroupWrap: false,
+        toRgx() { return /[a-zA-Z]/; }
+    },
+    "lowercase-letter": {
+        rgxIsGroup: true,
+        rgxGroupWrap: false,
+        toRgx() { return /[a-z]/; }
+    },
+    "uppercase-letter": {
+        rgxIsGroup: true,
+        rgxGroupWrap: false,
+        toRgx() { return /[A-Z]/; }
+    },
+    "non-letter": {
+        rgxIsGroup: true,
+        rgxGroupWrap: false,
+        toRgx() { return /[^a-zA-Z]/; }
+    },
+    "alphanumeric": {
+        rgxIsGroup: true,
+        rgxGroupWrap: false,
+        toRgx() { return /[a-zA-Z0-9]/; }
+    },
+    "non-alphanumeric": {
+        rgxIsGroup: true,
+        rgxGroupWrap: false,
+        toRgx() { return /[^a-zA-Z0-9]/; }
+    },
+    // Predefined Character Sets
+    "digit": {
+        rgxGroupWrap: false,
+        toRgx() { return /\d/; }
+    },
+    "non-digit": {
+        rgxGroupWrap: false,
+        toRgx() { return /\D/; }
+    },
+    "whitespace": {
+        rgxGroupWrap: false,
+        toRgx() { return /\s/; }
+    },
+    "non-whitespace": {
+        rgxGroupWrap: false,
+        toRgx() { return /\S/; }
+    },
+    "vertical-whitespace": {
+        rgxGroupWrap: false,
+        toRgx() { return /\v/; }
+    },
+    "word-char": {
+        rgxGroupWrap: false,
+        toRgx() { return /\w/; }
+    },
+    "non-word-char": {
+        rgxGroupWrap: false,
+        toRgx() { return /\W/; }
+    },
+    "backspace": {
+        rgxIsGroup: true,
+        rgxGroupWrap: false,
+        toRgx() { return /[\b]/; }
+    },
+    // Complex Constructs
+    "non-escape-bound": {
+        rgxGroupWrap: false,
+        rgxIsRepeatable: false,
+        toRgx() {
+            // Put this before any pattern to ensure that the pattern is not escaped, i.e., not preceded by an odd number of backslashes.
+            return /(?<=(?<!\\)(?:\\\\)*)(?=[^\\]|$)/;
+        }
+    },
+};
 function listRGXConstants() {
     return Object.keys(rgxConstants);
 }
@@ -41,176 +179,6 @@ function deleteRGXConstant(name) {
     assertHasRGXConstant(name);
     delete rgxConstants[name];
 }
-// Control Characters
-defineRGXConstant("newline", "\n");
-defineRGXConstant("carriage-return", "\r");
-defineRGXConstant("tab", "\t");
-defineRGXConstant("null", "\0");
-defineRGXConstant("form-feed", "\f");
-// Special Characters
-defineRGXConstant("any", {
-    rgxGroupWrap: false,
-    toRgx() {
-        return /./;
-    }
-});
-defineRGXConstant("start", {
-    rgxGroupWrap: false,
-    rgxIsRepeatable: false,
-    toRgx() {
-        return /^/;
-    }
-});
-defineRGXConstant("line-start", {
-    rgxGroupWrap: false,
-    rgxIsRepeatable: false,
-    toRgx() {
-        return /^/m;
-    }
-});
-defineRGXConstant("end", {
-    rgxGroupWrap: false,
-    rgxIsRepeatable: false,
-    toRgx() {
-        return /$/;
-    }
-});
-defineRGXConstant("line-end", {
-    rgxGroupWrap: false,
-    rgxIsRepeatable: false,
-    toRgx() {
-        return /$/m;
-    }
-});
-defineRGXConstant("word-bound", {
-    rgxGroupWrap: false,
-    rgxIsRepeatable: false,
-    toRgx() {
-        return /\b/;
-    }
-});
-defineRGXConstant("non-word-bound", {
-    rgxGroupWrap: false,
-    rgxIsRepeatable: false,
-    toRgx() {
-        return /\B/;
-    }
-});
-defineRGXConstant("word-bound-start", {
-    rgxGroupWrap: false,
-    rgxIsRepeatable: false,
-    toRgx() {
-        // Make sure there is a non-word character before and a word character after
-        return /(?<=\W)(?=\w)/;
-    }
-});
-defineRGXConstant("word-bound-end", {
-    rgxGroupWrap: false,
-    rgxIsRepeatable: false,
-    toRgx() {
-        // Make sure there is a word character before and a non-word character after
-        return /(?<=\w)(?=\W)/;
-    }
-});
-// Character Sets
-defineRGXConstant("letter", {
-    rgxIsGroup: true,
-    rgxGroupWrap: false,
-    toRgx() {
-        return /[a-zA-Z]/;
-    }
-});
-defineRGXConstant("lowercase-letter", {
-    rgxIsGroup: true,
-    rgxGroupWrap: false,
-    toRgx() {
-        return /[a-z]/;
-    }
-});
-defineRGXConstant("uppercase-letter", {
-    rgxIsGroup: true,
-    rgxGroupWrap: false,
-    toRgx() {
-        return /[A-Z]/;
-    }
-});
-defineRGXConstant("non-letter", {
-    rgxIsGroup: true,
-    rgxGroupWrap: false,
-    toRgx() {
-        return /[^a-zA-Z]/;
-    }
-});
-defineRGXConstant("alphanumeric", {
-    rgxIsGroup: true,
-    rgxGroupWrap: false,
-    toRgx() {
-        return /[a-zA-Z0-9]/;
-    }
-});
-defineRGXConstant("non-alphanumeric", {
-    rgxIsGroup: true,
-    rgxGroupWrap: false,
-    toRgx() {
-        return /[^a-zA-Z0-9]/;
-    }
-});
-// Predefined Character Sets
-defineRGXConstant("digit", {
-    rgxGroupWrap: false,
-    toRgx() {
-        return /\d/;
-    }
-});
-defineRGXConstant("non-digit", {
-    rgxGroupWrap: false,
-    toRgx() {
-        return /\D/;
-    }
-});
-defineRGXConstant("whitespace", {
-    rgxGroupWrap: false,
-    toRgx() {
-        return /\s/;
-    }
-});
-defineRGXConstant("non-whitespace", {
-    rgxGroupWrap: false,
-    toRgx() {
-        return /\S/;
-    }
-});
-defineRGXConstant("vertical-whitespace", {
-    rgxGroupWrap: false,
-    toRgx() {
-        return /\v/;
-    }
-});
-defineRGXConstant("word-char", {
-    rgxGroupWrap: false,
-    toRgx() {
-        return /\w/;
-    }
-});
-defineRGXConstant("non-word-char", {
-    rgxGroupWrap: false,
-    toRgx() {
-        return /\W/;
-    }
-});
-defineRGXConstant("backspace", {
-    rgxIsGroup: true,
-    rgxGroupWrap: false,
-    toRgx() {
-        return /[\b]/;
-    }
-});
-// Complex Constructs
-// Put this before any pattern to ensure that the pattern is not escaped, i.e., not preceded by an odd number of backslashes.
-defineRGXConstant("non-escape-bound", {
-    rgxGroupWrap: false,
-    rgxIsRepeatable: false,
-    toRgx() {
-        return /(?<=(?<!\\)(?:\\\\)*)(?=[^\\]|$)/;
-    }
-});
+for (const [name, value] of Object.entries(exports.RGX_PREDEFINED_CONSTANTS)) {
+    defineRGXConstant(name, value);
+}

package/dist/walker/base.d.ts

@@ -27,7 +27,7 @@ export declare class RGXWalker<R> implements RGXConvertibleToken {
     set tokenPosition(value: number);
     get stopped(): boolean;
     constructor(source: string, tokens: RGXTokenCollectionInput, options?: RGXWalkerOptions<R>);
-    stop(): void;
+    stop(): this;
     atTokenEnd(): boolean;
     hasNextToken(predicate?: (token: RGXToken) => boolean): boolean;
     atSourceEnd(): boolean;
@@ -38,9 +38,9 @@ export declare class RGXWalker<R> implements RGXConvertibleToken {
     capture(token: RGXToken, includeMatch: true): RegExpExecArray;
     capture(token: RGXToken, includeMatch?: false): string;
     step(): RGXCapture | null;
-    stepToToken(predicate: (token: RGXToken) => boolean): void;
-    stepToPart(predicate?: (part: RGXPart<R>) => boolean): void;
-    walk(): void;
+    stepToToken(predicate: (token: RGXToken) => boolean): this;
+    stepToPart(predicate?: (part: RGXPart<R>) => boolean): this;
+    walk(): this;
     toRgx(): RGXTokenCollection;
     clone(depth?: CloneDepth): RGXWalker<R>;
 }

package/dist/walker/base.js

@@ -54,6 +54,7 @@ class RGXWalker {
     }
     stop() {
         this._stopped = true;
+        return this;
     }
     atTokenEnd() {
         return this.tokenPosition >= this.tokens.length;
@@ -137,7 +138,11 @@ class RGXWalker {
                 }
             }
         }
-        const captureResult = { raw, value, start, end, branch, ownerId: isPart && token.hasId() ? token.id : null };
+        const captureResult = {
+            raw, value, start, end, branch,
+            ownerId: isPart && token.hasId() ? token.id : null,
+            groups: isPart ? capture.groups ?? null : null
+        };
         // Validate the part. If validation fails, it will throw an error, so nothing below will run.
         if (isPart) {
             token.validate(captureResult, this);
@@ -172,6 +177,7 @@ class RGXWalker {
             if (this._stopped)
                 break;
         }
+        return this;
     }
     stepToPart(predicate = () => true) {
         // If currently at a Part, step past it first so repeated
@@ -180,9 +186,10 @@ class RGXWalker {
             this._stopped = false;
             this.step();
             if (this._stopped)
-                return;
+                return this;
         }
         this.stepToToken(token => token instanceof part_1.RGXPart && predicate(token));
+        return this;
     }
     walk() {
         return this.stepToToken(() => false);

package/dist/walker/part.d.ts

@@ -9,6 +9,7 @@ export type RGXCapture<T = unknown> = {
     end: number;
     ownerId: string | null;
     branch: number;
+    groups: Record<string, string> | null;
 };
 export type RGXPartOptions<R, T = string> = {
     id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ptolemy2002/rgx",
-    "version": "7.5.0",
+    "version": "7.7.0",
     "private": false,
     "main": "dist/index.js",
     "types": "dist/index.d.ts",