@eslint-community/regexpp 4.6.1 → 4.7.0

package/index.d.ts

@@ -88,8 +88,8 @@ declare module "@eslint-community/regexpp/ast" {
   export type ClassRangesCharacterClassElement =
     | Character
     | CharacterClassRange
-    | EscapeCharacterSet
-    | UnicodePropertyCharacterSet;
+    | CharacterUnicodePropertyCharacterSet
+    | EscapeCharacterSet;
   export type UnicodeSetsCharacterClassElement =
     | Character
     | CharacterClassRange
@@ -215,12 +215,23 @@ declare module "@eslint-community/regexpp/ast" {
     negate: boolean;
     elements: CharacterClassElement[];
   }
+  /**
+   * The character class used in legacy (neither `u` nor `v` flag) and Unicode mode (`u` flag).
+   *
+   * This character class is guaranteed to **not** contain strings.
+   *
+   * In Unicode sets mode (`v` flag), {@link UnicodeSetsCharacterClass} is used.
+   */
   export interface ClassRangesCharacterClass extends BaseCharacterClass {
     parent: Alternative | Quantifier;
     unicodeSets: false;
     elements: ClassRangesCharacterClassElement[];
   }
-  /** UnicodeSetsCharacterClass is the CharacterClass when in Unicode sets mode. So it may contain strings. */
+  /**
+   * The character class used in Unicode sets mode (`v` flag).
+   *
+   * This character class may contain strings.
+   */
   export interface UnicodeSetsCharacterClass extends BaseCharacterClass {
     parent:
       | Alternative
@@ -522,6 +533,12 @@ declare module "@eslint-community/regexpp/parser" {
 
 declare module "@eslint-community/regexpp/validator" {
   import type { EcmaVersion } from "@eslint-community/regexpp/ecma-versions";
+  export type RegExpValidatorSourceContext = {
+    readonly source: string;
+    readonly start: number;
+    readonly end: number;
+    readonly kind: "flags" | "literal" | "pattern";
+  };
   export namespace RegExpValidator {
     /**
      * The options for RegExpValidator construction.

package/index.js

@@ -360,12 +360,18 @@ class Reader {
 }
 
 class RegExpSyntaxError extends SyntaxError {
-    constructor(source, flags, index, message) {
-        if (source) {
-            if (!source.startsWith("/")) {
-                source = `/${source}/${flags.unicode ? "u" : ""}${flags.unicodeSets ? "v" : ""}`;
+    constructor(srcCtx, flags, index, message) {
+        let source = "";
+        if (srcCtx.kind === "literal") {
+            const literal = srcCtx.source.slice(srcCtx.start, srcCtx.end);
+            if (literal) {
+                source = `: ${literal}`;
             }
-            source = `: ${source}`;
+        }
+        else if (srcCtx.kind === "pattern") {
+            const pattern = srcCtx.source.slice(srcCtx.start, srcCtx.end);
+            const flagsText = `${flags.unicode ? "u" : ""}${flags.unicodeSets ? "v" : ""}`;
+            source = `: /${pattern}/${flagsText}`;
         }
         super(`Invalid regular expression${source}: ${message}`);
         this.index = index;
@@ -493,9 +499,11 @@ class RegExpValidator {
         this._numCapturingParens = 0;
         this._groupNames = new Set();
         this._backreferenceNames = new Set();
+        this._srcCtx = null;
         this._options = options !== null && options !== void 0 ? options : {};
     }
     validateLiteral(source, start = 0, end = source.length) {
+        this._srcCtx = { source, start, end, kind: "literal" };
         this._unicodeSetsMode = this._unicodeMode = this._nFlag = false;
         this.reset(source, start, end);
         this.onLiteralEnter(start);
@@ -503,8 +511,8 @@ class RegExpValidator {
             const flagStart = this.index;
             const unicode = source.includes("u", flagStart);
             const unicodeSets = source.includes("v", flagStart);
-            this.validateFlags(source, flagStart, end);
-            this.validatePattern(source, start + 1, flagStart - 1, {
+            this.validateFlagsInternal(source, flagStart, end);
+            this.validatePatternInternal(source, start + 1, flagStart - 1, {
                 unicode,
                 unicodeSets,
             });
@@ -519,6 +527,29 @@ class RegExpValidator {
         this.onLiteralLeave(start, end);
     }
     validateFlags(source, start = 0, end = source.length) {
+        this._srcCtx = { source, start, end, kind: "flags" };
+        this.validateFlagsInternal(source, start, end);
+    }
+    validatePattern(source, start = 0, end = source.length, uFlagOrFlags = undefined) {
+        this._srcCtx = { source, start, end, kind: "pattern" };
+        this.validatePatternInternal(source, start, end, uFlagOrFlags);
+    }
+    validatePatternInternal(source, start = 0, end = source.length, uFlagOrFlags = undefined) {
+        const mode = this._parseFlagsOptionToMode(uFlagOrFlags, end);
+        this._unicodeMode = mode.unicodeMode;
+        this._nFlag = mode.nFlag;
+        this._unicodeSetsMode = mode.unicodeSetsMode;
+        this.reset(source, start, end);
+        this.consumePattern();
+        if (!this._nFlag &&
+            this.ecmaVersion >= 2018 &&
+            this._groupNames.size > 0) {
+            this._nFlag = true;
+            this.rewind(start);
+            this.consumePattern();
+        }
+    }
+    validateFlagsInternal(source, start, end) {
         const existingFlags = new Set();
         let global = false;
         let ignoreCase = false;
@@ -531,7 +562,7 @@ class RegExpValidator {
         for (let i = start; i < end; ++i) {
             const flag = source.charCodeAt(i);
             if (existingFlags.has(flag)) {
-                this.raise(`Duplicated flag '${source[i]}'`);
+                this.raise(`Duplicated flag '${source[i]}'`, { index: start });
             }
             existingFlags.add(flag);
             if (flag === LATIN_SMALL_LETTER_G) {
@@ -564,7 +595,7 @@ class RegExpValidator {
                 unicodeSets = true;
             }
             else {
-                this.raise(`Invalid flag '${source[i]}'`);
+                this.raise(`Invalid flag '${source[i]}'`, { index: start });
             }
         }
         this.onRegExpFlags(start, end, {
@@ -578,22 +609,7 @@ class RegExpValidator {
             unicodeSets,
         });
     }
-    validatePattern(source, start = 0, end = source.length, uFlagOrFlags = undefined) {
-        const mode = this._parseFlagsOptionToMode(uFlagOrFlags, source, end);
-        this._unicodeMode = mode.unicodeMode;
-        this._nFlag = mode.nFlag;
-        this._unicodeSetsMode = mode.unicodeSetsMode;
-        this.reset(source, start, end);
-        this.consumePattern();
-        if (!this._nFlag &&
-            this.ecmaVersion >= 2018 &&
-            this._groupNames.size > 0) {
-            this._nFlag = true;
-            this.rewind(start);
-            this.consumePattern();
-        }
-    }
-    _parseFlagsOptionToMode(uFlagOrFlags, source, sourceEnd) {
+    _parseFlagsOptionToMode(uFlagOrFlags, sourceEnd) {
         let unicode = false;
         let unicodeSets = false;
         if (uFlagOrFlags && this.ecmaVersion >= 2015) {
@@ -608,7 +624,11 @@ class RegExpValidator {
             }
         }
         if (unicode && unicodeSets) {
-            throw new RegExpSyntaxError(source, { unicode, unicodeSets }, sourceEnd + 1, "Invalid regular expression flags");
+            this.raise("Invalid regular expression flags", {
+                index: sourceEnd + 1,
+                unicode,
+                unicodeSets,
+            });
         }
         const unicodeMode = unicode || unicodeSets;
         const nFlag = (unicode && this.ecmaVersion >= 2018) ||
@@ -787,9 +807,6 @@ class RegExpValidator {
             this._options.onStringAlternativeLeave(start, end, index);
         }
     }
-    get source() {
-        return this._reader.source;
-    }
     get index() {
         return this._reader.index;
     }
@@ -823,11 +840,12 @@ class RegExpValidator {
     eat3(cp1, cp2, cp3) {
         return this._reader.eat3(cp1, cp2, cp3);
     }
-    raise(message) {
-        throw new RegExpSyntaxError(this.source, {
-            unicode: this._unicodeMode && !this._unicodeSetsMode,
-            unicodeSets: this._unicodeSetsMode,
-        }, this.index, message);
+    raise(message, context) {
+        var _a, _b, _c;
+        throw new RegExpSyntaxError(this._srcCtx, {
+            unicode: (_a = context === null || context === void 0 ? void 0 : context.unicode) !== null && _a !== void 0 ? _a : (this._unicodeMode && !this._unicodeSetsMode),
+            unicodeSets: (_b = context === null || context === void 0 ? void 0 : context.unicodeSets) !== null && _b !== void 0 ? _b : this._unicodeSetsMode,
+        }, (_c = context === null || context === void 0 ? void 0 : context.index) !== null && _c !== void 0 ? _c : this.index, message);
     }
     eatRegExpBody() {
         const start = this.index;
@@ -2208,7 +2226,15 @@ class RegExpParserState {
         const node = strings
             ? Object.assign(Object.assign({}, base), { value: null, negate: false, strings: true }) : Object.assign(Object.assign({}, base), { value,
             negate, strings: false });
-        parent.elements.push(node);
+        if (node.strings) {
+            if (parent.type === "CharacterClass" && !parent.unicodeSets) {
+                throw new Error("UnknownError");
+            }
+            parent.elements.push(node);
+        }
+        else {
+            parent.elements.push(node);
+        }
     }
     onCharacter(start, end, value) {
         const parent = this._node;