@ptolemy2002/rgx 12.6.0 → 12.7.1

package/README.md

@@ -16,6 +16,7 @@ Because there is so much to document, it has been broken up into multiple files.
   - [clone](./docs/util/clone.md) - The `cloneRGXToken` function, which creates a clone of a given RGX token to a specified depth.
   - [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.
+  - [regexMatchAfterPosition](./docs/util/regexMatchAfterPosition.md) - The `regexMatchAfterPosition` function and related functions, which search for a regular expression match at or after 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.

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

package/dist/errors/index.d.ts

@@ -13,6 +13,7 @@ export * from './insertionRejected';
 export * from './constantConflict';
 export * from './invalidConstantKey';
 export * from './regexNotMatchedAtPosition';
+export * from './regexNotMatchedAfterPosition';
 export * from './partValidationFailed';
 export * from './invalidLexerMode';
 export * from './lexemeNotMatchedAtPosition';

package/dist/errors/index.js

@@ -29,6 +29,7 @@ __exportStar(require("./insertionRejected"), exports);
 __exportStar(require("./constantConflict"), exports);
 __exportStar(require("./invalidConstantKey"), exports);
 __exportStar(require("./regexNotMatchedAtPosition"), exports);
+__exportStar(require("./regexNotMatchedAfterPosition"), exports);
 __exportStar(require("./partValidationFailed"), exports);
 __exportStar(require("./invalidLexerMode"), exports);
 __exportStar(require("./lexemeNotMatchedAtPosition"), exports);

package/dist/errors/lexemeNotMatchedAtPosition.d.ts

@@ -1,5 +1,5 @@
-import { RGXError, RGXPartValidationFailedError, RGXRegexNotMatchedAtPositionError } from "./";
-export type LexemeNotMatchedCauseError = RGXRegexNotMatchedAtPositionError | RGXPartValidationFailedError;
+import { RGXError, RGXPartValidationFailedError, RGXRegexNotMatchedAfterPositionError, RGXRegexNotMatchedAtPositionError } from "./";
+export type LexemeNotMatchedCauseError = RGXRegexNotMatchedAtPositionError | RGXPartValidationFailedError | RGXRegexNotMatchedAfterPositionError;
 export type LexemeNotMatchedCause = {
     id: string;
     error: LexemeNotMatchedCauseError;

package/dist/errors/lexemeNotMatchedAtPosition.js

@@ -4,7 +4,7 @@ exports.RGXLexemeNotMatchedAtPositionError = void 0;
 exports.isLexemeNotMatchedCauseError = isLexemeNotMatchedCauseError;
 const errors_1 = require("./");
 function isLexemeNotMatchedCauseError(error) {
-    return error instanceof errors_1.RGXRegexNotMatchedAtPositionError || error instanceof errors_1.RGXPartValidationFailedError;
+    return error instanceof errors_1.RGXRegexNotMatchedAtPositionError || error instanceof errors_1.RGXPartValidationFailedError || error instanceof errors_1.RGXRegexNotMatchedAfterPositionError;
 }
 class RGXLexemeNotMatchedAtPositionError extends errors_1.RGXError {
     get position() {

package/dist/errors/regexNotMatchedAfterPosition.d.ts

@@ -0,0 +1,15 @@
+import { RGXError } from "./base";
+export declare class RGXRegexNotMatchedAfterPositionError extends RGXError {
+    pattern: RegExp;
+    source: string;
+    _position: number;
+    contextSize: number | null;
+    set position(value: number);
+    get position(): number;
+    constructor(message: string, pattern: RegExp, source: string, position: number, contextSize?: number | null);
+    sourceContext(): string;
+    hasLeftContext(): boolean;
+    hasRightContext(): boolean;
+    hasFullContext(): boolean;
+    calcMessage(message: string): string;
+}

package/dist/errors/regexNotMatchedAfterPosition.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RGXRegexNotMatchedAfterPositionError = void 0;
+const base_1 = require("./base");
+const outOfBounds_1 = require("./outOfBounds");
+class RGXRegexNotMatchedAfterPositionError extends base_1.RGXError {
+    set position(value) {
+        (0, outOfBounds_1.assertInRange)(value, { min: 0, max: this.source.length }, "position is outside the bounds of the source string");
+        this._position = value;
+    }
+    get position() {
+        return this._position;
+    }
+    constructor(message, pattern, source, position, contextSize = null) {
+        super(message, 'REGEX_NOT_MATCHED_AFTER_POSITION');
+        this.name = 'RGXRegexNotMatchedAfterPositionError';
+        this.pattern = pattern;
+        this.source = source;
+        this.position = position;
+        this.contextSize = contextSize;
+    }
+    sourceContext() {
+        if (this.hasFullContext())
+            return this.source;
+        const start = Math.max(0, this.position - this.contextSize);
+        const end = Math.min(this.source.length, this.position + this.contextSize);
+        return this.source.slice(start, end);
+    }
+    hasLeftContext() {
+        if (this.contextSize === null)
+            return false;
+        return this.position - this.contextSize >= 0;
+    }
+    hasRightContext() {
+        if (this.contextSize === null)
+            return false;
+        return this.position + this.contextSize <= this.source.length;
+    }
+    hasFullContext() {
+        return !this.hasLeftContext() && !this.hasRightContext();
+    }
+    calcMessage(message) {
+        let context = this.sourceContext();
+        if (this.contextSize !== null) {
+            if (this.hasLeftContext())
+                context = `...${context}`;
+            if (this.hasRightContext())
+                context = `${context}...`;
+        }
+        return `${message}; Pattern: ${this.pattern.toString()}, Position: ${this.position}, Context: ${context}`;
+    }
+}
+exports.RGXRegexNotMatchedAfterPositionError = RGXRegexNotMatchedAfterPositionError;

package/dist/utils/index.d.ts

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

package/dist/utils/index.js

@@ -15,6 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./regexMatchAtPosition"), exports);
+__exportStar(require("./regexMatchAfterPosition"), exports);
 __exportStar(require("./regexWithFlags"), exports);
 __exportStar(require("./normalizeRegexFlags"), exports);
 __exportStar(require("./createRGXClassGuardFunction"), exports);

package/dist/utils/regexMatchAfterPosition.d.ts

@@ -0,0 +1,6 @@
+export declare function regexMatchAfterPosition(regex: RegExp, str: string, position: number, includeMatch: true): [number, RegExpExecArray] | null;
+export declare function regexMatchAfterPosition(regex: RegExp, str: string, position: number, includeMatch?: false): [number, string] | null;
+export declare function doesRegexMatchAfterPosition(regex: RegExp, str: string, position: number, includeMatch: true): [number, RegExpExecArray] | false;
+export declare function doesRegexMatchAfterPosition(regex: RegExp, str: string, position: number, includeMatch?: false): boolean;
+export declare function assertRegexMatchesAfterPosition(regex: RegExp, str: string, position: number, contextSize?: number | null, includeMatch?: false): [number, string];
+export declare function assertRegexMatchesAfterPosition(regex: RegExp, str: string, position: number, contextSize: number | null | undefined, includeMatch: true): [number, RegExpExecArray];

package/dist/utils/regexMatchAfterPosition.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.regexMatchAfterPosition = regexMatchAfterPosition;
+exports.doesRegexMatchAfterPosition = doesRegexMatchAfterPosition;
+exports.assertRegexMatchesAfterPosition = assertRegexMatchesAfterPosition;
+const outOfBounds_1 = require("../errors/outOfBounds");
+const regexWithFlags_1 = require("./regexWithFlags");
+const errors_1 = require("../errors");
+function regexMatchAfterPosition(regex, str, position, includeMatch = false) {
+    /*
+        The g flag means global mode, which searches forward from lastIndex rather
+        than requiring a match exactly there (as the y/sticky flag does). By setting
+        lastIndex to the position we want to search from, exec will find the next
+        match at or after that position.
+    */
+    (0, outOfBounds_1.assertInRange)(position, { min: 0, max: str.length, inclusiveRight: false }, 'String index out of bounds');
+    const globalRegex = (0, regexWithFlags_1.regexWithFlags)(regex, "g");
+    globalRegex.lastIndex = position;
+    const match = globalRegex.exec(str);
+    return match ? (includeMatch ? [match.index, match] : [match.index, match[0]]) : null;
+}
+function doesRegexMatchAfterPosition(regex, str, position, includeMatch = false) {
+    const match = regexMatchAfterPosition(regex, str, position, true);
+    if (includeMatch)
+        return match ?? false;
+    return match !== null;
+}
+function assertRegexMatchesAfterPosition(regex, str, position, contextSize = 10, includeMatch = false) {
+    const result = regexMatchAfterPosition(regex, str, position, true);
+    if (result === null) {
+        throw new errors_1.RGXRegexNotMatchedAfterPositionError("Regex not matched after index", regex, str, position, contextSize);
+    }
+    return includeMatch ? result : [result[0], result[1][0]];
+}

package/dist/walker/base.d.ts

@@ -7,6 +7,7 @@ export type RGXWalkerOptions<R, S = unknown> = {
     share?: S;
     infinite?: boolean;
     looping?: boolean;
+    contiguous?: boolean;
 };
 export type RGXTokenOrPart<R, S = unknown, T = unknown> = RGXToken | RGXPart<R, S, T>;
 export type RGXWalkerStepDirective = "stop" | "skip" | "silent";
@@ -21,7 +22,9 @@ export declare class RGXWalker<R, S = unknown> {
     namedCaptures: Record<string, RGXCapture[]>;
     infinite: boolean;
     looping: boolean;
+    contiguous: boolean;
     private _stopped;
+    private _didReachEnd;
     static check: (value: unknown) => value is RGXWalker<unknown, unknown>;
     static assert: (value: unknown) => asserts value is RGXWalker<unknown, unknown>;
     get sourcePosition(): number;

package/dist/walker/base.js

@@ -26,7 +26,9 @@ function createBranchGroups(tokens) {
     }
 }
 function isMatchError(e) {
-    return e instanceof errors_1.RGXRegexNotMatchedAtPositionError || e instanceof errors_1.RGXPartValidationFailedError;
+    return (e instanceof errors_1.RGXRegexNotMatchedAtPositionError ||
+        e instanceof errors_1.RGXRegexNotMatchedAfterPositionError ||
+        e instanceof errors_1.RGXPartValidationFailedError);
 }
 class RGXWalker {
     get sourcePosition() {
@@ -50,6 +52,8 @@ class RGXWalker {
         this.captures = [];
         this.namedCaptures = {};
         this._stopped = false;
+        // Only relevant in infinite mode, tracking whether we've reached the end yet.
+        this._didReachEnd = false;
         this.source = source;
         this.sourcePosition = options.startingSourcePosition ?? 0;
         this.tokens = tokens;
@@ -58,6 +62,7 @@ class RGXWalker {
         this.share = options.share ?? null;
         this.infinite = options.infinite ?? false;
         this.looping = options.looping ?? false;
+        this.contiguous = options.contiguous ?? true;
     }
     stop() {
         this._stopped = true;
@@ -92,11 +97,24 @@ class RGXWalker {
     }
     capture(token, includeMatch = false) {
         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;
+        const args = [regex, this.source, this.sourcePosition, 10, true];
+        let match;
+        let endPosition;
+        if (this.contiguous) {
+            match = (0, utils_1.assertRegexMatchesAtPosition)(...args);
+            endPosition = this.sourcePosition + match[0].length;
+        }
+        else {
+            const [startPosition, _match] = (0, utils_1.assertRegexMatchesAfterPosition)(...args);
+            match = _match;
+            endPosition = startPosition + match[0].length;
+        }
+        this.sourcePosition = endPosition;
         return includeMatch ? match : match[0];
     }
     advanceToken() {
+        if (this.tokenPosition === this.tokens.length - 1)
+            this._didReachEnd = true;
         if (!this.infinite || this.tokenPosition < this.tokens.length - 1) {
             this.tokenPosition++;
             if (this.looping && this.atTokenEnd()) {
@@ -144,7 +162,7 @@ class RGXWalker {
             return this.capture(branchedToken, true);
         }
         catch (e) {
-            if (part !== null && e instanceof errors_1.RGXRegexNotMatchedAtPositionError) {
+            if (part !== null && (e instanceof errors_1.RGXRegexNotMatchedAtPositionError || e instanceof errors_1.RGXRegexNotMatchedAfterPositionError)) {
                 const control = part.afterFailure?.(e, { part, walker: this });
                 // If this happens, afterFailure itself stopped the walker, so we just need to respect that.
                 if (this.stopped)
@@ -182,12 +200,12 @@ class RGXWalker {
     }
     handleAfterCapture(token, captureResult, silent, start) {
         const control = token.afterCapture?.(captureResult, { part: token, walker: this });
-        // If this happens, afterCapture itself stopped the walker, so we just need to respect that.
-        if (this.stopped)
-            return "stop";
         if (!silent && (control === "skip" || control === "silent" || control === "stop-silent")) {
             this.unregisterLastCapture(token);
         }
+        // If this happens, afterCapture itself stopped the walker, so we just need to respect that.
+        if (this.stopped)
+            return "stop";
         if (control === "skip") {
             this.sourcePosition = start;
             return "skip";
@@ -221,17 +239,34 @@ class RGXWalker {
             }
             silent = dir === "silent";
         }
-        const start = this.sourcePosition;
         const branchedToken = isPart ? createBranchGroups(token.token) : createBranchGroups(token);
-        const captureAttempt = this.attemptCapture(branchedToken, isPart ? token : null);
-        if (captureAttempt === "stop") {
-            this._stopped = true;
-            return null;
+        let captureAttempt;
+        try {
+            captureAttempt = this.attemptCapture(branchedToken, isPart ? token : null);
+            if (captureAttempt === "stop") {
+                this._stopped = true;
+                return null;
+            }
+            if (captureAttempt === "skip") {
+                this.advanceToken();
+                return null;
+            }
         }
-        if (captureAttempt === "skip") {
-            this.advanceToken();
-            return null;
+        catch (e) {
+            if (e instanceof errors_1.RGXRegexNotMatchedAfterPositionError) {
+                // If we're in infinite mode, we've reached the end before, and we're at the end now,
+                // this is recoverable. Just stop the walker instead of throwing an error.
+                if (this.infinite && this._didReachEnd && this.tokenPosition === this.tokens.length - 1) {
+                    this._stopped = true;
+                    return null;
+                }
+            }
+            throw e;
         }
+        // The reason we no longer track start as the position before attempting capture
+        // is the possibility of non-contiguous matches. In that case, there may be a gap between
+        // the previous position and the actual start of the capture.
+        const start = this.sourcePosition - captureAttempt[0].length;
         const raw = isPart ? token.rawTransform(captureAttempt[0]) : captureAttempt[0];
         const end = this.sourcePosition;
         const value = isPart ? token.transform(raw) : raw;

package/dist/walker/part.d.ts

@@ -1,7 +1,7 @@
 import { RGXToken } from "../types";
 import type { RGXWalker } from "./base";
 import { CloneDepth } from "@ptolemy2002/immutability-utils";
-import { RGXPartValidationFailedError, RGXRegexNotMatchedAtPositionError } from "../errors";
+import { RGXPartValidationFailedError, RGXRegexNotMatchedAfterPositionError, RGXRegexNotMatchedAtPositionError } from "../errors";
 export type RGXPartControl = "skip" | "stop" | "silent" | "stop-silent" | void;
 export type RGXCapture<T = unknown> = {
     raw: string;
@@ -23,7 +23,7 @@ export type RGXPartOptions<R, S = unknown, T = string> = {
     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>) => RGXPartControl) | null;
-    afterFailure: ((e: RGXRegexNotMatchedAtPositionError, context: RGXPartContext<R, S, T>) => RGXPartControl) | null;
+    afterFailure: ((e: RGXRegexNotMatchedAtPositionError | RGXRegexNotMatchedAfterPositionError, 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> {

package/dist/walker/part.js

@@ -38,6 +38,8 @@ class RGXPart {
             transform: this.transform,
             beforeCapture: this.beforeCapture,
             afterCapture: this.afterCapture,
+            afterFailure: this.afterFailure,
+            afterValidationFailure: this.afterValidationFailure,
         });
     }
 }

package/package.json

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