@ptolemy2002/rgx 9.0.0 → 11.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.
+  - [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/concat.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rgxConcat = rgxConcat;
+const ExtRegExp_1 = require("./ExtRegExp");
 const internal_1 = require("./internal");
 const resolve_1 = require("./resolve");
 // Wrapper for letting an array of tokens be resolved as a concatenation instead of a union.
 function rgxConcat(tokens, groupWrap = true, currentFlags = '') {
+    (0, ExtRegExp_1.assertValidRegexFlags)(currentFlags);
     const result = tokens.map(t => (0, resolve_1.resolveRGXToken)(t, groupWrap, true, currentFlags)).join('');
     (0, internal_1.assureAcceptance)(tokens, currentFlags);
     return result;

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/invalidRegexString.d.ts

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

package/dist/errors/invalidRegexString.js

@@ -3,13 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RGXInvalidRegexStringError = void 0;
 const errors_1 = require("./");
 class RGXInvalidRegexStringError extends errors_1.RGXError {
-    constructor(message, got) {
+    constructor(message, got, cause) {
         super(message, 'INVALID_REGEX_STRING');
         this.name = 'RGXInvalidRegexStringError';
         this.got = got;
+        this.cause = cause;
     }
     calcMessage(message) {
-        return `${message}; Got: ${JSON.stringify(this.got)}`;
+        return `${message}; Got: ${JSON.stringify(this.got)}; Cause: ${this.cause.message}`;
     }
 }
 exports.RGXInvalidRegexStringError = RGXInvalidRegexStringError;

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.d.ts

@@ -16,6 +16,6 @@ export * from "./constants";
 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 default function rgx(flags?: string, multiline?: boolean, verbatim?: boolean): (strings: TemplateStringsArray, ...tokens: t.RGXToken[]) => ExtRegExp;
 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>;
+export declare function rgxw<R = unknown, S = unknown, T = unknown>(source: string, { multiline, verbatim, ...options }?: t.RGXWOptions<R, S>): (strings: TemplateStringsArray, ...tokens: RGXTokenOrPart<R, S, T>[]) => RGXWalker<R, S>;

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,20 +47,20 @@ 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) {
-    (0, ExtRegExp_1.assertValidRegexFlags)(flags);
+function rgx(flags = '', multiline = true, verbatim = true) {
     return (strings, ...tokens) => {
-        return rgxa((0, internal_1.taggedTemplateToArray)(strings, tokens, multiline), flags);
+        // 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);
     };
 }
 function rgxwa(source, tokens, options = {}) {
     (0, internal_1.assureAcceptance)(tokens.map(t => walker_1.RGXPart.check(t) ? t.token : t), '');
     return new walker_1.RGXWalker(source, tokens, options);
 }
-function rgxw(source, { multiline = true, ...options } = {}) {
+function rgxw(source, { multiline = true, verbatim = true, ...options } = {}) {
     return (strings, ...tokens) => {
-        return rgxwa(source, (0, internal_1.taggedTemplateToArray)(strings, tokens, multiline), options);
+        return rgxwa(source, (0, internal_1.rgxTaggedTemplateToArray)(strings, tokens, multiline, verbatim), options);
     };
 }

package/dist/internal/taggedTemplateToArray.d.ts

@@ -1 +1,2 @@
-export declare function taggedTemplateToArray<T>(strings: TemplateStringsArray, tokens: T[], multiline: boolean): (string | T)[];
+import { RGXTokenOrPart } from "../walker";
+export declare function rgxTaggedTemplateToArray<R = unknown, S = unknown, T = unknown>(strings: TemplateStringsArray, tokens: RGXTokenOrPart<R, S, T>[], multiline: boolean, verbatim: boolean): RGXTokenOrPart<R, S, T>[];

package/dist/internal/taggedTemplateToArray.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.taggedTemplateToArray = taggedTemplateToArray;
-function taggedTemplateToArray(strings, tokens, multiline) {
+exports.rgxTaggedTemplateToArray = rgxTaggedTemplateToArray;
+function rgxTaggedTemplateToArray(strings, tokens, multiline, verbatim) {
     function isNullOrUndefined(value) {
         return value === null || value === undefined;
     }
@@ -12,13 +12,27 @@ function taggedTemplateToArray(strings, tokens, multiline) {
         // Strings always come before tokens
         if (!isNullOrUndefined(string)) {
             if (!multiline) {
-                array.push(string);
+                if (verbatim)
+                    array.push(string);
+                else
+                    array.push({ rgxInterpolate: true, toRgx: () => string });
             }
             else {
+                const startsNewLine = string.startsWith("\n");
                 // Remove all empty lines, remove comments, and trim whitespace from the start of each line.
                 let lines = string
                     .split("\n")
-                    .map(line => line.trimStart())
+                    /*
+                        This check makes sure
+                        `
+                            foo |
+                            ${'bar'} |
+                            baz
+                        `
+
+                        resolves to "foo | bar |baz" instead of "foo | bar|baz"
+                    */
+                    .map((line, i) => (i !== 0 || startsNewLine) ? line.trimStart() : line)
                     // Remove comments both for the start of the line.
                     .filter(line => !line.startsWith("//"))
                     .filter(line => line.length > 0)
@@ -31,7 +45,10 @@ function taggedTemplateToArray(strings, tokens, multiline) {
                     return line;
                 })
                     .join("");
-                array.push(lines);
+                if (verbatim)
+                    array.push(lines);
+                else
+                    array.push({ rgxInterpolate: true, toRgx: () => lines });
             }
         }
         if (!isNullOrUndefined(token))

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/resolve.js

@@ -37,9 +37,12 @@ exports.escapeRegex = escapeRegex;
 exports.resolveRGXToken = resolveRGXToken;
 const class_1 = require("./class");
 const e = __importStar(require("./errors"));
+const ExtRegExp_1 = require("./ExtRegExp");
 const tg = __importStar(require("./typeGuards"));
 function escapeRegex(value) {
-    return value.replaceAll(/[\-\^\$.*+?^${}()|[\]\\]/g, '\\$&');
+    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
@@ -56,44 +59,55 @@ function localizableVanillaRegexFlagDiff(prev, next) {
     return `${added}-${removed}`;
 }
 function resolveRGXToken(token, groupWrap = true, topLevel = true, currentFlags = '') {
-    if (tg.isRGXNoOpToken(token))
-        return '';
-    if (tg.isRGXLiteralToken(token)) {
-        const localizableFlagDiff = localizableVanillaRegexFlagDiff(currentFlags, token.flags);
-        currentFlags = token.flags;
-        if (!localizableFlagDiff) {
-            if (groupWrap)
-                return '(?:' + token.source + ')';
-            else
-                return token.source;
+    (0, ExtRegExp_1.assertValidRegexFlags)(currentFlags);
+    const innerResolve = () => {
+        if (tg.isRGXNoOpToken(token))
+            return '';
+        if (tg.isRGXLiteralToken(token)) {
+            const localizableFlagDiff = localizableVanillaRegexFlagDiff(currentFlags, token.flags);
+            currentFlags = token.flags;
+            if (!localizableFlagDiff) {
+                if (groupWrap)
+                    return '(?:' + token.source + ')';
+                else
+                    return token.source;
+            }
+            else {
+                return `(?${localizableFlagDiff}:${token.source})`;
+            }
         }
-        else {
-            return `(?${localizableFlagDiff}:${token.source})`;
+        if (tg.isRGXNativeToken(token))
+            return escapeRegex(String(token));
+        if (tg.isRGXConvertibleToken(token)) {
+            // If it's an interpolation, we want to just return it as-is.
+            // This will mean the result might be an invalid regex string,
+            // but that's why we have a check.
+            if (token.rgxInterpolate)
+                return String(token.toRgx());
+            // The top-level group-wrapping preference propogates to a direct convertible token, but after that
+            // the preference falls back to true whenever a token doesn't explicitly specify a preference.
+            return resolveRGXToken(token.toRgx(), token.rgxGroupWrap ?? (topLevel ? groupWrap : true), false, currentFlags);
         }
-    }
-    if (tg.isRGXNativeToken(token))
-        return escapeRegex(String(token));
-    if (tg.isRGXConvertibleToken(token)) {
-        // The top-level group-wrapping preference propogates to a direct convertible token, but after that
-        // the preference falls back to true whenever a token doesn't explicitly specify a preference.
-        return resolveRGXToken(token.toRgx(), token.rgxGroupWrap ?? (topLevel ? groupWrap : true), false, currentFlags);
-    }
-    // Interpret arrays as unions
-    if (tg.isRGXArrayToken(token, false)) {
-        if (token.length === 0)
-            return '';
-        if (token.length > 1) {
-            // Remove duplicates
-            token = [...(0, class_1.removeRgxUnionDuplicates)(...token)];
-            // Don't preserve group wrapping preference for the recursive calls
-            if (groupWrap)
-                return '(?:' + token.map(t => resolveRGXToken(t, true, false, currentFlags)).join('|') + ')';
-            else
-                return token.map(t => resolveRGXToken(t, true, false, currentFlags)).join('|');
+        // Interpret arrays as unions
+        if (tg.isRGXArrayToken(token, false)) {
+            if (token.length === 0)
+                return '';
+            if (token.length > 1) {
+                // Remove duplicates
+                token = [...(0, class_1.removeRgxUnionDuplicates)(...token)];
+                // Don't preserve group wrapping preference for the recursive calls
+                if (groupWrap)
+                    return '(?:' + token.map(t => resolveRGXToken(t, true, false, currentFlags)).join('|') + ')';
+                else
+                    return token.map(t => resolveRGXToken(t, true, false, currentFlags)).join('|');
+            }
+            return resolveRGXToken(token[0], true, false, currentFlags);
         }
-        return resolveRGXToken(token[0], true, false, currentFlags);
-    }
-    // Ignoring this line since it should be impossible to reach if the types are correct, but we need it to satisfy the return type
-    /* istanbul ignore next */
-    throw new e.RGXInvalidTokenError(`Invalid RGX token: ${token}`, null, token);
+        // Ignoring this line since it should be impossible to reach if the types are correct, but we need it to satisfy the return type
+        /* istanbul ignore next */
+        throw new e.RGXInvalidTokenError(`Invalid RGX token: ${token}`, null, token);
+    };
+    const result = innerResolve();
+    tg.assertValidRegexString(result);
+    return result;
 }

package/dist/typeGuards.js

@@ -93,13 +93,15 @@ function assertRGXNativeToken(value) {
 }
 function isRGXConvertibleToken(value, returnCheck = true) {
     if (typeof value === 'object' && value !== null && 'toRgx' in value) {
-        // The rgxGroupWrap, rgxIsRepeatable, and rgxIsGroup properties are optional, but if they exist they must be booleans.
+        // The rgxGroupWrap, interpolate, rgxIsRepeatable, and rgxIsGroup properties are optional, but if they exist they must be booleans.
         if ('rgxGroupWrap' in value && typeof value.rgxGroupWrap !== 'boolean')
             return false;
         if ('rgxIsRepeatable' in value && typeof value.rgxIsRepeatable !== 'boolean')
             return false;
         if ('rgxIsGroup' in value && typeof value.rgxIsGroup !== 'boolean')
             return false;
+        if ('rgxInterpolate' in value && typeof value.rgxInterpolate !== 'boolean')
+            return false;
         // If the rgxAcceptInsertion property exists, it must be a function that returns a string or boolean.
         if ('rgxAcceptInsertion' in value) {
             if (!(0, is_callable_1.default)(value.rgxAcceptInsertion))
@@ -219,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);
     }
 }
@@ -240,13 +247,30 @@ function isValidRegexString(value) {
         new RegExp(value);
         return true;
     }
-    catch {
-        return false;
+    catch (e) {
+        if (e instanceof SyntaxError) {
+            return false;
+        }
+        // This is ignored because I don't know what kind of
+        // unexpected errors might happen.
+        /* istanbul ignore next */
+        throw e;
     }
 }
 function assertValidRegexString(value) {
     if (!isValidRegexString(value)) {
-        throw new e.RGXInvalidRegexStringError("Invalid regex string", value);
+        try {
+            new RegExp(value);
+        }
+        catch (err) {
+            if (err instanceof SyntaxError) {
+                throw new e.RGXInvalidRegexStringError("Invalid regex string", value, err);
+            }
+            // This is ignored because I don't know what king of
+            // unexpected errors might happen.
+            /* istanbul ignore next */
+            throw err;
+        }
     }
 }
 function isValidVanillaRegexFlags(value) {

package/dist/types.d.ts

@@ -12,6 +12,7 @@ export type RGXConvertibleToken = {
     readonly rgxGroupWrap?: boolean;
     readonly rgxIsGroup?: boolean;
     readonly rgxIsRepeatable?: boolean;
+    readonly rgxInterpolate?: boolean;
 };
 export type RGXToken = RGXNativeToken | RGXLiteralToken | RGXConvertibleToken | RGXToken[];
 export type RGXClassTokenConstructor = new (...args: unknown[]) => RGXClassToken;
@@ -49,6 +50,8 @@ 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, S = unknown> = RGXWalkerOptions<R, S> & {
+export type RGXOptions = {
     multiline?: boolean;
+    verbatim?: boolean;
 };
+export type RGXWOptions<R = unknown, S = unknown> = RGXWalkerOptions<R, S> & RGXOptions;

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,7 @@ class RGXWalker {
         }
         catch (e) {
             if (isPart && e instanceof errors_1.RGXRegexNotMatchedAtPositionError) {
-                token.afterFailure?.(e, this.share, token, this);
+                token.afterFailure?.(e, { part: token, walker: this });
             }
             throw e;
         }
@@ -159,11 +159,11 @@ 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) {
                 if (e instanceof errors_1.RGXPartValidationFailedError) {
-                    token.afterValidationFailure?.(e, this.share, token, this);
+                    token.afterValidationFailure?.(e, { part: token, walker: this });
                 }
                 throw e;
             }
@@ -179,7 +179,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 +213,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>) => void) | null;
+    afterValidationFailure: ((e: RGXPartValidationFailedError, context: RGXPartContext<R, S, T>) => void) | 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": "9.0.0",
+    "version": "11.0.0",
     "private": false,
     "main": "dist/index.js",
     "types": "dist/index.d.ts",