@ptolemy2002/rgx 13.2.1 → 13.3.1

package/dist/constants.d.ts

@@ -140,6 +140,11 @@ export declare const RGX_PREDEFINED_CONSTANTS: {
         readonly rgxIsRepeatable: false;
         readonly toRgx: () => RegExp;
     };
+    readonly never: {
+        readonly rgxGroupWrap: false;
+        readonly rgxIsRepeatable: false;
+        readonly toRgx: () => RegExp;
+    };
 };
 export type RGXPredefinedConstant = keyof typeof RGX_PREDEFINED_CONSTANTS;
 export type RGXConstantName = RGXPredefinedConstant | (string & {});

package/dist/constants.js

@@ -169,6 +169,14 @@ exports.RGX_PREDEFINED_CONSTANTS = {
             return /(?<=(?<!\\)(?:\\\\)*)/;
         }
     },
+    "never": {
+        rgxGroupWrap: false,
+        rgxIsRepeatable: false,
+        toRgx() {
+            // Never succeed
+            return /(?!)/;
+        }
+    }
 };
 function listRGXConstants() {
     return Object.keys(rgxConstants);

package/dist/resolve.js

@@ -60,6 +60,7 @@ function localizableVanillaRegexFlagDiff(prev, next) {
 }
 function resolveRGXToken(token, { groupWrap = true, topLevel = true, currentFlags = '' } = {}) {
     (0, ExtRegExp_1.assertValidRegexFlags)(currentFlags);
+    let acceptUnterminatedGroup = false;
     const innerResolve = () => {
         if (tg.isRGXNoOpToken(token))
             return '';
@@ -80,10 +81,14 @@ function resolveRGXToken(token, { groupWrap = true, topLevel = true, currentFlag
             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)
+            // It might have an unterminated group, but that's okay,
+            // since a future token might terminate it, and if it doesn't, that
+            // will be caught by one of the checks that the entire resolved string
+            // is a valid regex string.
+            if (token.rgxInterpolate) {
+                acceptUnterminatedGroup = true;
                 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(), { groupWrap: token.rgxGroupWrap ?? (topLevel ? groupWrap : true), topLevel: false, currentFlags });
@@ -108,6 +113,19 @@ function resolveRGXToken(token, { groupWrap = true, topLevel = true, currentFlag
         throw new e.RGXInvalidTokenError(`Invalid RGX token: ${token}`, null, token);
     };
     const result = innerResolve();
-    tg.assertValidRegexString(result);
+    try {
+        tg.assertValidRegexString(result);
+    }
+    catch (err) {
+        if (err instanceof e.RGXInvalidRegexStringError) {
+            if (acceptUnterminatedGroup && err.cause.message.endsWith('Unterminated group')) {
+                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/typeGuards.js

@@ -266,7 +266,7 @@ function assertValidRegexString(value) {
             if (err instanceof SyntaxError) {
                 throw new e.RGXInvalidRegexStringError("Invalid regex string", value, err);
             }
-            // This is ignored because I don't know what king of
+            // This is ignored because I don't know what kind of
             // unexpected errors might happen.
             /* istanbul ignore next */
             throw err;

package/package.json

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