@ptolemy2002/rgx 13.3.4 → 13.5.0

package/dist/class/group.d.ts

@@ -4,10 +4,12 @@ import { CloneDepth } from "@ptolemy2002/immutability-utils";
 export type RGXGroupTokenArgs = {
     name?: string | null;
     capturing?: boolean;
+    flags?: string;
 };
 export declare class RGXGroupToken extends RGXClassToken {
     tokens: RGXTokenCollection;
     _name: string | null;
+    _flags: string;
     _capturing: boolean;
     static check: (value: unknown) => value is RGXGroupToken;
     static assert: (value: unknown) => asserts value is RGXGroupToken;
@@ -15,9 +17,11 @@ export declare class RGXGroupToken extends RGXClassToken {
     set name(value: string | null);
     get capturing(): boolean;
     set capturing(value: boolean);
+    get flags(): string;
+    set flags(value: string);
     get rgxIsGroup(): true;
     get rgxGroupWrap(): false;
-    constructor({ name, capturing }?: RGXGroupTokenArgs, tokens?: RGXTokenCollectionInput);
+    constructor({ name, capturing, flags }?: RGXGroupTokenArgs, tokens?: RGXTokenCollectionInput);
     toRgx(): RegExp;
     clone(depth?: CloneDepth): RGXGroupToken;
 }

package/dist/class/group.js

@@ -25,6 +25,13 @@ class RGXGroupToken extends base_1.RGXClassToken {
             this.name = null; // Non-capturing groups cannot have names
         this._capturing = value;
     }
+    get flags() {
+        return this._flags;
+    }
+    set flags(value) {
+        (0, typeGuards_1.assertValidRegexLocalizableFlags)(value);
+        this._flags = value;
+    }
     get rgxIsGroup() {
         return true;
     }
@@ -32,12 +39,14 @@ class RGXGroupToken extends base_1.RGXClassToken {
         // When this token is resolved, it will wrap itself in a group, so we don't want the resolver to group wrap it again.
         return false;
     }
-    constructor({ name = null, capturing = true } = {}, tokens = []) {
+    constructor({ name = null, capturing = true, flags = '' } = {}, tokens = []) {
         super();
         this._name = null;
+        this._flags = '';
         this._capturing = true;
         this.name = name;
         this.capturing = capturing;
+        this.flags = flags;
         if (tokens instanceof collection_1.RGXTokenCollection && tokens.mode === 'union')
             this.tokens = new collection_1.RGXTokenCollection(tokens, 'concat');
         else
@@ -46,18 +55,29 @@ class RGXGroupToken extends base_1.RGXClassToken {
     toRgx() {
         // The collection token doesn't group itself, so this is safe.
         let result = this.tokens.toRgx().source;
-        if (this.name !== null)
+        const hasFlags = this.flags.length > 0;
+        // This will return the flags that are not present in the flags variable, preceded by a "-" if there are any.
+        const flagsNotPresent = (0, internal_1.localizableVanillaRegexFlagDiff)("ims", this.flags);
+        if (this.name !== null) {
             result = `(?<${this.name}>${result})`;
-        else if (!this.capturing)
-            result = `(?:${result})`;
-        else
+        }
+        else if (!this.capturing) {
+            if (!hasFlags)
+                result = `(?:${result})`;
+            else
+                result = `(?${this.flags}${flagsNotPresent}:${result})`;
+        }
+        else {
             result = `(${result})`;
+        }
+        if ((this.name !== null || this.capturing) && hasFlags)
+            result = `(?${this.flags}${flagsNotPresent}:${result})`;
         return (0, utils_1.createRegex)(result);
     }
     clone(depth = "max") {
         if (depth === 0)
             return this;
-        return new RGXGroupToken({ name: this.name, capturing: this._capturing }, this.tokens.clone((0, immutability_utils_1.depthDecrement)(depth, 1)));
+        return new RGXGroupToken({ name: this.name, capturing: this._capturing, flags: this.flags }, this.tokens.clone((0, immutability_utils_1.depthDecrement)(depth, 1)));
     }
 }
 exports.RGXGroupToken = RGXGroupToken;

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

package/dist/errors/index.d.ts

@@ -22,3 +22,5 @@ export * from './invalidWalker';
 export * from './invalidPart';
 export * from './notDirectRegexp';
 export * from './currentTokenNotFound';
+export * from './invalidRegexLocalizableFlagDiff';
+export * from './invalidRegexLocalizableFlags';

package/dist/errors/index.js

@@ -38,3 +38,5 @@ __exportStar(require("./invalidWalker"), exports);
 __exportStar(require("./invalidPart"), exports);
 __exportStar(require("./notDirectRegexp"), exports);
 __exportStar(require("./currentTokenNotFound"), exports);
+__exportStar(require("./invalidRegexLocalizableFlagDiff"), exports);
+__exportStar(require("./invalidRegexLocalizableFlags"), exports);

package/dist/errors/invalidRegexLocalizableFlagDiff.d.ts

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

package/dist/errors/invalidRegexLocalizableFlagDiff.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RGXInvalidRegexLocalizableFlagDiffError = void 0;
+const errors_1 = require("./");
+class RGXInvalidRegexLocalizableFlagDiffError extends errors_1.RGXError {
+    constructor(message, got) {
+        super(message, 'INVALID_REGEX_LOCALIZABLE_FLAG_DIFF');
+        this.name = 'RGXInvalidRegexLocalizableFlagDiffError';
+        this.got = got;
+    }
+    calcMessage(message) {
+        return `${message}; Got: ${JSON.stringify(this.got)}`;
+    }
+}
+exports.RGXInvalidRegexLocalizableFlagDiffError = RGXInvalidRegexLocalizableFlagDiffError;

package/dist/errors/invalidRegexLocalizableFlags.d.ts

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

package/dist/errors/invalidRegexLocalizableFlags.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RGXInvalidRegexLocalizableFlagsError = void 0;
+const errors_1 = require("./");
+class RGXInvalidRegexLocalizableFlagsError extends errors_1.RGXError {
+    constructor(message, got) {
+        super(message, 'INVALID_REGEX_LOCALIZABLE_FLAGS');
+        this.name = 'RGXInvalidRegexLocalizableFlagsError';
+        this.got = got;
+    }
+    calcMessage(message) {
+        return `${message}; Got: ${JSON.stringify(this.got)}`;
+    }
+}
+exports.RGXInvalidRegexLocalizableFlagsError = RGXInvalidRegexLocalizableFlagsError;

package/dist/internal/index.d.ts

@@ -3,3 +3,4 @@ export * from "./taggedTemplateToArray";
 export * from "./isConstructor";
 export * from "./getProxy";
 export * from "./assureAcceptance";
+export * from "./localizableVanillaRegexFlagDiff";

package/dist/internal/index.js

@@ -19,3 +19,4 @@ __exportStar(require("./taggedTemplateToArray"), exports);
 __exportStar(require("./isConstructor"), exports);
 __exportStar(require("./getProxy"), exports);
 __exportStar(require("./assureAcceptance"), exports);
+__exportStar(require("./localizableVanillaRegexFlagDiff"), exports);

package/dist/internal/localizableVanillaRegexFlagDiff.d.ts

@@ -0,0 +1,2 @@
+import * as t from "../types";
+export declare function localizableVanillaRegexFlagDiff(prev: string, next: string): t.ValidRegexLocalizableFlagDiff;

package/dist/internal/localizableVanillaRegexFlagDiff.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.localizableVanillaRegexFlagDiff = localizableVanillaRegexFlagDiff;
+function localizableVanillaRegexFlagDiff(prev, next) {
+    // Remove anything other than the "ims" flags from both strings, as
+    // other flags are not localizable (including our custom flags).
+    prev = prev.replaceAll(/[^ims]/g, '');
+    next = next.replaceAll(/[^ims]/g, '');
+    // Format <added flags>-<removed flags>
+    const added = [...new Set(next.split(''))].filter(flag => !prev.includes(flag)).join('');
+    const removed = [...new Set(prev.split(''))].filter(flag => !next.includes(flag)).join('');
+    if (added === '' && removed === '')
+        return '';
+    if (removed === '')
+        return `${added}`;
+    return `${added}-${removed}`;
+}

package/dist/resolve.js

@@ -39,25 +39,12 @@ const class_1 = require("./class");
 const e = __importStar(require("./errors"));
 const ExtRegExp_1 = require("./ExtRegExp");
 const tg = __importStar(require("./typeGuards"));
+const internal_1 = require("./internal");
 function escapeRegex(value) {
     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
-    // other flags are not localizable (including our custom flags).
-    prev = prev.replaceAll(/[^ims]/g, '');
-    next = next.replaceAll(/[^ims]/g, '');
-    // Format <added flags>-<removed flags>
-    const added = [...new Set(next.split(''))].filter(flag => !prev.includes(flag)).join('');
-    const removed = [...new Set(prev.split(''))].filter(flag => !next.includes(flag)).join('');
-    if (added === '' && removed === '')
-        return '';
-    if (removed === '')
-        return `${added}`;
-    return `${added}-${removed}`;
-}
 function hasParenErrors(pattern) {
     let depth = 0;
     let charClassDepth = 0;
@@ -95,7 +82,7 @@ function resolveRGXToken(token, { groupWrap = true, topLevel = true, currentFlag
         if (tg.isRGXNoOpToken(token))
             return '';
         if (tg.isRGXLiteralToken(token)) {
-            const localizableFlagDiff = localizableVanillaRegexFlagDiff(currentFlags, token.flags);
+            const localizableFlagDiff = (0, internal_1.localizableVanillaRegexFlagDiff)(currentFlags, token.flags);
             currentFlags = token.flags;
             if (!localizableFlagDiff) {
                 if (groupWrap)

package/dist/typeGuards.d.ts

@@ -24,3 +24,7 @@ export declare function isValidVanillaRegexFlags(value: string): value is t.Vali
 export declare function assertValidVanillaRegexFlags(value: string): asserts value is t.ValidVanillaRegexFlags;
 export declare function isValidIdentifier(value: string): value is t.ValidIdentifier;
 export declare function assertValidIdentifier(value: string): asserts value is t.ValidIdentifier;
+export declare function isValidRegexLocalizableFlagDiff(value: string): value is t.ValidRegexLocalizableFlagDiff;
+export declare function assertValidRegexLocalizableFlagDiff(value: string): asserts value is t.ValidRegexLocalizableFlagDiff;
+export declare function isValidRegexLocalizableFlags(value: string): value is t.ValidRegexLocalizableFlags;
+export declare function assertValidRegexLocalizableFlags(value: string): asserts value is t.ValidRegexLocalizableFlags;

package/dist/typeGuards.js

@@ -61,6 +61,10 @@ exports.isValidVanillaRegexFlags = isValidVanillaRegexFlags;
 exports.assertValidVanillaRegexFlags = assertValidVanillaRegexFlags;
 exports.isValidIdentifier = isValidIdentifier;
 exports.assertValidIdentifier = assertValidIdentifier;
+exports.isValidRegexLocalizableFlagDiff = isValidRegexLocalizableFlagDiff;
+exports.assertValidRegexLocalizableFlagDiff = assertValidRegexLocalizableFlagDiff;
+exports.isValidRegexLocalizableFlags = isValidRegexLocalizableFlags;
+exports.assertValidRegexLocalizableFlags = assertValidRegexLocalizableFlags;
 const e = __importStar(require("./errors"));
 const is_callable_1 = __importDefault(require("is-callable"));
 const internal_1 = require("./internal");
@@ -295,3 +299,21 @@ function assertValidIdentifier(value) {
         throw new e.RGXInvalidIdentifierError("Invalid identifier", value);
     }
 }
+function isValidRegexLocalizableFlagDiff(value) {
+    if (value === '')
+        return true;
+    return /^[ims]+(-[ims]+)?$/.test(value);
+}
+function assertValidRegexLocalizableFlagDiff(value) {
+    if (!isValidRegexLocalizableFlagDiff(value)) {
+        throw new e.RGXInvalidRegexLocalizableFlagDiffError("Invalid localizable flag diff", value);
+    }
+}
+function isValidRegexLocalizableFlags(value) {
+    return /^[ims]*$/.test(value);
+}
+function assertValidRegexLocalizableFlags(value) {
+    if (!isValidRegexLocalizableFlags(value)) {
+        throw new e.RGXInvalidRegexLocalizableFlagsError("Invalid localizable flags", value);
+    }
+}

package/dist/types.d.ts

@@ -50,6 +50,12 @@ 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 declare const validRegexLocalizableFlagsSymbol: unique symbol;
+export type ValidRegexLocalizableFlagsBrandSymbol = typeof validRegexLocalizableFlagsSymbol;
+export type ValidRegexLocalizableFlags = Branded<string, [ValidRegexLocalizableFlagsBrandSymbol]>;
+export declare const validRegexLocalizableFlagDiffSymbol: unique symbol;
+export type ValidRegexLocalizableFlagDiffBrandSymbol = typeof validRegexLocalizableFlagDiffSymbol;
+export type ValidRegexLocalizableFlagDiff = Branded<string, [ValidRegexLocalizableFlagDiffBrandSymbol]>;
 export type RGXOptions = {
     multiline?: boolean;
     verbatim?: boolean;

package/dist/types.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validIdentifierSymbol = exports.validRegexFlagsSymbol = exports.validVanillaRegexFlagsSymbol = exports.validRegexSymbol = void 0;
+exports.validRegexLocalizableFlagDiffSymbol = exports.validRegexLocalizableFlagsSymbol = exports.validIdentifierSymbol = exports.validRegexFlagsSymbol = exports.validVanillaRegexFlagsSymbol = exports.validRegexSymbol = void 0;
 exports.validRegexSymbol = Symbol('rgx.ValidRegex');
 exports.validVanillaRegexFlagsSymbol = Symbol('rgx.ValidVanillaRegexFlags');
 exports.validRegexFlagsSymbol = Symbol('rgx.ValidRegexFlags');
 exports.validIdentifierSymbol = Symbol('rgx.ValidIdentifier');
+exports.validRegexLocalizableFlagsSymbol = Symbol('rgx.ValidRegexLocalizableFlags');
+exports.validRegexLocalizableFlagDiffSymbol = Symbol('rgx.ValidRegexLocalizableFlagDiff');

package/dist/walker/base.d.ts

@@ -14,6 +14,7 @@ export type RGXTryWalkOptions = {
     revertShare?: boolean;
     revertCaptures?: boolean;
 };
+export type RGXWalkerSnapshotKey = "sourcePosition" | "tokenPosition" | "reduced" | "share" | "captures" | "namedCaptures";
 export type RGXTokenOrPart<R, S = unknown, T = any> = RGXToken | RGXPart<R, S, T>;
 export type RGXWalkerStepDirective = "stop" | "skip" | "silent";
 export declare class RGXWalker<R, S = unknown> {
@@ -30,6 +31,7 @@ export declare class RGXWalker<R, S = unknown> {
     contiguous: boolean;
     private _stopped;
     private _didReachEnd;
+    private _snapshots;
     static check: (value: unknown) => value is RGXWalker<unknown, unknown>;
     static assert: (value: unknown) => asserts value is RGXWalker<unknown, unknown>;
     get sourcePosition(): number;
@@ -61,6 +63,8 @@ export declare class RGXWalker<R, S = unknown> {
     stepToToken(predicate: (token: RGXTokenOrPart<R>) => boolean): this;
     stepToPart(predicate?: (part: RGXPart<R, S, unknown>) => boolean): this;
     walk(): R;
+    snapshot(name: string, ...keys: Array<RGXWalkerSnapshotKey | false>): this;
+    restore(name: string): this;
     tryWalk({ revertReduced, revertShare, revertCaptures }?: RGXTryWalkOptions): boolean;
     clone(depth?: CloneDepth): RGXWalker<R, S>;
 }

package/dist/walker/base.js

@@ -55,6 +55,7 @@ class RGXWalker {
         this._stopped = false;
         // Only relevant in infinite mode, tracking whether we've reached the end yet.
         this._didReachEnd = false;
+        this._snapshots = new Map();
         this.source = source;
         this.sourcePosition = options.startingSourcePosition ?? 0;
         this.tokens = tokens;
@@ -184,13 +185,13 @@ class RGXWalker {
         }
     }
     // Returns a directive on handled validation failure, null on success. Unhandled errors are rethrown.
-    validateCapture(token, captureResult, start) {
+    validateCapture(token, captureResult) {
         try {
             token.validate(captureResult, { part: token, walker: this });
             return null;
         }
         catch (e) {
-            this.sourcePosition = start; // Reset source position on validation failure
+            this.restore("step"); // 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.
@@ -205,7 +206,7 @@ class RGXWalker {
             throw e;
         }
     }
-    handleAfterCapture(token, captureResult, silent, start) {
+    handleAfterCapture(token, captureResult, silent) {
         const control = token.afterCapture?.(captureResult, { part: token, walker: this });
         if (!silent && (control === "skip" || control === "silent" || control === "stop-silent")) {
             this.unregisterLastCapture(token);
@@ -214,7 +215,7 @@ class RGXWalker {
         if (this.stopped)
             return "stop";
         if (control === "skip") {
-            this.sourcePosition = start;
+            this.restore("step");
             return "skip";
         }
         if (control === "stop" || control === "stop-silent")
@@ -247,9 +248,9 @@ class RGXWalker {
             silent = dir === "silent";
         }
         const branchedToken = isPart ? createBranchGroups(token.token) : createBranchGroups(token);
-        // Still track the previous source position,
-        // because if we have to skip, we need to reset to it.
-        const prevSourcePosition = this.sourcePosition;
+        // Snapshot the source position so validateCapture and handleAfterCapture
+        // can restore it on skip/failure.
+        this.snapshot("step", "sourcePosition");
         let captureAttempt;
         try {
             captureAttempt = this.attemptCapture(branchedToken, isPart ? token : null);
@@ -287,7 +288,7 @@ class RGXWalker {
             groups: captureAttempt.groups ?? null
         };
         if (isPart) {
-            const dir = this.validateCapture(token, captureResult, prevSourcePosition);
+            const dir = this.validateCapture(token, captureResult);
             if (dir === "stop") {
                 this._stopped = true;
                 return null;
@@ -300,7 +301,7 @@ class RGXWalker {
         if (!silent)
             this.registerCapture(captureResult, token);
         if (isPart) {
-            const dir = this.handleAfterCapture(token, captureResult, silent, prevSourcePosition);
+            const dir = this.handleAfterCapture(token, captureResult, silent);
             if (dir === "stop") {
                 this.advanceToken();
                 this._stopped = true;
@@ -341,31 +342,48 @@ class RGXWalker {
         this.stepToToken(() => false);
         return this.reduced;
     }
+    snapshot(name, ...keys) {
+        const filteredKeys = keys.filter((k) => k !== false);
+        const snap = {};
+        for (const key of filteredKeys) {
+            if (key === "sourcePosition" || key === "tokenPosition") {
+                snap[key] = this[key];
+            }
+            else {
+                snap[key] = (0, immutability_utils_1.extClone)(this[key], "max");
+            }
+        }
+        this._snapshots.set(name, snap);
+        return this;
+    }
+    restore(name) {
+        const snap = this._snapshots.get(name);
+        if (!snap)
+            return this;
+        if ("sourcePosition" in snap)
+            this.sourcePosition = snap.sourcePosition;
+        if ("tokenPosition" in snap)
+            this.tokenPosition = snap.tokenPosition;
+        if ("reduced" in snap)
+            this.reduced = snap.reduced;
+        if ("share" in snap)
+            this.share = snap.share;
+        if ("captures" in snap)
+            this.captures = snap.captures;
+        if ("namedCaptures" in snap)
+            this.namedCaptures = snap.namedCaptures;
+        return this;
+    }
     tryWalk({ revertReduced = false, revertShare = false, revertCaptures = false } = {}) {
-        const prevSourcePosition = this.sourcePosition;
-        const prevTokenPosition = this.tokenPosition;
-        const prevReduced = revertReduced ? (0, immutability_utils_1.extClone)(this.reduced, "max") : this.reduced;
-        const prevShare = revertShare ? (0, immutability_utils_1.extClone)(this.share, "max") : this.share;
-        const prevCaptures = revertCaptures ? (0, immutability_utils_1.extClone)(this.captures, "max") : this.captures;
-        const prevNamedCaptures = revertCaptures ? (0, immutability_utils_1.extClone)(this.namedCaptures, "max") : this.namedCaptures;
+        this.snapshot("tryWalk", "sourcePosition", "tokenPosition", revertReduced && "reduced", revertShare && "share", revertCaptures && "captures", revertCaptures && "namedCaptures");
         try {
             this.walk();
             return true;
         }
         catch (e) {
-            this.sourcePosition = prevSourcePosition;
-            this.tokenPosition = prevTokenPosition;
-            if (revertReduced)
-                this.reduced = prevReduced;
-            if (revertShare)
-                this.share = prevShare;
-            if (revertCaptures)
-                this.captures = prevCaptures;
-            if (revertCaptures)
-                this.namedCaptures = prevNamedCaptures;
-            if (isMatchError(e)) {
+            this.restore("tryWalk");
+            if (isMatchError(e))
                 return false;
-            }
             throw e;
         }
     }

package/package.json

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