@ptolemy2002/rgx 9.0.0 → 10.0.0

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/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/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

@@ -48,18 +48,19 @@ function rgxa(tokens, flags = '') {
     const pattern = (0, concat_1.rgxConcat)(tokens, true, flags);
     return (0, ExtRegExp_1.extRegExp)(pattern, flags);
 }
-function rgx(flags = '', multiline = true) {
+function rgx(flags = '', multiline = true, verbatim = true) {
     (0, ExtRegExp_1.assertValidRegexFlags)(flags);
     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/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))
@@ -240,13 +242,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 king 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/package.json

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