@ptolemy2002/rgx 8.2.0 → 10.0.0

package/dist/concat.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rgxConcat = rgxConcat;
+const ExtRegExp_1 = require("./ExtRegExp");
 const internal_1 = require("./internal");
 const resolve_1 = require("./resolve");
 // Wrapper for letting an array of tokens be resolved as a concatenation instead of a union.
 function rgxConcat(tokens, groupWrap = true, currentFlags = '') {
+    (0, ExtRegExp_1.assertValidRegexFlags)(currentFlags);
     const result = tokens.map(t => (0, resolve_1.resolveRGXToken)(t, groupWrap, true, currentFlags)).join('');
     (0, internal_1.assureAcceptance)(tokens, currentFlags);
     return result;

package/dist/errors/invalidRegexString.d.ts

@@ -1,6 +1,7 @@
 import { RGXError } from "./";
 export declare class RGXInvalidRegexStringError extends RGXError {
     got: string;
-    constructor(message: string, got: string);
+    cause: SyntaxError;
+    constructor(message: string, got: string, cause: SyntaxError);
     calcMessage(message: string): string;
 }

package/dist/errors/invalidRegexString.js

@@ -3,13 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RGXInvalidRegexStringError = void 0;
 const errors_1 = require("./");
 class RGXInvalidRegexStringError extends errors_1.RGXError {
-    constructor(message, got) {
+    constructor(message, got, cause) {
         super(message, 'INVALID_REGEX_STRING');
         this.name = 'RGXInvalidRegexStringError';
         this.got = got;
+        this.cause = cause;
     }
     calcMessage(message) {
-        return `${message}; Got: ${JSON.stringify(this.got)}`;
+        return `${message}; Got: ${JSON.stringify(this.got)}; Cause: ${this.cause.message}`;
     }
 }
 exports.RGXInvalidRegexStringError = RGXInvalidRegexStringError;

package/dist/index.d.ts

@@ -16,6 +16,6 @@ export * from "./constants";
 export * from "./walker";
 export * from "./lexer";
 export declare function rgxa(tokens: t.RGXToken[], flags?: string): ExtRegExp;
-export default function rgx(flags?: string, multiline?: boolean): (strings: TemplateStringsArray, ...tokens: t.RGXToken[]) => ExtRegExp;
-export declare function rgxwa<R = unknown, T = unknown>(source: string, tokens: RGXTokenOrPart<R, T>[], options?: Omit<t.RGXWOptions<R>, "multiline">): RGXWalker<R>;
-export declare function rgxw<R = unknown, T = unknown>(source: string, { multiline, ...options }?: t.RGXWOptions<R>): (strings: TemplateStringsArray, ...tokens: RGXTokenOrPart<R, T>[]) => RGXWalker<R>;
+export default function rgx(flags?: string, multiline?: boolean, verbatim?: boolean): (strings: TemplateStringsArray, ...tokens: t.RGXToken[]) => ExtRegExp;
+export declare function rgxwa<R = unknown, S = unknown, T = unknown>(source: string, tokens: RGXTokenOrPart<R, S, T>[], options?: Omit<t.RGXWOptions<R, S>, "multiline">): RGXWalker<R, S>;
+export declare function rgxw<R = unknown, S = unknown, T = unknown>(source: string, { multiline, verbatim, ...options }?: t.RGXWOptions<R, S>): (strings: TemplateStringsArray, ...tokens: RGXTokenOrPart<R, S, T>[]) => RGXWalker<R, S>;

package/dist/index.js

@@ -48,18 +48,19 @@ function rgxa(tokens, flags = '') {
     const pattern = (0, concat_1.rgxConcat)(tokens, true, flags);
     return (0, ExtRegExp_1.extRegExp)(pattern, flags);
 }
-function rgx(flags = '', multiline = true) {
+function rgx(flags = '', multiline = true, verbatim = true) {
     (0, ExtRegExp_1.assertValidRegexFlags)(flags);
     return (strings, ...tokens) => {
-        return rgxa((0, internal_1.taggedTemplateToArray)(strings, tokens, multiline), flags);
+        // It is safe to assert the result because we know there will be no parts passed in here.
+        return rgxa((0, internal_1.rgxTaggedTemplateToArray)(strings, tokens, multiline, verbatim), flags);
     };
 }
 function rgxwa(source, tokens, options = {}) {
     (0, internal_1.assureAcceptance)(tokens.map(t => walker_1.RGXPart.check(t) ? t.token : t), '');
     return new walker_1.RGXWalker(source, tokens, options);
 }
-function rgxw(source, { multiline = true, ...options } = {}) {
+function rgxw(source, { multiline = true, verbatim = true, ...options } = {}) {
     return (strings, ...tokens) => {
-        return rgxwa(source, (0, internal_1.taggedTemplateToArray)(strings, tokens, multiline), options);
+        return rgxwa(source, (0, internal_1.rgxTaggedTemplateToArray)(strings, tokens, multiline, verbatim), options);
     };
 }

package/dist/internal/taggedTemplateToArray.d.ts

@@ -1 +1,2 @@
-export declare function taggedTemplateToArray<T>(strings: TemplateStringsArray, tokens: T[], multiline: boolean): (string | T)[];
+import { RGXTokenOrPart } from "../walker";
+export declare function rgxTaggedTemplateToArray<R = unknown, S = unknown, T = unknown>(strings: TemplateStringsArray, tokens: RGXTokenOrPart<R, S, T>[], multiline: boolean, verbatim: boolean): RGXTokenOrPart<R, S, T>[];

package/dist/internal/taggedTemplateToArray.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.taggedTemplateToArray = taggedTemplateToArray;
-function taggedTemplateToArray(strings, tokens, multiline) {
+exports.rgxTaggedTemplateToArray = rgxTaggedTemplateToArray;
+function rgxTaggedTemplateToArray(strings, tokens, multiline, verbatim) {
     function isNullOrUndefined(value) {
         return value === null || value === undefined;
     }
@@ -12,13 +12,27 @@ function taggedTemplateToArray(strings, tokens, multiline) {
         // Strings always come before tokens
         if (!isNullOrUndefined(string)) {
             if (!multiline) {
-                array.push(string);
+                if (verbatim)
+                    array.push(string);
+                else
+                    array.push({ rgxInterpolate: true, toRgx: () => string });
             }
             else {
+                const startsNewLine = string.startsWith("\n");
                 // Remove all empty lines, remove comments, and trim whitespace from the start of each line.
                 let lines = string
                     .split("\n")
-                    .map(line => line.trimStart())
+                    /*
+                        This check makes sure
+                        `
+                            foo |
+                            ${'bar'} |
+                            baz
+                        `
+
+                        resolves to "foo | bar |baz" instead of "foo | bar|baz"
+                    */
+                    .map((line, i) => (i !== 0 || startsNewLine) ? line.trimStart() : line)
                     // Remove comments both for the start of the line.
                     .filter(line => !line.startsWith("//"))
                     .filter(line => line.length > 0)
@@ -31,7 +45,10 @@ function taggedTemplateToArray(strings, tokens, multiline) {
                     return line;
                 })
                     .join("");
-                array.push(lines);
+                if (verbatim)
+                    array.push(lines);
+                else
+                    array.push({ rgxInterpolate: true, toRgx: () => lines });
             }
         }
         if (!isNullOrUndefined(token))

package/dist/lexer/base.d.ts

@@ -1,13 +1,14 @@
 import { RGXToken } from "../types";
 import { RGXTokenOrPart, RGXWalkerOptions } from "../walker";
-export type RGXLexemeDefinition<Data> = Readonly<({
+export type RGXLexemeDefinition<Data, Share = unknown> = Readonly<({
     type: "resolve";
     token: RGXToken;
 } | {
     type: "walk";
-    tokens: RGXTokenOrPart<Data>[];
-    options?: Omit<RGXWalkerOptions<Data>, "startingSourcePosition" | "reduced"> & {
+    tokens: RGXTokenOrPart<Data, Share>[];
+    options?: Omit<RGXWalkerOptions<Data, Share>, "startingSourcePosition" | "reduced" | "share"> & {
         reduced?: (() => Data) | null;
+        share?: (() => Share) | null;
     };
 }) & {
     id: string;
@@ -20,23 +21,23 @@ export type RGXLexeme<Data> = {
     end: RGXLexemeLocation;
     data?: Data;
 };
-export type RGXLexemeDefinitions<Data> = Readonly<Record<string, ReadonlyArray<RGXLexemeDefinition<Data>>>>;
+export type RGXLexemeDefinitions<Data, Share = unknown> = Readonly<Record<string, ReadonlyArray<RGXLexemeDefinition<Data, Share>>>>;
 export type RGXLexemeLocation = {
     index: number;
     line: number;
     column: number;
 };
 export declare function rgxLexemeLocationFromIndex(source: string, index: number): RGXLexemeLocation;
-export declare class RGXLexer<Data> {
+export declare class RGXLexer<Data, Share = unknown> {
     readonly source: string;
     _position: number;
-    readonly lexemeDefinitions: RGXLexemeDefinitions<Data>;
+    readonly lexemeDefinitions: RGXLexemeDefinitions<Data, Share>;
     readonly matched: RGXLexeme<Data>[];
-    static check: (value: unknown) => value is RGXLexer<unknown>;
-    static assert: (value: unknown) => asserts value is RGXLexer<unknown>;
+    static check: (value: unknown) => value is RGXLexer<unknown, unknown>;
+    static assert: (value: unknown) => asserts value is RGXLexer<unknown, unknown>;
     get position(): number;
     set position(value: number);
-    constructor(source: string, lexemeDefinitions?: RGXLexemeDefinitions<Data>, startingPosition?: number);
+    constructor(source: string, lexemeDefinitions?: RGXLexemeDefinitions<Data, Share>, startingPosition?: number);
     private matchDefinition;
     private next;
     private expect;
@@ -56,4 +57,4 @@ export declare class RGXLexer<Data> {
     consumeWhile(predicate: (lexeme: RGXLexeme<Data>) => boolean, mode?: string, skipWhitespace?: boolean): RGXLexeme<Data>[];
     consumeUntil(predicate: (lexeme: RGXLexeme<Data>) => boolean, mode?: string, skipWhitespace?: boolean): RGXLexeme<Data>[];
 }
-export declare const rgxLexer: <Data>(...args: ConstructorParameters<typeof RGXLexer<Data>>) => RGXLexer<Data>;
+export declare const rgxLexer: <Data, Share = unknown>(...args: ConstructorParameters<typeof RGXLexer<Data, Share>>) => RGXLexer<Data, Share>;

package/dist/lexer/base.js

@@ -52,10 +52,11 @@ class RGXLexer {
             // No data part for token lexemes.
         }
         else {
-            const { tokens, options: { reduced, ...options } = {} } = lexemeDefinition;
+            const { tokens, options: { reduced, share, ...options } = {} } = lexemeDefinition;
             const walker = new walker_1.RGXWalker(this.source, tokens, {
                 ...options,
                 reduced: reduced?.() ?? undefined,
+                share: share?.() ?? undefined,
                 startingSourcePosition: startPosition
             });
             // Since the walker will throw an error if it fails to match to the end of its tokens (assuming it isn't stopped before then), this is safe.

package/dist/resolve.js

@@ -37,9 +37,12 @@ exports.escapeRegex = escapeRegex;
 exports.resolveRGXToken = resolveRGXToken;
 const class_1 = require("./class");
 const e = __importStar(require("./errors"));
+const ExtRegExp_1 = require("./ExtRegExp");
 const tg = __importStar(require("./typeGuards"));
 function escapeRegex(value) {
-    return value.replaceAll(/[\-\^\$.*+?^${}()|[\]\\]/g, '\\$&');
+    const result = value.replaceAll(/[\-\^\$.*+?^${}()|[\]\\]/g, '\\$&');
+    tg.assertValidRegexString(result);
+    return result;
 }
 function localizableVanillaRegexFlagDiff(prev, next) {
     // Remove anything other than the "ims" flags from both strings, as
@@ -56,44 +59,55 @@ function localizableVanillaRegexFlagDiff(prev, next) {
     return `${added}-${removed}`;
 }
 function resolveRGXToken(token, groupWrap = true, topLevel = true, currentFlags = '') {
-    if (tg.isRGXNoOpToken(token))
-        return '';
-    if (tg.isRGXLiteralToken(token)) {
-        const localizableFlagDiff = localizableVanillaRegexFlagDiff(currentFlags, token.flags);
-        currentFlags = token.flags;
-        if (!localizableFlagDiff) {
-            if (groupWrap)
-                return '(?:' + token.source + ')';
-            else
-                return token.source;
+    (0, ExtRegExp_1.assertValidRegexFlags)(currentFlags);
+    const innerResolve = () => {
+        if (tg.isRGXNoOpToken(token))
+            return '';
+        if (tg.isRGXLiteralToken(token)) {
+            const localizableFlagDiff = localizableVanillaRegexFlagDiff(currentFlags, token.flags);
+            currentFlags = token.flags;
+            if (!localizableFlagDiff) {
+                if (groupWrap)
+                    return '(?:' + token.source + ')';
+                else
+                    return token.source;
+            }
+            else {
+                return `(?${localizableFlagDiff}:${token.source})`;
+            }
         }
-        else {
-            return `(?${localizableFlagDiff}:${token.source})`;
+        if (tg.isRGXNativeToken(token))
+            return escapeRegex(String(token));
+        if (tg.isRGXConvertibleToken(token)) {
+            // If it's an interpolation, we want to just return it as-is.
+            // This will mean the result might be an invalid regex string,
+            // but that's why we have a check.
+            if (token.rgxInterpolate)
+                return String(token.toRgx());
+            // The top-level group-wrapping preference propogates to a direct convertible token, but after that
+            // the preference falls back to true whenever a token doesn't explicitly specify a preference.
+            return resolveRGXToken(token.toRgx(), token.rgxGroupWrap ?? (topLevel ? groupWrap : true), false, currentFlags);
         }
-    }
-    if (tg.isRGXNativeToken(token))
-        return escapeRegex(String(token));
-    if (tg.isRGXConvertibleToken(token)) {
-        // The top-level group-wrapping preference propogates to a direct convertible token, but after that
-        // the preference falls back to true whenever a token doesn't explicitly specify a preference.
-        return resolveRGXToken(token.toRgx(), token.rgxGroupWrap ?? (topLevel ? groupWrap : true), false, currentFlags);
-    }
-    // Interpret arrays as unions
-    if (tg.isRGXArrayToken(token, false)) {
-        if (token.length === 0)
-            return '';
-        if (token.length > 1) {
-            // Remove duplicates
-            token = [...(0, class_1.removeRgxUnionDuplicates)(...token)];
-            // Don't preserve group wrapping preference for the recursive calls
-            if (groupWrap)
-                return '(?:' + token.map(t => resolveRGXToken(t, true, false, currentFlags)).join('|') + ')';
-            else
-                return token.map(t => resolveRGXToken(t, true, false, currentFlags)).join('|');
+        // Interpret arrays as unions
+        if (tg.isRGXArrayToken(token, false)) {
+            if (token.length === 0)
+                return '';
+            if (token.length > 1) {
+                // Remove duplicates
+                token = [...(0, class_1.removeRgxUnionDuplicates)(...token)];
+                // Don't preserve group wrapping preference for the recursive calls
+                if (groupWrap)
+                    return '(?:' + token.map(t => resolveRGXToken(t, true, false, currentFlags)).join('|') + ')';
+                else
+                    return token.map(t => resolveRGXToken(t, true, false, currentFlags)).join('|');
+            }
+            return resolveRGXToken(token[0], true, false, currentFlags);
         }
-        return resolveRGXToken(token[0], true, false, currentFlags);
-    }
-    // Ignoring this line since it should be impossible to reach if the types are correct, but we need it to satisfy the return type
-    /* istanbul ignore next */
-    throw new e.RGXInvalidTokenError(`Invalid RGX token: ${token}`, null, token);
+        // Ignoring this line since it should be impossible to reach if the types are correct, but we need it to satisfy the return type
+        /* istanbul ignore next */
+        throw new e.RGXInvalidTokenError(`Invalid RGX token: ${token}`, null, token);
+    };
+    const result = innerResolve();
+    tg.assertValidRegexString(result);
+    return result;
 }

package/dist/typeGuards.js

@@ -93,13 +93,15 @@ function assertRGXNativeToken(value) {
 }
 function isRGXConvertibleToken(value, returnCheck = true) {
     if (typeof value === 'object' && value !== null && 'toRgx' in value) {
-        // The rgxGroupWrap, rgxIsRepeatable, and rgxIsGroup properties are optional, but if they exist they must be booleans.
+        // The rgxGroupWrap, interpolate, rgxIsRepeatable, and rgxIsGroup properties are optional, but if they exist they must be booleans.
         if ('rgxGroupWrap' in value && typeof value.rgxGroupWrap !== 'boolean')
             return false;
         if ('rgxIsRepeatable' in value && typeof value.rgxIsRepeatable !== 'boolean')
             return false;
         if ('rgxIsGroup' in value && typeof value.rgxIsGroup !== 'boolean')
             return false;
+        if ('rgxInterpolate' in value && typeof value.rgxInterpolate !== 'boolean')
+            return false;
         // If the rgxAcceptInsertion property exists, it must be a function that returns a string or boolean.
         if ('rgxAcceptInsertion' in value) {
             if (!(0, is_callable_1.default)(value.rgxAcceptInsertion))
@@ -240,13 +242,30 @@ function isValidRegexString(value) {
         new RegExp(value);
         return true;
     }
-    catch {
-        return false;
+    catch (e) {
+        if (e instanceof SyntaxError) {
+            return false;
+        }
+        // This is ignored because I don't know what king of
+        // unexpected errors might happen.
+        /* istanbul ignore next */
+        throw e;
     }
 }
 function assertValidRegexString(value) {
     if (!isValidRegexString(value)) {
-        throw new e.RGXInvalidRegexStringError("Invalid regex string", value);
+        try {
+            new RegExp(value);
+        }
+        catch (err) {
+            if (err instanceof SyntaxError) {
+                throw new e.RGXInvalidRegexStringError("Invalid regex string", value, err);
+            }
+            // This is ignored because I don't know what king of
+            // unexpected errors might happen.
+            /* istanbul ignore next */
+            throw err;
+        }
     }
 }
 function isValidVanillaRegexFlags(value) {

package/dist/types.d.ts

@@ -12,6 +12,7 @@ export type RGXConvertibleToken = {
     readonly rgxGroupWrap?: boolean;
     readonly rgxIsGroup?: boolean;
     readonly rgxIsRepeatable?: boolean;
+    readonly rgxInterpolate?: boolean;
 };
 export type RGXToken = RGXNativeToken | RGXLiteralToken | RGXConvertibleToken | RGXToken[];
 export type RGXClassTokenConstructor = new (...args: unknown[]) => RGXClassToken;
@@ -49,6 +50,8 @@ export type ValidRegexFlags = Branded<string, [ValidRegexFlagsBrandSymbol]> | Va
 export declare const validIdentifierSymbol: unique symbol;
 export type ValidIdentifierBrandSymbol = typeof validIdentifierSymbol;
 export type ValidIdentifier = Branded<string, [ValidIdentifierBrandSymbol]>;
-export type RGXWOptions<R = unknown> = RGXWalkerOptions<R> & {
+export type RGXOptions = {
     multiline?: boolean;
+    verbatim?: boolean;
 };
+export type RGXWOptions<R = unknown, S = unknown> = RGXWalkerOptions<R, S> & RGXOptions;

package/dist/walker/base.d.ts

@@ -1,46 +1,48 @@
 import { CloneDepth } from "@ptolemy2002/immutability-utils";
 import { RGXToken } from "../types";
 import { RGXPart, RGXCapture } from "./part";
-export type RGXWalkerOptions<R> = {
+export type RGXWalkerOptions<R, S = unknown> = {
     startingSourcePosition?: number;
     reduced?: R;
+    share?: S;
     infinite?: boolean;
     looping?: boolean;
 };
-export type RGXTokenOrPart<R, T = unknown> = RGXToken | RGXPart<R, T>;
-export declare class RGXWalker<R> {
+export type RGXTokenOrPart<R, S = unknown, T = unknown> = RGXToken | RGXPart<R, S, T>;
+export declare class RGXWalker<R, S = unknown> {
     readonly source: string;
     _sourcePosition: number;
-    readonly tokens: RGXTokenOrPart<R>[];
+    readonly tokens: RGXTokenOrPart<R, S>[];
     _tokenPosition: number;
     reduced: R;
+    share: S;
     captures: RGXCapture[];
     namedCaptures: Record<string, RGXCapture[]>;
     infinite: boolean;
     looping: boolean;
     private _stopped;
-    static check: (value: unknown) => value is RGXWalker<unknown>;
-    static assert: (value: unknown) => asserts value is RGXWalker<unknown>;
+    static check: (value: unknown) => value is RGXWalker<unknown, unknown>;
+    static assert: (value: unknown) => asserts value is RGXWalker<unknown, unknown>;
     get sourcePosition(): number;
     set sourcePosition(value: number);
     get tokenPosition(): number;
     set tokenPosition(value: number);
     get stopped(): boolean;
-    constructor(source: string, tokens: RGXTokenOrPart<R>[], options?: RGXWalkerOptions<R>);
+    constructor(source: string, tokens: RGXTokenOrPart<R, S>[], options?: RGXWalkerOptions<R, S>);
     stop(): this;
     atTokenEnd(): boolean;
-    hasNextToken(predicate?: (token: RGXToken | RGXPart<R>) => boolean): boolean;
+    hasNextToken(predicate?: (token: RGXToken | RGXPart<R, S>) => boolean): boolean;
     atSourceEnd(): boolean;
     hasNextSource(predicate?: (rest: string) => boolean): boolean;
     lastCapture(): RGXCapture | null;
-    currentToken(): RGXTokenOrPart<R, unknown>;
+    currentToken(): RGXTokenOrPart<R, S, unknown>;
     remainingSource(): string | null;
-    capture(token: RGXTokenOrPart<R>, includeMatch: true): RegExpExecArray;
-    capture(token: RGXTokenOrPart<R>, includeMatch?: false): string;
+    capture(token: RGXTokenOrPart<R, S>, includeMatch: true): RegExpExecArray;
+    capture(token: RGXTokenOrPart<R, S>, includeMatch?: false): string;
     step(): RGXCapture | null;
     stepToToken(predicate: (token: RGXTokenOrPart<R>) => boolean): this;
-    stepToPart(predicate?: (part: RGXPart<R, unknown>) => boolean): this;
+    stepToPart(predicate?: (part: RGXPart<R, S, unknown>) => boolean): this;
     walk(): this;
-    clone(depth?: CloneDepth): RGXWalker<R>;
+    clone(depth?: CloneDepth): RGXWalker<R, S>;
 }
-export declare function rgxWalker<R>(...args: ConstructorParameters<typeof RGXWalker<R>>): RGXWalker<R>;
+export declare function rgxWalker<R, S = unknown>(...args: ConstructorParameters<typeof RGXWalker<R, S>>): RGXWalker<R, S>;

package/dist/walker/base.js

@@ -52,6 +52,7 @@ class RGXWalker {
         this.tokens = tokens;
         this.tokenPosition = 0;
         this.reduced = options.reduced ?? null;
+        this.share = options.share ?? null;
         this.infinite = options.infinite ?? false;
         this.looping = options.looping ?? false;
     }
@@ -107,7 +108,7 @@ class RGXWalker {
         let silent = false;
         // Ask Part what to do — control flow via return values, not flags.
         if (isPart) {
-            const control = token.beforeCapture?.(token, this);
+            const control = token.beforeCapture?.(this.share, token, this);
             if (control === "stop") {
                 this._stopped = true;
                 return null;
@@ -127,7 +128,16 @@ class RGXWalker {
             branchedToken = createBranchGroups(token.token);
         else
             branchedToken = createBranchGroups(token);
-        const capture = this.capture(branchedToken, true);
+        let capture;
+        try {
+            capture = this.capture(branchedToken, true);
+        }
+        catch (e) {
+            if (isPart && e instanceof errors_1.RGXRegexNotMatchedAtPositionError) {
+                token.afterFailure?.(e, this.share, token, this);
+            }
+            throw e;
+        }
         const raw = isPart ? token.rawTransform(capture[0]) : capture[0];
         const end = this.sourcePosition;
         const value = isPart ? token.transform(raw) : raw;
@@ -148,7 +158,15 @@ class RGXWalker {
         };
         // Validate the part. If validation fails, it will throw an error, so nothing below will run.
         if (isPart) {
-            token.validate(captureResult, this);
+            try {
+                token.validate(captureResult, this.share, this);
+            }
+            catch (e) {
+                if (e instanceof errors_1.RGXPartValidationFailedError) {
+                    token.afterValidationFailure?.(e, this.share, token, this);
+                }
+                throw e;
+            }
         }
         // Skip adding the capture if in silent mode.
         if (!silent) {
@@ -161,7 +179,7 @@ class RGXWalker {
         }
         // Notify Part after capture
         if (isPart) {
-            token.afterCapture?.(captureResult, token, this);
+            token.afterCapture?.(captureResult, this.share, token, this);
         }
         if (!this.infinite || this.tokenPosition < this.tokens.length - 1) {
             this.tokenPosition++;
@@ -204,6 +222,7 @@ class RGXWalker {
         const clone = new RGXWalker(this.source, (0, immutability_utils_1.extClone)(this.tokens, (0, immutability_utils_1.depthDecrement)(1)), {
             startingSourcePosition: this.sourcePosition,
             reduced: (0, immutability_utils_1.extClone)(this.reduced, (0, immutability_utils_1.depthDecrement)(1)),
+            share: (0, immutability_utils_1.extClone)(this.share, (0, immutability_utils_1.depthDecrement)(1)),
             infinite: this.infinite,
             looping: this.looping
         });

package/dist/walker/part.d.ts

@@ -1,6 +1,7 @@
 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;
 export type RGXCapture<T = unknown> = {
     raw: string;
@@ -11,29 +12,33 @@ export type RGXCapture<T = unknown> = {
     branch: number;
     groups: Record<string, string> | null;
 };
-export type RGXPartOptions<R, T = string> = {
+export type RGXPartOptions<R, S = unknown, T = string> = {
     id: string;
     rawTransform: (captured: string) => string;
     transform: (captured: string) => T;
-    validate: (captured: RGXCapture<T>, part: RGXPart<R, T>, walker: RGXWalker<R>) => boolean | string;
-    beforeCapture: ((part: RGXPart<R, T>, walker: RGXWalker<R>) => RGXPartControl) | null;
-    afterCapture: ((capture: RGXCapture<T>, part: RGXPart<R, T>, walker: RGXWalker<R>) => void) | null;
+    validate: (captured: RGXCapture<T>, share: S, part: RGXPart<R, S, T>, walker: RGXWalker<R, S>) => boolean | string;
+    beforeCapture: ((share: S, part: RGXPart<R, S, T>, walker: RGXWalker<R, S>) => RGXPartControl) | null;
+    afterCapture: ((capture: RGXCapture<T>, share: S, part: RGXPart<R, S, T>, walker: RGXWalker<R, S>) => void) | null;
+    afterFailure: ((e: RGXRegexNotMatchedAtPositionError, share: S, part: RGXPart<R, S, T>, walker: RGXWalker<R, S>) => void) | null;
+    afterValidationFailure: ((e: RGXPartValidationFailedError, share: S, part: RGXPart<R, S, T>, walker: RGXWalker<R, S>) => void) | null;
 };
-export declare class RGXPart<R, T = string> {
+export declare class RGXPart<R, S = unknown, T = string> {
     id: string | null;
     token: RGXToken;
-    readonly rawTransform: RGXPartOptions<R, T>["rawTransform"];
-    readonly transform: RGXPartOptions<R, T>["transform"];
+    readonly rawTransform: RGXPartOptions<R, S, T>["rawTransform"];
+    readonly transform: RGXPartOptions<R, S, T>["transform"];
     private readonly _validate;
-    readonly beforeCapture: RGXPartOptions<R, T>["beforeCapture"];
-    readonly afterCapture: RGXPartOptions<R, T>["afterCapture"];
-    static check: (value: unknown) => value is RGXPart<unknown, unknown>;
-    static assert: (value: unknown) => asserts value is RGXPart<unknown, unknown>;
-    constructor(token: RGXToken, options?: Partial<RGXPartOptions<R, T>>);
-    hasId(): this is RGXPart<R, T> & {
+    readonly beforeCapture: RGXPartOptions<R, S, T>["beforeCapture"];
+    readonly afterCapture: RGXPartOptions<R, S, T>["afterCapture"];
+    readonly afterFailure: RGXPartOptions<R, S, T>["afterFailure"];
+    readonly afterValidationFailure: RGXPartOptions<R, S, T>["afterValidationFailure"];
+    static check: (value: unknown) => value is RGXPart<unknown, unknown, unknown>;
+    static assert: (value: unknown) => asserts value is RGXPart<unknown, unknown, unknown>;
+    constructor(token: RGXToken, options?: Partial<RGXPartOptions<R, S, T>>);
+    hasId(): this is RGXPart<R, S, T> & {
         id: string;
     };
-    validate(capture: RGXCapture<T>, walker: RGXWalker<R>): void;
-    clone(depth?: CloneDepth): RGXPart<R, T>;
+    validate(capture: RGXCapture<T>, share: S, walker: RGXWalker<R, S>): void;
+    clone(depth?: CloneDepth): RGXPart<R, S, T>;
 }
-export declare function rgxPart<R, T = string>(...args: ConstructorParameters<typeof RGXPart<R, T>>): RGXPart<R, T>;
+export declare function rgxPart<R, S = unknown, T = string>(...args: ConstructorParameters<typeof RGXPart<R, S, T>>): RGXPart<R, S, T>;

package/dist/walker/part.js

@@ -15,12 +15,14 @@ class RGXPart {
         this._validate = options.validate ?? (() => true);
         this.beforeCapture = options.beforeCapture ?? null;
         this.afterCapture = options.afterCapture ?? null;
+        this.afterFailure = options.afterFailure ?? null;
+        this.afterValidationFailure = options.afterValidationFailure ?? null;
     }
     hasId() {
         return this.id !== null;
     }
-    validate(capture, walker) {
-        const result = this._validate(capture, this, walker);
+    validate(capture, share, walker) {
+        const result = this._validate(capture, share, this, walker);
         if (result === true)
             return;
         const message = typeof result === "string" ? result : "Part Validation Failed";

package/package.json

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