@ptolemy2002/rgx 12.5.0 → 12.7.1

package/README.md

@@ -16,6 +16,7 @@ Because there is so much to document, it has been broken up into multiple files.
   - [clone](./docs/util/clone.md) - The `cloneRGXToken` function, which creates a clone of a given RGX token to a specified depth.
   - [escapeRegex](./docs/util/escapeRegex.md) - The `escapeRegex` function, which escapes special regex characters in a given string and assures you that the result is valid Regex.
   - [regexMatchAtPosition](./docs/util/regexMatchAtPosition.md) - The `regexMatchAtPosition` function and related functions, which attempt to match a given regular expression at a specific position in a string.
+  - [regexMatchAfterPosition](./docs/util/regexMatchAfterPosition.md) - The `regexMatchAfterPosition` function and related functions, which search for a regular expression match at or after a specific position in a string.
   - [regexWithFlags](./docs/util/regexWithFlags.md) - The `regexWithFlags` function, which creates a new regular expression with the same source as a given regular expression but with different flags.
   - [createRegex](./docs/util/createRegex.md) - The `createRegex` function, which safely constructs a `RegExp` or `ExtRegExp` from a pattern string, converting `SyntaxError` into `RGXInvalidRegexStringError`.
   - [createRGXClassGuardFunction](./docs/util/createRGXClassGuardFunction.md) - The `createRGXClassGuardFunction` and `createAssertRGXClassGuardFunction` utilities for creating type guard and assertion functions for class instances.

package/dist/errors/base.d.ts

@@ -1,4 +1,4 @@
-export type RGXErrorCode = 'UNKNOWN' | 'INVALID_RGX_TOKEN' | 'INVALID_REGEX_STRING' | 'INVALID_REGEX_FLAGS' | 'INVALID_VANILLA_REGEX_FLAGS' | 'NOT_IMPLEMENTED' | 'NOT_SUPPORTED' | 'INVALID_IDENTIFIER' | 'OUT_OF_BOUNDS' | 'INVALID_FLAG_TRANSFORMER_KEY' | 'FLAG_TRANSFORMER_CONFLICT' | 'CONSTANT_CONFLICT' | 'INVALID_CONSTANT_KEY' | 'INSERTION_REJECTED' | 'REGEX_NOT_MATCHED_AT_POSITION' | 'PART_VALIDATION_FAILED' | 'INVALID_LEXER_MODE' | 'LEXEME_NOT_MATCHED_AT_POSITION' | 'INVALID_RGX_LEXER' | 'INVALID_RGX_WALKER' | 'INVALID_RGX_PART' | 'NOT_DIRECT_REGEXP';
+export type RGXErrorCode = 'UNKNOWN' | 'INVALID_RGX_TOKEN' | 'INVALID_REGEX_STRING' | 'INVALID_REGEX_FLAGS' | 'INVALID_VANILLA_REGEX_FLAGS' | 'NOT_IMPLEMENTED' | 'NOT_SUPPORTED' | 'INVALID_IDENTIFIER' | 'OUT_OF_BOUNDS' | 'INVALID_FLAG_TRANSFORMER_KEY' | 'FLAG_TRANSFORMER_CONFLICT' | 'CONSTANT_CONFLICT' | 'INVALID_CONSTANT_KEY' | 'INSERTION_REJECTED' | 'REGEX_NOT_MATCHED_AT_POSITION' | 'REGEX_NOT_MATCHED_AFTER_POSITION' | 'PART_VALIDATION_FAILED' | 'INVALID_LEXER_MODE' | 'LEXEME_NOT_MATCHED_AT_POSITION' | 'INVALID_RGX_LEXER' | 'INVALID_RGX_WALKER' | 'INVALID_RGX_PART' | 'NOT_DIRECT_REGEXP';
 export declare class RGXError extends Error {
     _message: string;
     code: RGXErrorCode;

package/dist/errors/index.d.ts

@@ -13,6 +13,7 @@ export * from './insertionRejected';
 export * from './constantConflict';
 export * from './invalidConstantKey';
 export * from './regexNotMatchedAtPosition';
+export * from './regexNotMatchedAfterPosition';
 export * from './partValidationFailed';
 export * from './invalidLexerMode';
 export * from './lexemeNotMatchedAtPosition';

package/dist/errors/index.js

@@ -29,6 +29,7 @@ __exportStar(require("./insertionRejected"), exports);
 __exportStar(require("./constantConflict"), exports);
 __exportStar(require("./invalidConstantKey"), exports);
 __exportStar(require("./regexNotMatchedAtPosition"), exports);
+__exportStar(require("./regexNotMatchedAfterPosition"), exports);
 __exportStar(require("./partValidationFailed"), exports);
 __exportStar(require("./invalidLexerMode"), exports);
 __exportStar(require("./lexemeNotMatchedAtPosition"), exports);

package/dist/errors/lexemeNotMatchedAtPosition.d.ts

@@ -1,5 +1,5 @@
-import { RGXError, RGXPartValidationFailedError, RGXRegexNotMatchedAtPositionError } from "./";
-export type LexemeNotMatchedCauseError = RGXRegexNotMatchedAtPositionError | RGXPartValidationFailedError;
+import { RGXError, RGXPartValidationFailedError, RGXRegexNotMatchedAfterPositionError, RGXRegexNotMatchedAtPositionError } from "./";
+export type LexemeNotMatchedCauseError = RGXRegexNotMatchedAtPositionError | RGXPartValidationFailedError | RGXRegexNotMatchedAfterPositionError;
 export type LexemeNotMatchedCause = {
     id: string;
     error: LexemeNotMatchedCauseError;

package/dist/errors/lexemeNotMatchedAtPosition.js

@@ -4,7 +4,7 @@ exports.RGXLexemeNotMatchedAtPositionError = void 0;
 exports.isLexemeNotMatchedCauseError = isLexemeNotMatchedCauseError;
 const errors_1 = require("./");
 function isLexemeNotMatchedCauseError(error) {
-    return error instanceof errors_1.RGXRegexNotMatchedAtPositionError || error instanceof errors_1.RGXPartValidationFailedError;
+    return error instanceof errors_1.RGXRegexNotMatchedAtPositionError || error instanceof errors_1.RGXPartValidationFailedError || error instanceof errors_1.RGXRegexNotMatchedAfterPositionError;
 }
 class RGXLexemeNotMatchedAtPositionError extends errors_1.RGXError {
     get position() {

package/dist/errors/regexNotMatchedAfterPosition.d.ts

@@ -0,0 +1,15 @@
+import { RGXError } from "./base";
+export declare class RGXRegexNotMatchedAfterPositionError extends RGXError {
+    pattern: RegExp;
+    source: string;
+    _position: number;
+    contextSize: number | null;
+    set position(value: number);
+    get position(): number;
+    constructor(message: string, pattern: RegExp, source: string, position: number, contextSize?: number | null);
+    sourceContext(): string;
+    hasLeftContext(): boolean;
+    hasRightContext(): boolean;
+    hasFullContext(): boolean;
+    calcMessage(message: string): string;
+}

package/dist/errors/regexNotMatchedAfterPosition.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RGXRegexNotMatchedAfterPositionError = void 0;
+const base_1 = require("./base");
+const outOfBounds_1 = require("./outOfBounds");
+class RGXRegexNotMatchedAfterPositionError extends base_1.RGXError {
+    set position(value) {
+        (0, outOfBounds_1.assertInRange)(value, { min: 0, max: this.source.length }, "position is outside the bounds of the source string");
+        this._position = value;
+    }
+    get position() {
+        return this._position;
+    }
+    constructor(message, pattern, source, position, contextSize = null) {
+        super(message, 'REGEX_NOT_MATCHED_AFTER_POSITION');
+        this.name = 'RGXRegexNotMatchedAfterPositionError';
+        this.pattern = pattern;
+        this.source = source;
+        this.position = position;
+        this.contextSize = contextSize;
+    }
+    sourceContext() {
+        if (this.hasFullContext())
+            return this.source;
+        const start = Math.max(0, this.position - this.contextSize);
+        const end = Math.min(this.source.length, this.position + this.contextSize);
+        return this.source.slice(start, end);
+    }
+    hasLeftContext() {
+        if (this.contextSize === null)
+            return false;
+        return this.position - this.contextSize >= 0;
+    }
+    hasRightContext() {
+        if (this.contextSize === null)
+            return false;
+        return this.position + this.contextSize <= this.source.length;
+    }
+    hasFullContext() {
+        return !this.hasLeftContext() && !this.hasRightContext();
+    }
+    calcMessage(message) {
+        let context = this.sourceContext();
+        if (this.contextSize !== null) {
+            if (this.hasLeftContext())
+                context = `...${context}`;
+            if (this.hasRightContext())
+                context = `${context}...`;
+        }
+        return `${message}; Pattern: ${this.pattern.toString()}, Position: ${this.position}, Context: ${context}`;
+    }
+}
+exports.RGXRegexNotMatchedAfterPositionError = RGXRegexNotMatchedAfterPositionError;

package/dist/utils/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./regexMatchAtPosition";
+export * from "./regexMatchAfterPosition";
 export * from "./regexWithFlags";
 export * from "./normalizeRegexFlags";
 export * from "./createRGXClassGuardFunction";

package/dist/utils/index.js

@@ -15,6 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./regexMatchAtPosition"), exports);
+__exportStar(require("./regexMatchAfterPosition"), exports);
 __exportStar(require("./regexWithFlags"), exports);
 __exportStar(require("./normalizeRegexFlags"), exports);
 __exportStar(require("./createRGXClassGuardFunction"), exports);

package/dist/utils/regexMatchAfterPosition.d.ts

@@ -0,0 +1,6 @@
+export declare function regexMatchAfterPosition(regex: RegExp, str: string, position: number, includeMatch: true): [number, RegExpExecArray] | null;
+export declare function regexMatchAfterPosition(regex: RegExp, str: string, position: number, includeMatch?: false): [number, string] | null;
+export declare function doesRegexMatchAfterPosition(regex: RegExp, str: string, position: number, includeMatch: true): [number, RegExpExecArray] | false;
+export declare function doesRegexMatchAfterPosition(regex: RegExp, str: string, position: number, includeMatch?: false): boolean;
+export declare function assertRegexMatchesAfterPosition(regex: RegExp, str: string, position: number, contextSize?: number | null, includeMatch?: false): [number, string];
+export declare function assertRegexMatchesAfterPosition(regex: RegExp, str: string, position: number, contextSize: number | null | undefined, includeMatch: true): [number, RegExpExecArray];

package/dist/utils/regexMatchAfterPosition.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.regexMatchAfterPosition = regexMatchAfterPosition;
+exports.doesRegexMatchAfterPosition = doesRegexMatchAfterPosition;
+exports.assertRegexMatchesAfterPosition = assertRegexMatchesAfterPosition;
+const outOfBounds_1 = require("../errors/outOfBounds");
+const regexWithFlags_1 = require("./regexWithFlags");
+const errors_1 = require("../errors");
+function regexMatchAfterPosition(regex, str, position, includeMatch = false) {
+    /*
+        The g flag means global mode, which searches forward from lastIndex rather
+        than requiring a match exactly there (as the y/sticky flag does). By setting
+        lastIndex to the position we want to search from, exec will find the next
+        match at or after that position.
+    */
+    (0, outOfBounds_1.assertInRange)(position, { min: 0, max: str.length, inclusiveRight: false }, 'String index out of bounds');
+    const globalRegex = (0, regexWithFlags_1.regexWithFlags)(regex, "g");
+    globalRegex.lastIndex = position;
+    const match = globalRegex.exec(str);
+    return match ? (includeMatch ? [match.index, match] : [match.index, match[0]]) : null;
+}
+function doesRegexMatchAfterPosition(regex, str, position, includeMatch = false) {
+    const match = regexMatchAfterPosition(regex, str, position, true);
+    if (includeMatch)
+        return match ?? false;
+    return match !== null;
+}
+function assertRegexMatchesAfterPosition(regex, str, position, contextSize = 10, includeMatch = false) {
+    const result = regexMatchAfterPosition(regex, str, position, true);
+    if (result === null) {
+        throw new errors_1.RGXRegexNotMatchedAfterPositionError("Regex not matched after index", regex, str, position, contextSize);
+    }
+    return includeMatch ? result : [result[0], result[1][0]];
+}

package/dist/walker/base.d.ts

@@ -7,8 +7,10 @@ export type RGXWalkerOptions<R, S = unknown> = {
     share?: S;
     infinite?: boolean;
     looping?: boolean;
+    contiguous?: boolean;
 };
 export type RGXTokenOrPart<R, S = unknown, T = unknown> = RGXToken | RGXPart<R, S, T>;
+export type RGXWalkerStepDirective = "stop" | "skip" | "silent";
 export declare class RGXWalker<R, S = unknown> {
     readonly source: string;
     _sourcePosition: number;
@@ -20,7 +22,9 @@ export declare class RGXWalker<R, S = unknown> {
     namedCaptures: Record<string, RGXCapture[]>;
     infinite: boolean;
     looping: boolean;
+    contiguous: boolean;
     private _stopped;
+    private _didReachEnd;
     static check: (value: unknown) => value is RGXWalker<unknown, unknown>;
     static assert: (value: unknown) => asserts value is RGXWalker<unknown, unknown>;
     get sourcePosition(): number;
@@ -39,6 +43,14 @@ export declare class RGXWalker<R, S = unknown> {
     remainingSource(): string | null;
     capture(token: RGXTokenOrPart<R, S>, includeMatch: true): RegExpExecArray;
     capture(token: RGXTokenOrPart<R, S>, includeMatch?: false): string;
+    private advanceToken;
+    private determineBranch;
+    private registerCapture;
+    private unregisterLastCapture;
+    private handleBeforeCapture;
+    private attemptCapture;
+    private validateCapture;
+    private handleAfterCapture;
     step(): RGXCapture | null;
     stepToToken(predicate: (token: RGXTokenOrPart<R>) => boolean): this;
     stepToPart(predicate?: (part: RGXPart<R, S, unknown>) => boolean): this;

package/dist/walker/base.js

@@ -26,7 +26,9 @@ function createBranchGroups(tokens) {
     }
 }
 function isMatchError(e) {
-    return e instanceof errors_1.RGXRegexNotMatchedAtPositionError || e instanceof errors_1.RGXPartValidationFailedError;
+    return (e instanceof errors_1.RGXRegexNotMatchedAtPositionError ||
+        e instanceof errors_1.RGXRegexNotMatchedAfterPositionError ||
+        e instanceof errors_1.RGXPartValidationFailedError);
 }
 class RGXWalker {
     get sourcePosition() {
@@ -50,6 +52,8 @@ class RGXWalker {
         this.captures = [];
         this.namedCaptures = {};
         this._stopped = false;
+        // Only relevant in infinite mode, tracking whether we've reached the end yet.
+        this._didReachEnd = false;
         this.source = source;
         this.sourcePosition = options.startingSourcePosition ?? 0;
         this.tokens = tokens;
@@ -58,6 +62,7 @@ class RGXWalker {
         this.share = options.share ?? null;
         this.infinite = options.infinite ?? false;
         this.looping = options.looping ?? false;
+        this.contiguous = options.contiguous ?? true;
     }
     stop() {
         this._stopped = true;
@@ -92,10 +97,123 @@ class RGXWalker {
     }
     capture(token, includeMatch = false) {
         const regex = (0, utils_1.createRegex)((0, resolve_1.resolveRGXToken)(part_1.RGXPart.check(token) ? token.token : token));
-        const match = (0, utils_1.assertRegexMatchesAtPosition)(regex, this.source, this.sourcePosition, 10, true);
-        this.sourcePosition += match[0].length;
+        const args = [regex, this.source, this.sourcePosition, 10, true];
+        let match;
+        let endPosition;
+        if (this.contiguous) {
+            match = (0, utils_1.assertRegexMatchesAtPosition)(...args);
+            endPosition = this.sourcePosition + match[0].length;
+        }
+        else {
+            const [startPosition, _match] = (0, utils_1.assertRegexMatchesAfterPosition)(...args);
+            match = _match;
+            endPosition = startPosition + match[0].length;
+        }
+        this.sourcePosition = endPosition;
         return includeMatch ? match : match[0];
     }
+    advanceToken() {
+        if (this.tokenPosition === this.tokens.length - 1)
+            this._didReachEnd = true;
+        if (!this.infinite || this.tokenPosition < this.tokens.length - 1) {
+            this.tokenPosition++;
+            if (this.looping && this.atTokenEnd()) {
+                this.tokenPosition = 0;
+            }
+        }
+    }
+    determineBranch(capture) {
+        for (let i = 0; i < capture.length - 1; i++) {
+            if (capture.groups?.[`rgx_branch_${i}`] !== undefined)
+                return i;
+        }
+        return 0;
+    }
+    registerCapture(captureResult, token) {
+        this.captures.push(captureResult);
+        if (token instanceof part_1.RGXPart && token.hasId()) {
+            if (!(token.id in this.namedCaptures))
+                this.namedCaptures[token.id] = [];
+            this.namedCaptures[token.id].push(captureResult);
+        }
+    }
+    unregisterLastCapture(token) {
+        this.captures.pop();
+        if (token instanceof part_1.RGXPart && token.hasId()) {
+            this.namedCaptures[token.id].pop();
+        }
+    }
+    handleBeforeCapture(token) {
+        const control = token.beforeCapture?.({ part: token, walker: this });
+        // If this happens, beforeCapture itself stopped the walker, so we just need to respect that.
+        if (this.stopped)
+            return "stop";
+        if (control === "stop" || control === "stop-silent")
+            return "stop";
+        if (control === "skip")
+            return "skip";
+        if (control === "silent")
+            return "silent";
+        return null;
+    }
+    // Returns the capture on success, or a directive on handled failure. Unhandled errors are rethrown.
+    attemptCapture(branchedToken, part) {
+        try {
+            return this.capture(branchedToken, true);
+        }
+        catch (e) {
+            if (part !== null && (e instanceof errors_1.RGXRegexNotMatchedAtPositionError || e instanceof errors_1.RGXRegexNotMatchedAfterPositionError)) {
+                const control = part.afterFailure?.(e, { part, walker: this });
+                // If this happens, afterFailure itself stopped the walker, so we just need to respect that.
+                if (this.stopped)
+                    return "stop";
+                if (control === "stop" || control === "stop-silent")
+                    return "stop";
+                if (control === "skip")
+                    return "skip";
+                // Handling silent is pointless here since it won't add a capture in either case, so we don't check for it.
+            }
+            throw e;
+        }
+    }
+    // Returns a directive on handled validation failure, null on success. Unhandled errors are rethrown.
+    validateCapture(token, captureResult, start) {
+        try {
+            token.validate(captureResult, { part: token, walker: this });
+            return null;
+        }
+        catch (e) {
+            this.sourcePosition = start; // Reset source position on validation failure
+            if (e instanceof errors_1.RGXPartValidationFailedError) {
+                const control = token.afterValidationFailure?.(e, { part: token, walker: this });
+                // If this happens, afterValidationFailure itself stopped the walker, so we just need to respect that.
+                if (this.stopped)
+                    return "stop";
+                if (control === "stop" || control === "stop-silent")
+                    return "stop";
+                if (control === "skip")
+                    return "skip";
+                // Handling silent is pointless here since it won't add a capture in either case, so we don't check for it.
+            }
+            throw e;
+        }
+    }
+    handleAfterCapture(token, captureResult, silent, start) {
+        const control = token.afterCapture?.(captureResult, { part: token, walker: this });
+        if (!silent && (control === "skip" || control === "silent" || control === "stop-silent")) {
+            this.unregisterLastCapture(token);
+        }
+        // If this happens, afterCapture itself stopped the walker, so we just need to respect that.
+        if (this.stopped)
+            return "stop";
+        if (control === "skip") {
+            this.sourcePosition = start;
+            return "skip";
+        }
+        if (control === "stop" || control === "stop-silent")
+            return "stop";
+        return null;
+    }
     step() {
         if (!this.infinite && !this.looping && this.atTokenEnd()) {
             this._stopped = true;
@@ -109,106 +227,81 @@ class RGXWalker {
         const token = this.currentToken();
         const isPart = token instanceof part_1.RGXPart;
         let silent = false;
-        // Ask Part what to do — control flow via return values, not flags.
         if (isPart) {
-            const control = token.beforeCapture?.({ part: token, walker: this });
-            if (control === "stop") {
+            const dir = this.handleBeforeCapture(token);
+            if (dir === "stop") {
                 this._stopped = true;
                 return null;
             }
-            if (control === "skip") {
-                this.tokenPosition++;
+            if (dir === "skip") {
+                this.advanceToken();
                 return null;
             }
-            if (control === "silent") {
-                silent = true;
-            }
+            silent = dir === "silent";
         }
-        // Capture the match
-        const start = this.sourcePosition;
-        let branchedToken;
-        if (isPart)
-            branchedToken = createBranchGroups(token.token);
-        else
-            branchedToken = createBranchGroups(token);
-        let capture;
+        const branchedToken = isPart ? createBranchGroups(token.token) : createBranchGroups(token);
+        let captureAttempt;
         try {
-            capture = this.capture(branchedToken, true);
+            captureAttempt = this.attemptCapture(branchedToken, isPart ? token : null);
+            if (captureAttempt === "stop") {
+                this._stopped = true;
+                return null;
+            }
+            if (captureAttempt === "skip") {
+                this.advanceToken();
+                return null;
+            }
         }
         catch (e) {
-            if (isPart && e instanceof errors_1.RGXRegexNotMatchedAtPositionError) {
-                const control = token.afterFailure?.(e, { part: token, walker: this });
-                if (control === "stop") {
+            if (e instanceof errors_1.RGXRegexNotMatchedAfterPositionError) {
+                // If we're in infinite mode, we've reached the end before, and we're at the end now,
+                // this is recoverable. Just stop the walker instead of throwing an error.
+                if (this.infinite && this._didReachEnd && this.tokenPosition === this.tokens.length - 1) {
                     this._stopped = true;
                     return null;
                 }
-                if (control === "skip") {
-                    this.tokenPosition++;
-                    return null;
-                }
-                // Handling silent is pointless here since it won't add a capture in either case, so we don't check for it.
             }
             throw e;
         }
-        const raw = isPart ? token.rawTransform(capture[0]) : capture[0];
+        // The reason we no longer track start as the position before attempting capture
+        // is the possibility of non-contiguous matches. In that case, there may be a gap between
+        // the previous position and the actual start of the capture.
+        const start = this.sourcePosition - captureAttempt[0].length;
+        const raw = isPart ? token.rawTransform(captureAttempt[0]) : captureAttempt[0];
         const end = this.sourcePosition;
         const value = isPart ? token.transform(raw) : raw;
-        let branch = 0;
-        // Determine branch index for captureResult by finding the first index
-        // with non-undefined match group.
-        for (let i = 0; i < capture.length - 1; i++) {
-            const branchKey = `rgx_branch_${i}`;
-            if (capture.groups && capture.groups[branchKey] !== undefined) {
-                branch = i;
-                break;
-            }
-        }
         const captureResult = {
-            raw, value, start, end, branch,
+            raw, value, start, end,
+            branch: this.determineBranch(captureAttempt),
             ownerId: isPart && token.hasId() ? token.id : null,
-            groups: capture.groups ?? null
+            groups: captureAttempt.groups ?? null
         };
-        // Validate the part. If validation fails, it will throw an error, so nothing below will run.
         if (isPart) {
-            try {
-                token.validate(captureResult, { part: token, walker: this });
-            }
-            catch (e) {
-                this.sourcePosition = start; // Reset source position on validation failure
-                if (e instanceof errors_1.RGXPartValidationFailedError) {
-                    const control = token.afterValidationFailure?.(e, { part: token, walker: this });
-                    if (control === "stop") {
-                        this._stopped = true;
-                        return null;
-                    }
-                    if (control === "skip") {
-                        this.tokenPosition++;
-                        return null;
-                    }
-                    // Handling silent is pointless here since it won't add a capture in either case, so we don't check for it.
-                }
-                throw e;
+            const dir = this.validateCapture(token, captureResult, start);
+            if (dir === "stop") {
+                this._stopped = true;
+                return null;
             }
-        }
-        // Skip adding the capture if in silent mode.
-        if (!silent) {
-            this.captures.push(captureResult);
-            if (isPart && token.hasId()) {
-                if (!(token.id in this.namedCaptures))
-                    this.namedCaptures[token.id] = [];
-                this.namedCaptures[token.id].push(captureResult);
+            if (dir === "skip") {
+                this.advanceToken();
+                return null;
             }
         }
-        // Notify Part after capture
+        if (!silent)
+            this.registerCapture(captureResult, token);
         if (isPart) {
-            token.afterCapture?.(captureResult, { part: token, walker: this });
-        }
-        if (!this.infinite || this.tokenPosition < this.tokens.length - 1) {
-            this.tokenPosition++;
-            if (this.looping && this.atTokenEnd()) {
-                this.tokenPosition = 0;
+            const dir = this.handleAfterCapture(token, captureResult, silent, start);
+            if (dir === "stop") {
+                this.advanceToken();
+                this._stopped = true;
+                return null;
+            }
+            if (dir === "skip") {
+                this.advanceToken();
+                return null;
             }
         }
+        this.advanceToken();
         return captureResult;
     }
     stepToToken(predicate) {

package/dist/walker/part.d.ts

@@ -1,8 +1,8 @@
 import { RGXToken } from "../types";
 import type { RGXWalker } from "./base";
 import { CloneDepth } from "@ptolemy2002/immutability-utils";
-import { RGXPartValidationFailedError, RGXRegexNotMatchedAtPositionError } from "../errors";
-export type RGXPartControl = "skip" | "stop" | "silent" | void;
+import { RGXPartValidationFailedError, RGXRegexNotMatchedAfterPositionError, RGXRegexNotMatchedAtPositionError } from "../errors";
+export type RGXPartControl = "skip" | "stop" | "silent" | "stop-silent" | void;
 export type RGXCapture<T = unknown> = {
     raw: string;
     value: T;
@@ -22,8 +22,8 @@ export type RGXPartOptions<R, S = unknown, T = string> = {
     transform: (captured: string) => T;
     validate: (captured: RGXCapture<T>, context: RGXPartContext<R, S, T>) => boolean | string;
     beforeCapture: ((context: RGXPartContext<R, S, T>) => RGXPartControl) | null;
-    afterCapture: ((capture: RGXCapture<T>, context: RGXPartContext<R, S, T>) => void) | null;
-    afterFailure: ((e: RGXRegexNotMatchedAtPositionError, context: RGXPartContext<R, S, T>) => RGXPartControl) | null;
+    afterCapture: ((capture: RGXCapture<T>, context: RGXPartContext<R, S, T>) => RGXPartControl) | null;
+    afterFailure: ((e: RGXRegexNotMatchedAtPositionError | RGXRegexNotMatchedAfterPositionError, context: RGXPartContext<R, S, T>) => RGXPartControl) | null;
     afterValidationFailure: ((e: RGXPartValidationFailedError, context: RGXPartContext<R, S, T>) => RGXPartControl) | null;
 };
 export declare class RGXPart<R, S = unknown, T = string> {

package/dist/walker/part.js

@@ -38,6 +38,8 @@ class RGXPart {
             transform: this.transform,
             beforeCapture: this.beforeCapture,
             afterCapture: this.afterCapture,
+            afterFailure: this.afterFailure,
+            afterValidationFailure: this.afterValidationFailure,
         });
     }
 }

package/package.json

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