@ptolemy2002/rgx 10.0.0 → 11.1.0

package/README.md

@@ -17,6 +17,7 @@ Because there is so much to document, it has been broken up into multiple files.
   - [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.
   - [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.
 - `class` - A directory containing documentation for all classes in the library.
   - [collection](./docs/class/collection.md) - The `RGXTokenCollection` class, which is a collection of tokens.

package/dist/ExtRegExp.d.ts

@@ -1,5 +1,5 @@
 import { ValidRegexFlags } from "./types";
-export type RegExpFlagTransformer = (exp: RegExp) => RegExp;
+export type RegExpFlagTransformer = (exp: RegExp) => [string, string];
 export declare class ExtRegExp extends RegExp {
     private extFlags;
     constructor(pattern: string | RegExp, flags?: string);

package/dist/ExtRegExp.js

@@ -12,6 +12,7 @@ exports.assertValidRegexFlags = assertValidRegexFlags;
 const errors_1 = require("./errors");
 const internal_1 = require("./internal");
 const typeGuards_1 = require("./typeGuards");
+const utils_1 = require("./utils");
 const flagTransformers = {};
 class ExtRegExp extends RegExp {
     constructor(pattern, flags = '') {
@@ -20,7 +21,7 @@ class ExtRegExp extends RegExp {
         const customFlags = extractCustomRegexFlags(flags);
         const source = pattern instanceof RegExp ? pattern.source : pattern;
         const alreadyAppliedFlags = pattern instanceof RegExp ? pattern.flags : '';
-        const { source: transformedSource, flags: transformedFlags } = applyFlagTransformers(new RegExp(source, vanillaFlags), customFlags, alreadyAppliedFlags);
+        const { source: transformedSource, flags: transformedFlags } = applyFlagTransformers((0, utils_1.createRegex)(source, vanillaFlags), customFlags, alreadyAppliedFlags);
         super(transformedSource, transformedFlags);
         this.extFlags = customFlags;
     }
@@ -56,9 +57,29 @@ function unregisterFlagTransformer(key) {
     delete flagTransformers[key];
 }
 function applyFlagTransformers(regex, flags, alreadyAppliedFlags = '') {
+    if (Object.getPrototypeOf(regex) !== RegExp.prototype) {
+        throw new errors_1.RGXNotDirectRegExpError("Cannot apply flag transformers to non-direct RegExp instances", regex.constructor.name);
+    }
     for (const flag in flagTransformers) {
         if (flags.includes(flag) && !alreadyAppliedFlags.includes(flag)) {
-            regex = flagTransformers[flag](regex);
+            const [newSource, newFlags] = flagTransformers[flag](regex);
+            try {
+                if ((0, typeGuards_1.isValidVanillaRegexFlags)(newFlags)) {
+                    regex = new RegExp(newSource, newFlags);
+                }
+                else {
+                    throw new errors_1.RGXInvalidVanillaRegexFlagsError(`Flag transformer for flag "${flag}" produced invalid vanilla regex flags.`, newFlags);
+                }
+            }
+            catch (e) {
+                if (e instanceof SyntaxError) {
+                    throw new errors_1.RGXInvalidRegexStringError(`Flag transformer for flag "${flag}" produced an invalid regex.`, newSource, e);
+                }
+                // This is ignored because I don't know what kind of
+                // unexpected errors might happen.
+                /* istanbul ignore next */
+                throw e;
+            }
             alreadyAppliedFlags += flag;
         }
     }

package/dist/class/group.js

@@ -52,7 +52,7 @@ class RGXGroupToken extends base_1.RGXClassToken {
             result = `(?:${result})`;
         else
             result = `(${result})`;
-        return new RegExp(result);
+        return (0, utils_1.createRegex)(result);
     }
     clone(depth = "max") {
         if (depth === 0)

package/dist/class/lookahead.js

@@ -19,7 +19,7 @@ class RGXLookaheadToken extends lookaround_1.RGXLookaroundToken {
             result = `(?=${result})`;
         else
             result = `(?!${result})`;
-        return new RegExp(result);
+        return (0, utils_1.createRegex)(result);
     }
     clone(depth = "max") {
         if (depth === 0)

package/dist/class/lookbehind.js

@@ -19,7 +19,7 @@ class RGXLookbehindToken extends lookaround_1.RGXLookaroundToken {
             result = `(?<=${result})`;
         else
             result = `(?<!${result})`;
-        return new RegExp(result);
+        return (0, utils_1.createRegex)(result);
     }
     clone(depth = "max") {
         if (depth === 0)

package/dist/class/repeat.js

@@ -90,7 +90,7 @@ class RGXRepeatToken extends base_1.RGXClassToken {
         if (this.min === 0 && this.max === 0)
             return null;
         const resolvedSource = (0, resolve_1.resolveRGXToken)(this.token);
-        return new RegExp(`${resolvedSource}${this.repeaterSuffix}`);
+        return (0, utils_1.createRegex)(`${resolvedSource}${this.repeaterSuffix}`);
     }
     clone(depth = "max") {
         if (depth === 0)

package/dist/class/subpattern.js

@@ -26,10 +26,10 @@ class RGXSubpatternToken extends base_1.RGXClassToken {
     }
     toRgx() {
         if (typeof this.pattern === "string") {
-            return new RegExp(`\\k<${this.pattern}>`);
+            return (0, utils_1.createRegex)(`\\k<${this.pattern}>`);
         }
         else {
-            return new RegExp(`\\${this.pattern}`);
+            return (0, utils_1.createRegex)(`\\${this.pattern}`);
         }
     }
     clone(depth = "max") {

package/dist/collection.js

@@ -33,7 +33,7 @@ class RGXTokenCollection {
         else {
             pattern = (0, concat_1.rgxConcat)(this.tokens);
         }
-        return new RegExp(pattern);
+        return (0, utils_1.createRegex)(pattern);
     }
     getTokens() {
         return (0, immutability_utils_1.extClone)(this.tokens, "max");

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';
+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 declare class RGXError extends Error {
     _message: string;
     code: RGXErrorCode;

package/dist/errors/index.d.ts

@@ -19,3 +19,4 @@ export * from './lexemeNotMatchedAtPosition';
 export * from './invalidLexer';
 export * from './invalidWalker';
 export * from './invalidPart';
+export * from './notDirectRegexp';

package/dist/errors/index.js

@@ -35,3 +35,4 @@ __exportStar(require("./lexemeNotMatchedAtPosition"), exports);
 __exportStar(require("./invalidLexer"), exports);
 __exportStar(require("./invalidWalker"), exports);
 __exportStar(require("./invalidPart"), exports);
+__exportStar(require("./notDirectRegexp"), exports);

package/dist/errors/notDirectRegexp.d.ts

@@ -0,0 +1,6 @@
+import { RGXError } from "./base";
+export declare class RGXNotDirectRegExpError extends RGXError {
+    gotConstructorName: string;
+    constructor(message: string, gotConstructorName: string);
+    calcMessage(message: string): string;
+}

package/dist/errors/notDirectRegexp.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RGXNotDirectRegExpError = void 0;
+const base_1 = require("./base");
+class RGXNotDirectRegExpError extends base_1.RGXError {
+    constructor(message, gotConstructorName) {
+        super(message, 'NOT_DIRECT_REGEXP');
+        this.name = 'RGXNotDirectRegExpError';
+        this.gotConstructorName = gotConstructorName;
+    }
+    calcMessage(message) {
+        return `${message}; Expected direct instance of RegExp; Got instance of ${this.gotConstructorName}`;
+    }
+}
+exports.RGXNotDirectRegExpError = RGXNotDirectRegExpError;

package/dist/flag-transformer/accentInsensitive.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.accentInsensitiveFlagTransformer = void 0;
 const constants_1 = require("../constants");
 const resolve_1 = require("../resolve");
+const utils_1 = require("../utils");
 const accentPatterns = [
     "(a|á|à|ä|â|ã)", "(A|Á|À|Ä|Â|Ã)",
     "(e|é|è|ë|ê)", "(E|É|È|Ë|Ê)",
@@ -26,8 +27,8 @@ const accentInsensitiveFlagTransformer = function (exp) {
     const flags = exp.flags;
     accentPatterns.forEach((pattern) => {
         // Replace any of the characters in the pattern with the pattern itself
-        source = source.replaceAll(new RegExp(nonEscapeBound + nonLocalizedFlagBound + nonCharacterClassBound + pattern, "g"), pattern);
+        source = source.replaceAll((0, utils_1.createRegex)(nonEscapeBound + nonLocalizedFlagBound + nonCharacterClassBound + pattern, "g"), pattern);
     });
-    return new RegExp(source, flags);
+    return [source, flags];
 };
 exports.accentInsensitiveFlagTransformer = accentInsensitiveFlagTransformer;

package/dist/index.js

@@ -24,6 +24,7 @@ const concat_1 = require("./concat");
 const internal_1 = require("./internal");
 const ExtRegExp_1 = require("./ExtRegExp");
 const walker_1 = require("./walker");
+const utils_1 = require("./utils");
 __exportStar(require("./errors"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./typeGuards"), exports);
@@ -46,10 +47,9 @@ function rgxa(tokens, flags = '') {
     (0, ExtRegExp_1.assertValidRegexFlags)(flags);
     (0, internal_1.assureAcceptance)(tokens, flags);
     const pattern = (0, concat_1.rgxConcat)(tokens, true, flags);
-    return (0, ExtRegExp_1.extRegExp)(pattern, flags);
+    return (0, utils_1.createRegex)(pattern, flags, true);
 }
 function rgx(flags = '', multiline = true, verbatim = true) {
-    (0, ExtRegExp_1.assertValidRegexFlags)(flags);
     return (strings, ...tokens) => {
         // 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);

package/dist/lexer/base.js

@@ -44,7 +44,7 @@ class RGXLexer {
         let dataPart = {};
         if (lexemeDefinition.type === "resolve") {
             const { token } = lexemeDefinition;
-            const regex = new RegExp((0, resolve_1.resolveRGXToken)(token));
+            const regex = (0, utils_1.createRegex)((0, resolve_1.resolveRGXToken)(token));
             // Since the assertion will throw an error if there is no match, this is safe.
             const match = (0, utils_1.assertRegexMatchesAtPosition)(regex, this.source, startPosition, 10, true);
             raw = match[0];
@@ -159,7 +159,7 @@ class RGXLexer {
     skipWhitespace() {
         if (this.isAtEnd())
             return;
-        const regex = new RegExp((0, resolve_1.resolveRGXToken)((0, constants_1.rgxConstant)("whitespace-block")));
+        const regex = (0, utils_1.createRegex)((0, resolve_1.resolveRGXToken)((0, constants_1.rgxConstant)("whitespace-block")));
         const match = (0, utils_1.regexMatchAtPosition)(regex, this.source, this.position, true);
         if (match !== null) {
             this.position += match[0].length;

package/dist/typeGuards.js

@@ -221,6 +221,11 @@ function isRGXToken(value, type = null, matchLength = true) {
 function assertRGXToken(value, type = null, matchLength = true) {
     if (!isRGXToken(value, type, matchLength)) {
         const flatType = rgxTokenTypeGuardInputToFlat(type);
+        /*
+            ts-ignore
+            This line sometimes throws a weird error in VSCode, but it doesn't prevent a build, and I don't know how to fix it.
+            It's an excessively deep type error on the `value` variable, which is typed as `unknown`.
+        */
         throw new e.RGXInvalidTokenError("Invalid RGX token", flatType === null ? null : { type: "tokenType", values: [flatType] }, value);
     }
 }
@@ -246,7 +251,7 @@ function isValidRegexString(value) {
         if (e instanceof SyntaxError) {
             return false;
         }
-        // This is ignored because I don't know what king of
+        // This is ignored because I don't know what kind of
         // unexpected errors might happen.
         /* istanbul ignore next */
         throw e;

package/dist/utils/createRegex.d.ts

@@ -0,0 +1,4 @@
+import { ExtRegExp } from "../ExtRegExp";
+export declare function createRegex(pattern: string, flags?: string): RegExp;
+export declare function createRegex(pattern: string, flags: string, extended: false): RegExp;
+export declare function createRegex(pattern: string, flags: string, extended: true): ExtRegExp;

package/dist/utils/createRegex.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRegex = createRegex;
+const errors_1 = require("../errors");
+const ExtRegExp_1 = require("../ExtRegExp");
+const typeGuards_1 = require("../typeGuards");
+function createRegex(pattern, flags = "", extended = false) {
+    // ExtRegExp will handle validation of flags if extended is true, otherwise we validate them here
+    if (!extended)
+        (0, typeGuards_1.assertValidVanillaRegexFlags)(flags);
+    try {
+        if (extended)
+            return new ExtRegExp_1.ExtRegExp(pattern, flags);
+        else
+            return new RegExp(pattern, flags);
+    }
+    catch (e) {
+        if (e instanceof SyntaxError) {
+            throw new errors_1.RGXInvalidRegexStringError("Invalid regex string", pattern, e);
+        }
+        // The invalid flags error thrown by ExtRegExp
+        // will be rethrown here.
+        throw e;
+    }
+}

package/dist/utils/index.d.ts

@@ -2,3 +2,4 @@ export * from "./regexMatchAtPosition";
 export * from "./regexWithFlags";
 export * from "./normalizeRegexFlags";
 export * from "./createRGXClassGuardFunction";
+export * from "./createRegex";

package/dist/utils/index.js

@@ -18,3 +18,4 @@ __exportStar(require("./regexMatchAtPosition"), exports);
 __exportStar(require("./regexWithFlags"), exports);
 __exportStar(require("./normalizeRegexFlags"), exports);
 __exportStar(require("./createRGXClassGuardFunction"), exports);
+__exportStar(require("./createRegex"), exports);

package/dist/utils/regexWithFlags.js

@@ -1,14 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.regexWithFlags = regexWithFlags;
-const ExtRegExp_1 = require("../ExtRegExp");
 const normalizeRegexFlags_1 = require("./normalizeRegexFlags");
-const ExtRegExp_2 = require("../ExtRegExp");
+const createRegex_1 = require("./createRegex");
 function regexWithFlags(exp, flags, replace = false) {
-    (0, ExtRegExp_1.assertValidRegexFlags)(flags);
     if (replace)
-        return new ExtRegExp_2.ExtRegExp(exp.source, flags);
+        return (0, createRegex_1.createRegex)(exp.source, flags, true);
     const existingFlags = exp.flags;
     const newFlags = existingFlags + flags;
-    return new ExtRegExp_2.ExtRegExp(exp.source, (0, normalizeRegexFlags_1.normalizeRegexFlags)(newFlags));
+    return (0, createRegex_1.createRegex)(exp.source, (0, normalizeRegexFlags_1.normalizeRegexFlags)(newFlags), true);
 }

package/dist/walker/base.d.ts

@@ -31,7 +31,7 @@ export declare class RGXWalker<R, S = unknown> {
     constructor(source: string, tokens: RGXTokenOrPart<R, S>[], options?: RGXWalkerOptions<R, S>);
     stop(): this;
     atTokenEnd(): boolean;
-    hasNextToken(predicate?: (token: RGXToken | RGXPart<R, S>) => boolean): boolean;
+    hasNextToken(predicate?: (token: RGXToken | RGXPart<R, S, unknown>) => boolean): boolean;
     atSourceEnd(): boolean;
     hasNextSource(predicate?: (rest: string) => boolean): boolean;
     lastCapture(): RGXCapture | null;
@@ -42,7 +42,7 @@ export declare class RGXWalker<R, S = unknown> {
     step(): RGXCapture | null;
     stepToToken(predicate: (token: RGXTokenOrPart<R>) => boolean): this;
     stepToPart(predicate?: (part: RGXPart<R, S, unknown>) => boolean): this;
-    walk(): this;
+    walk(): R;
     clone(depth?: CloneDepth): RGXWalker<R, S>;
 }
 export declare function rgxWalker<R, S = unknown>(...args: ConstructorParameters<typeof RGXWalker<R, S>>): RGXWalker<R, S>;

package/dist/walker/base.js

@@ -88,7 +88,7 @@ class RGXWalker {
         return this.source.slice(this.sourcePosition);
     }
     capture(token, includeMatch = false) {
-        const regex = new RegExp((0, resolve_1.resolveRGXToken)(part_1.RGXPart.check(token) ? token.token : token));
+        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;
         return includeMatch ? match : match[0];
@@ -108,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?.(this.share, token, this);
+            const control = token.beforeCapture?.({ part: token, walker: this });
             if (control === "stop") {
                 this._stopped = true;
                 return null;
@@ -134,7 +134,16 @@ class RGXWalker {
         }
         catch (e) {
             if (isPart && e instanceof errors_1.RGXRegexNotMatchedAtPositionError) {
-                token.afterFailure?.(e, this.share, token, this);
+                const control = token.afterFailure?.(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;
         }
@@ -144,7 +153,7 @@ class RGXWalker {
         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; i++) {
+        for (let i = 0; i < capture.length - 1; i++) {
             const branchKey = `rgx_branch_${i}`;
             if (capture.groups && capture.groups[branchKey] !== undefined) {
                 branch = i;
@@ -159,11 +168,21 @@ class RGXWalker {
         // Validate the part. If validation fails, it will throw an error, so nothing below will run.
         if (isPart) {
             try {
-                token.validate(captureResult, this.share, this);
+                token.validate(captureResult, { part: token, walker: this });
             }
             catch (e) {
+                this.sourcePosition = start; // Reset source position on validation failure
                 if (e instanceof errors_1.RGXPartValidationFailedError) {
-                    token.afterValidationFailure?.(e, this.share, token, this);
+                    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;
             }
@@ -179,7 +198,7 @@ class RGXWalker {
         }
         // Notify Part after capture
         if (isPart) {
-            token.afterCapture?.(captureResult, this.share, token, this);
+            token.afterCapture?.(captureResult, { part: token, walker: this });
         }
         if (!this.infinite || this.tokenPosition < this.tokens.length - 1) {
             this.tokenPosition++;
@@ -213,7 +232,8 @@ class RGXWalker {
         return this;
     }
     walk() {
-        return this.stepToToken(() => false);
+        this.stepToToken(() => false);
+        return this.reduced;
     }
     // Clone method
     clone(depth = "max") {

package/dist/walker/part.d.ts

@@ -12,15 +12,19 @@ export type RGXCapture<T = unknown> = {
     branch: number;
     groups: Record<string, string> | null;
 };
+export type RGXPartContext<R, S = unknown, T = string> = {
+    part: RGXPart<R, S, T>;
+    walker: RGXWalker<R, S>;
+};
 export type RGXPartOptions<R, S = unknown, T = string> = {
     id: string;
     rawTransform: (captured: string) => string;
     transform: (captured: string) => T;
-    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;
+    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;
+    afterValidationFailure: ((e: RGXPartValidationFailedError, context: RGXPartContext<R, S, T>) => RGXPartControl) | null;
 };
 export declare class RGXPart<R, S = unknown, T = string> {
     id: string | null;
@@ -38,7 +42,7 @@ export declare class RGXPart<R, S = unknown, T = string> {
     hasId(): this is RGXPart<R, S, T> & {
         id: string;
     };
-    validate(capture: RGXCapture<T>, share: S, walker: RGXWalker<R, S>): void;
+    validate(capture: RGXCapture<T>, context: RGXPartContext<R, S, T>): void;
     clone(depth?: CloneDepth): RGXPart<R, S, 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

@@ -21,8 +21,8 @@ class RGXPart {
     hasId() {
         return this.id !== null;
     }
-    validate(capture, share, walker) {
-        const result = this._validate(capture, share, this, walker);
+    validate(capture, context) {
+        const result = this._validate(capture, context);
         if (result === true)
             return;
         const message = typeof result === "string" ? result : "Part Validation Failed";

package/package.json

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