@ptolemy2002/rgx 8.1.0 → 9.0.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.
+  - [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.
   - [RGXError](./docs/class/RGXError.md) - Details on all custom error classes and the base `RGXError` class.

package/dist/class/group.js

@@ -4,6 +4,7 @@ exports.rgxGroup = exports.RGXGroupToken = void 0;
 const collection_1 = require("../collection");
 const base_1 = require("./base");
 const internal_1 = require("../internal");
+const utils_1 = require("../utils");
 const typeGuards_1 = require("../typeGuards");
 const immutability_utils_1 = require("@ptolemy2002/immutability-utils");
 class RGXGroupToken extends base_1.RGXClassToken {
@@ -60,6 +61,6 @@ class RGXGroupToken extends base_1.RGXClassToken {
     }
 }
 exports.RGXGroupToken = RGXGroupToken;
-RGXGroupToken.check = (0, internal_1.createClassGuardFunction)(RGXGroupToken);
-RGXGroupToken.assert = (0, internal_1.createAssertClassGuardFunction)(RGXGroupToken);
+RGXGroupToken.check = (0, utils_1.createRGXClassGuardFunction)(RGXGroupToken);
+RGXGroupToken.assert = (0, utils_1.createAssertRGXClassGuardFunction)(RGXGroupToken);
 exports.rgxGroup = (0, internal_1.createConstructFunction)(RGXGroupToken);

package/dist/class/lookahead.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rgxLookahead = exports.RGXLookaheadToken = void 0;
 const internal_1 = require("../internal");
+const utils_1 = require("../utils");
 const lookaround_1 = require("./lookaround");
 const lookbehind_1 = require("./lookbehind");
 const immutability_utils_1 = require("@ptolemy2002/immutability-utils");
@@ -27,6 +28,6 @@ class RGXLookaheadToken extends lookaround_1.RGXLookaroundToken {
     }
 }
 exports.RGXLookaheadToken = RGXLookaheadToken;
-RGXLookaheadToken.check = (0, internal_1.createClassGuardFunction)(RGXLookaheadToken);
-RGXLookaheadToken.assert = (0, internal_1.createAssertClassGuardFunction)(RGXLookaheadToken);
+RGXLookaheadToken.check = (0, utils_1.createRGXClassGuardFunction)(RGXLookaheadToken);
+RGXLookaheadToken.assert = (0, utils_1.createAssertRGXClassGuardFunction)(RGXLookaheadToken);
 exports.rgxLookahead = (0, internal_1.createConstructFunction)(RGXLookaheadToken);

package/dist/class/lookbehind.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rgxLookbehind = exports.RGXLookbehindToken = void 0;
 const internal_1 = require("../internal");
+const utils_1 = require("../utils");
 const lookahead_1 = require("./lookahead");
 const lookaround_1 = require("./lookaround");
 const immutability_utils_1 = require("@ptolemy2002/immutability-utils");
@@ -27,6 +28,6 @@ class RGXLookbehindToken extends lookaround_1.RGXLookaroundToken {
     }
 }
 exports.RGXLookbehindToken = RGXLookbehindToken;
-RGXLookbehindToken.check = (0, internal_1.createClassGuardFunction)(RGXLookbehindToken);
-RGXLookbehindToken.assert = (0, internal_1.createAssertClassGuardFunction)(RGXLookbehindToken);
+RGXLookbehindToken.check = (0, utils_1.createRGXClassGuardFunction)(RGXLookbehindToken);
+RGXLookbehindToken.assert = (0, utils_1.createAssertRGXClassGuardFunction)(RGXLookbehindToken);
 exports.rgxLookbehind = (0, internal_1.createConstructFunction)(RGXLookbehindToken);

package/dist/class/repeat.js

@@ -7,6 +7,7 @@ const typeGuards_1 = require("../typeGuards");
 const errors_1 = require("../errors");
 const resolve_1 = require("../resolve");
 const internal_1 = require("../internal");
+const utils_1 = require("../utils");
 const immutability_utils_1 = require("@ptolemy2002/immutability-utils");
 const clone_1 = require("../clone");
 class RGXRepeatToken extends base_1.RGXClassToken {
@@ -98,6 +99,6 @@ class RGXRepeatToken extends base_1.RGXClassToken {
     }
 }
 exports.RGXRepeatToken = RGXRepeatToken;
-RGXRepeatToken.check = (0, internal_1.createClassGuardFunction)(RGXRepeatToken);
-RGXRepeatToken.assert = (0, internal_1.createAssertClassGuardFunction)(RGXRepeatToken);
+RGXRepeatToken.check = (0, utils_1.createRGXClassGuardFunction)(RGXRepeatToken);
+RGXRepeatToken.assert = (0, utils_1.createAssertRGXClassGuardFunction)(RGXRepeatToken);
 exports.rgxRepeat = (0, internal_1.createConstructFunction)(RGXRepeatToken);

package/dist/class/subpattern.js

@@ -5,6 +5,7 @@ const base_1 = require("./base");
 const typeGuards_1 = require("../typeGuards");
 const errors_1 = require("../errors");
 const internal_1 = require("../internal");
+const utils_1 = require("../utils");
 class RGXSubpatternToken extends base_1.RGXClassToken {
     get pattern() {
         return this._pattern;
@@ -38,6 +39,6 @@ class RGXSubpatternToken extends base_1.RGXClassToken {
     }
 }
 exports.RGXSubpatternToken = RGXSubpatternToken;
-RGXSubpatternToken.check = (0, internal_1.createClassGuardFunction)(RGXSubpatternToken);
-RGXSubpatternToken.assert = (0, internal_1.createAssertClassGuardFunction)(RGXSubpatternToken);
+RGXSubpatternToken.check = (0, utils_1.createRGXClassGuardFunction)(RGXSubpatternToken);
+RGXSubpatternToken.assert = (0, utils_1.createAssertRGXClassGuardFunction)(RGXSubpatternToken);
 exports.rgxSubpattern = (0, internal_1.createConstructFunction)(RGXSubpatternToken);

package/dist/class/union.js

@@ -7,6 +7,7 @@ const internal_1 = require("../internal");
 const collection_1 = require("../collection");
 const base_1 = require("./base");
 const immutability_utils_1 = require("@ptolemy2002/immutability-utils");
+const utils_1 = require("../utils");
 class RGXClassUnionToken extends base_1.RGXClassToken {
     constructor(tokens = []) {
         super();
@@ -52,8 +53,8 @@ class RGXClassUnionToken extends base_1.RGXClassToken {
     }
 }
 exports.RGXClassUnionToken = RGXClassUnionToken;
-RGXClassUnionToken.check = (0, internal_1.createClassGuardFunction)(RGXClassUnionToken);
-RGXClassUnionToken.assert = (0, internal_1.createAssertClassGuardFunction)(RGXClassUnionToken);
+RGXClassUnionToken.check = (0, utils_1.createRGXClassGuardFunction)(RGXClassUnionToken);
+RGXClassUnionToken.assert = (0, utils_1.createAssertRGXClassGuardFunction)(RGXClassUnionToken);
 function expandRgxUnionTokens(...tokens) {
     const result = new collection_1.RGXTokenCollection();
     for (const token of tokens) {

package/dist/class/wrapper.js

@@ -6,6 +6,7 @@ const typeGuards_1 = require("../typeGuards");
 const internal_1 = require("../internal");
 const immutability_utils_1 = require("@ptolemy2002/immutability-utils");
 const clone_1 = require("../clone");
+const utils_1 = require("../utils");
 class RGXClassWrapperToken extends base_1.RGXClassToken {
     constructor(token) {
         super();
@@ -33,6 +34,6 @@ class RGXClassWrapperToken extends base_1.RGXClassToken {
     }
 }
 exports.RGXClassWrapperToken = RGXClassWrapperToken;
-RGXClassWrapperToken.check = (0, internal_1.createClassGuardFunction)(RGXClassWrapperToken);
-RGXClassWrapperToken.assert = (0, internal_1.createAssertClassGuardFunction)(RGXClassWrapperToken);
+RGXClassWrapperToken.check = (0, utils_1.createRGXClassGuardFunction)(RGXClassWrapperToken);
+RGXClassWrapperToken.assert = (0, utils_1.createAssertRGXClassGuardFunction)(RGXClassWrapperToken);
 exports.rgxClassWrapper = (0, internal_1.createConstructFunction)(RGXClassWrapperToken);

package/dist/collection.js

@@ -5,6 +5,7 @@ const resolve_1 = require("./resolve");
 const concat_1 = require("./concat");
 const immutability_utils_1 = require("@ptolemy2002/immutability-utils");
 const internal_1 = require("./internal");
+const utils_1 = require("./utils");
 class RGXTokenCollection {
     constructor(tokens = [], mode = 'concat') {
         this.tokens = [];
@@ -167,6 +168,6 @@ class RGXTokenCollection {
     }
 }
 exports.RGXTokenCollection = RGXTokenCollection;
-RGXTokenCollection.check = (0, internal_1.createClassGuardFunction)(RGXTokenCollection);
-RGXTokenCollection.assert = (0, internal_1.createAssertClassGuardFunction)(RGXTokenCollection);
+RGXTokenCollection.check = (0, utils_1.createRGXClassGuardFunction)(RGXTokenCollection);
+RGXTokenCollection.assert = (0, utils_1.createAssertRGXClassGuardFunction)(RGXTokenCollection);
 exports.rgxTokenCollection = (0, internal_1.createConstructFunction)(RGXTokenCollection);

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

package/dist/errors/index.d.ts

@@ -17,3 +17,5 @@ export * from './partValidationFailed';
 export * from './invalidLexerMode';
 export * from './lexemeNotMatchedAtPosition';
 export * from './invalidLexer';
+export * from './invalidWalker';
+export * from './invalidPart';

package/dist/errors/index.js

@@ -33,3 +33,5 @@ __exportStar(require("./partValidationFailed"), exports);
 __exportStar(require("./invalidLexerMode"), exports);
 __exportStar(require("./lexemeNotMatchedAtPosition"), exports);
 __exportStar(require("./invalidLexer"), exports);
+__exportStar(require("./invalidWalker"), exports);
+__exportStar(require("./invalidPart"), exports);

package/dist/errors/invalidPart.d.ts

@@ -0,0 +1,7 @@
+import { RGXError } from "./";
+export declare class RGXInvalidPartError extends RGXError {
+    constructorName: string;
+    got: unknown;
+    constructor(message: string, got: unknown, constructorName?: string);
+    calcMessage(message: string): string;
+}

package/dist/errors/invalidPart.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RGXInvalidPartError = void 0;
+const errors_1 = require("./");
+const class_1 = require("../class");
+class RGXInvalidPartError extends errors_1.RGXError {
+    constructor(message, got, constructorName = "RGXPart") {
+        super(message, 'INVALID_RGX_PART');
+        this.name = 'RGXInvalidPartError';
+        this.got = got;
+        this.constructorName = constructorName;
+    }
+    calcMessage(message) {
+        const gotString = class_1.RGXClassToken.check(this.got) ? `instance of ${this.got.constructor.name}` : JSON.stringify(this.got);
+        return `${message}; Expected: [instance of ${this.constructorName}]; Got: [${gotString}]`;
+    }
+}
+exports.RGXInvalidPartError = RGXInvalidPartError;

package/dist/errors/invalidWalker.d.ts

@@ -0,0 +1,7 @@
+import { RGXError } from "./";
+export declare class RGXInvalidWalkerError extends RGXError {
+    constructorName: string;
+    got: unknown;
+    constructor(message: string, got: unknown, constructorName?: string);
+    calcMessage(message: string): string;
+}

package/dist/errors/invalidWalker.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RGXInvalidWalkerError = void 0;
+const errors_1 = require("./");
+const class_1 = require("../class");
+class RGXInvalidWalkerError extends errors_1.RGXError {
+    constructor(message, got, constructorName = "RGXWalker") {
+        super(message, 'INVALID_RGX_WALKER');
+        this.name = 'RGXInvalidWalkerError';
+        this.got = got;
+        this.constructorName = constructorName;
+    }
+    calcMessage(message) {
+        const gotString = class_1.RGXClassToken.check(this.got) ? `instance of ${this.got.constructor.name}` : JSON.stringify(this.got);
+        return `${message}; Expected: [instance of ${this.constructorName}]; Got: [${gotString}]`;
+    }
+}
+exports.RGXInvalidWalkerError = RGXInvalidWalkerError;

package/dist/index.d.ts

@@ -17,5 +17,5 @@ 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 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, ...options }?: t.RGXWOptions<R, S>): (strings: TemplateStringsArray, ...tokens: RGXTokenOrPart<R, S, T>[]) => RGXWalker<R, S>;

package/dist/internal/index.d.ts

@@ -1,5 +1,4 @@
 export * from "./createConstructFunction";
-export * from "./createClassGuardFunction";
 export * from "./taggedTemplateToArray";
 export * from "./isConstructor";
 export * from "./getProxy";

package/dist/internal/index.js

@@ -15,7 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./createConstructFunction"), exports);
-__exportStar(require("./createClassGuardFunction"), exports);
 __exportStar(require("./taggedTemplateToArray"), exports);
 __exportStar(require("./isConstructor"), exports);
 __exportStar(require("./getProxy"), exports);

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

@@ -6,7 +6,7 @@ const resolve_1 = require("../resolve");
 const errors_1 = require("../errors");
 const walker_1 = require("../walker");
 const utils_1 = require("../utils");
-const internal_1 = require("../internal");
+const utils_2 = require("../utils");
 const constants_1 = require("../constants");
 function rgxLexemeLocationFromIndex(source, index) {
     (0, errors_1.assertInRange)(index, { min: 0, max: source.length }, "index is outside the bounds of the source string");
@@ -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.
@@ -192,7 +193,7 @@ class RGXLexer {
     }
 }
 exports.RGXLexer = RGXLexer;
-RGXLexer.check = (0, internal_1.createClassGuardFunction)(RGXLexer);
-RGXLexer.assert = (0, internal_1.createAssertClassGuardFunction)(RGXLexer, (value, c) => new errors_1.RGXInvalidLexerError("Invalid Lexer", value, c.name));
+RGXLexer.check = (0, utils_2.createRGXClassGuardFunction)(RGXLexer);
+RGXLexer.assert = (0, utils_2.createAssertRGXClassGuardFunction)(RGXLexer, (value, c) => new errors_1.RGXInvalidLexerError("Invalid Lexer", value, c.name));
 const rgxLexer = (...args) => new RGXLexer(...args);
 exports.rgxLexer = rgxLexer;

package/dist/types.d.ts

@@ -49,6 +49,6 @@ 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 RGXWOptions<R = unknown, S = unknown> = RGXWalkerOptions<R, S> & {
     multiline?: boolean;
 };

package/dist/utils/createRGXClassGuardFunction.d.ts

@@ -0,0 +1,3 @@
+import { RGXError } from "../errors";
+export declare function createRGXClassGuardFunction<T extends new (...args: unknown[]) => unknown>(constructor: T): (value: unknown) => value is InstanceType<T>;
+export declare function createAssertRGXClassGuardFunction<T extends new (...args: unknown[]) => unknown>(constructor: T, constructError?: (value: unknown, constructor: T) => RGXError): (value: unknown) => asserts value is InstanceType<T>;

package/dist/utils/createRGXClassGuardFunction.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRGXClassGuardFunction = createRGXClassGuardFunction;
+exports.createAssertRGXClassGuardFunction = createAssertRGXClassGuardFunction;
+const errors_1 = require("../errors");
+function createRGXClassGuardFunction(constructor) {
+    return (value) => value instanceof constructor;
+}
+function createAssertRGXClassGuardFunction(constructor, constructError = (value, constructor) => new errors_1.RGXInvalidTokenError("Invalid token type", { type: "custom", values: [`instance of ${constructor.name}`] }, value)) {
+    return (value) => {
+        if (!(value instanceof constructor)) {
+            throw constructError(value, constructor);
+        }
+    };
+}

package/dist/utils/index.d.ts

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

package/dist/utils/index.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./regexMatchAtPosition"), exports);
 __exportStar(require("./regexWithFlags"), exports);
 __exportStar(require("./normalizeRegexFlags"), exports);
+__exportStar(require("./createRGXClassGuardFunction"), exports);

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

@@ -10,7 +10,7 @@ const resolve_1 = require("../resolve");
 const utils_1 = require("../utils");
 const typeGuards_1 = require("../typeGuards");
 const class_1 = require("../class");
-const internal_1 = require("../internal");
+const utils_2 = require("../utils");
 function createBranchGroups(tokens) {
     if ((tokens instanceof collection_1.RGXTokenCollection && tokens.mode === "union") ||
         class_1.RGXClassUnionToken.check(tokens))
@@ -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
         });
@@ -214,8 +233,8 @@ class RGXWalker {
     }
 }
 exports.RGXWalker = RGXWalker;
-RGXWalker.check = (0, internal_1.createClassGuardFunction)(RGXWalker);
-RGXWalker.assert = (0, internal_1.createAssertClassGuardFunction)(RGXWalker);
+RGXWalker.check = (0, utils_2.createRGXClassGuardFunction)(RGXWalker);
+RGXWalker.assert = (0, utils_2.createAssertRGXClassGuardFunction)(RGXWalker, (value, constructor) => new errors_1.RGXInvalidWalkerError("Invalid Walker", value, constructor.name));
 function rgxWalker(...args) {
     return new RGXWalker(...args);
 }

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RGXPart = void 0;
 exports.rgxPart = rgxPart;
-const internal_1 = require("../internal");
+const utils_1 = require("../utils");
 const clone_1 = require("../clone");
 const immutability_utils_1 = require("@ptolemy2002/immutability-utils");
 const errors_1 = require("../errors");
@@ -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";
@@ -40,8 +42,8 @@ class RGXPart {
     }
 }
 exports.RGXPart = RGXPart;
-RGXPart.check = (0, internal_1.createClassGuardFunction)(RGXPart);
-RGXPart.assert = (0, internal_1.createAssertClassGuardFunction)(RGXPart);
+RGXPart.check = (0, utils_1.createRGXClassGuardFunction)(RGXPart);
+RGXPart.assert = (0, utils_1.createAssertRGXClassGuardFunction)(RGXPart, (value, constructor) => new errors_1.RGXInvalidPartError("Invalid Part", value, constructor.name));
 function rgxPart(...args) {
     return new RGXPart(...args);
 }

package/package.json

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

package/dist/internal/createClassGuardFunction.d.ts

@@ -1,3 +0,0 @@
-import { RGXError } from "../errors";
-export declare function createClassGuardFunction<T extends new (...args: unknown[]) => unknown>(constructor: T): (value: unknown) => value is InstanceType<T>;
-export declare function createAssertClassGuardFunction<T extends new (...args: unknown[]) => unknown>(constructor: T, constructError?: (value: unknown, constructor: T) => RGXError): (value: unknown) => asserts value is InstanceType<T>;

package/dist/internal/createClassGuardFunction.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createClassGuardFunction = createClassGuardFunction;
-exports.createAssertClassGuardFunction = createAssertClassGuardFunction;
-const errors_1 = require("../errors");
-function createClassGuardFunction(constructor) {
-    return (value) => value instanceof constructor;
-}
-function createAssertClassGuardFunction(constructor, constructError = (value, constructor) => new errors_1.RGXInvalidTokenError("Invalid token type", { type: "custom", values: [`instance of ${constructor.name}`] }, value)) {
-    return (value) => {
-        if (!(value instanceof constructor)) {
-            throw constructError(value, constructor);
-        }
-    };
-}