@ptolemy2002/rgx 13.3.3 → 13.4.0

package/dist/resolve.js

@@ -58,9 +58,39 @@ function localizableVanillaRegexFlagDiff(prev, next) {
         return `${added}`;
     return `${added}-${removed}`;
 }
+function hasParenErrors(pattern) {
+    let depth = 0;
+    let charClassDepth = 0;
+    for (let i = 0; i < pattern.length; i++) {
+        const ch = pattern[i];
+        if (ch === '\\') {
+            i++;
+            continue;
+        }
+        if (charClassDepth > 0) {
+            if (ch === '[')
+                charClassDepth++;
+            else if (ch === ']')
+                charClassDepth--;
+            continue;
+        }
+        if (ch === '[') {
+            charClassDepth++;
+        }
+        else if (ch === '(') {
+            depth++;
+        }
+        else if (ch === ')') {
+            depth--;
+            if (depth < 0)
+                return true;
+        }
+    }
+    return depth !== 0;
+}
 function resolveRGXToken(token, { groupWrap = true, topLevel = true, currentFlags = '' } = {}) {
     (0, ExtRegExp_1.assertValidRegexFlags)(currentFlags);
-    let acceptUnterminatedGroup = false;
+    let acceptParenErrors = false;
     const innerResolve = () => {
         if (tg.isRGXNoOpToken(token))
             return '';
@@ -86,7 +116,7 @@ function resolveRGXToken(token, { groupWrap = true, topLevel = true, currentFlag
             // will be caught by one of the checks that the entire resolved string
             // is a valid regex string.
             if (token.rgxInterpolate) {
-                acceptUnterminatedGroup = true;
+                acceptParenErrors = true;
                 return String(token.toRgx());
             }
             // The top-level group-wrapping preference propogates to a direct convertible token, but after that
@@ -113,21 +143,7 @@ function resolveRGXToken(token, { groupWrap = true, topLevel = true, currentFlag
         throw new e.RGXInvalidTokenError(`Invalid RGX token: ${token}`, null, token);
     };
     const result = innerResolve();
-    try {
+    if (!(acceptParenErrors && hasParenErrors(result)))
         tg.assertValidRegexString(result);
-    }
-    catch (err) {
-        if (err instanceof e.RGXInvalidRegexStringError) {
-            if (acceptUnterminatedGroup &&
-                (err.cause.message.endsWith('Unterminated group') ||
-                    err.cause.message.endsWith("Unmatched ')'"))) {
-                return result;
-            }
-        }
-        // This is ignored because I don't know what kind of
-        // unexpected errors might happen.
-        /* istanbul ignore next */
-        throw err;
-    }
     return result;
 }

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.3",
+    "version": "13.4.0",
     "private": false,
     "main": "dist/index.js",
     "types": "dist/index.d.ts",