immosquare-cleaner 0.1.46 → 0.1.47

data/node_modules/eslint/lib/rules/no-invalid-regexp.js

@@ -10,7 +10,7 @@
 
 const RegExpValidator = require("@eslint-community/regexpp").RegExpValidator;
 const validator = new RegExpValidator();
-const validFlags = /[dgimsuvy]/gu;
+const validFlags = "dgimsuvy";
 const undefined1 = void 0;
 
 //------------------------------------------------------------------------------
@@ -49,13 +49,13 @@ module.exports = {
     create(context) {
 
         const options = context.options[0];
-        let allowedFlags = null;
+        let allowedFlags = [];
 
         if (options && options.allowConstructorFlags) {
-            const temp = options.allowConstructorFlags.join("").replace(validFlags, "");
+            const temp = options.allowConstructorFlags.join("").replace(new RegExp(`[${validFlags}]`, "gu"), "");
 
             if (temp) {
-                allowedFlags = new RegExp(`[${temp}]`, "gu");
+                allowedFlags = [...new Set(temp)];
             }
         }
 
@@ -125,16 +125,19 @@ module.exports = {
         /**
          * Check syntax error in a given flags.
          * @param {string|null} flags The RegExp flags to validate.
+         * @param {string|null} flagsToCheck The RegExp invalid flags.
+         * @param {string} allFlags all valid and allowed flags.
          * @returns {string|null} The syntax error.
          */
-        function validateRegExpFlags(flags) {
-            if (!flags) {
-                return null;
-            }
-            try {
-                validator.validateFlags(flags);
-            } catch {
-                return `Invalid flags supplied to RegExp constructor '${flags}'`;
+        function validateRegExpFlags(flags, flagsToCheck, allFlags) {
+            const duplicateFlags = [];
+
+            if (typeof flagsToCheck === "string") {
+                for (const flag of flagsToCheck) {
+                    if (allFlags.includes(flag)) {
+                        duplicateFlags.push(flag);
+                    }
+                }
             }
 
             /*
@@ -142,10 +145,19 @@ module.exports = {
              * but this rule may check only the flag when the pattern is unidentifiable, so check it here.
              * https://tc39.es/ecma262/multipage/text-processing.html#sec-parsepattern
              */
-            if (flags.includes("u") && flags.includes("v")) {
+            if (flags && flags.includes("u") && flags.includes("v")) {
                 return "Regex 'u' and 'v' flags cannot be used together";
             }
-            return null;
+
+            if (duplicateFlags.length > 0) {
+                return `Duplicate flags ('${duplicateFlags.join("")}') supplied to RegExp constructor`;
+            }
+
+            if (!flagsToCheck) {
+                return null;
+            }
+
+            return `Invalid flags supplied to RegExp constructor '${flagsToCheck}'`;
         }
 
         return {
@@ -154,13 +166,17 @@ module.exports = {
                     return;
                 }
 
-                let flags = getFlags(node);
+                const flags = getFlags(node);
+                let flagsToCheck = flags;
+                const allFlags = allowedFlags.length > 0 ? validFlags.split("").concat(allowedFlags) : validFlags.split("");
 
-                if (flags && allowedFlags) {
-                    flags = flags.replace(allowedFlags, "");
+                if (flags) {
+                    allFlags.forEach(flag => {
+                        flagsToCheck = flagsToCheck.replace(flag, "");
+                    });
                 }
 
-                let message = validateRegExpFlags(flags);
+                let message = validateRegExpFlags(flags, flagsToCheck, allFlags);
 
                 if (message) {
                     report(node, message);

data/node_modules/eslint/lib/rules/require-unicode-regexp.js

@@ -18,6 +18,26 @@ const {
 const astUtils = require("./utils/ast-utils.js");
 const { isValidWithUnicodeFlag } = require("./utils/regular-expressions");
 
+/**
+ * Checks whether the flag configuration should be treated as a missing flag.
+ * @param {"u"|"v"|undefined} requireFlag A particular flag to require
+ * @param {string} flags The regex flags
+ * @returns {boolean} Whether the flag configuration results in a missing flag.
+ */
+function checkFlags(requireFlag, flags) {
+    let missingFlag;
+
+    if (requireFlag === "v") {
+        missingFlag = !flags.includes("v");
+    } else if (requireFlag === "u") {
+        missingFlag = !flags.includes("u");
+    } else {
+        missingFlag = !flags.includes("u") && !flags.includes("v");
+    }
+
+    return missingFlag;
+}
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -37,31 +57,65 @@ module.exports = {
 
         messages: {
             addUFlag: "Add the 'u' flag.",
-            requireUFlag: "Use the 'u' flag."
+            addVFlag: "Add the 'v' flag.",
+            requireUFlag: "Use the 'u' flag.",
+            requireVFlag: "Use the 'v' flag."
         },
 
-        schema: []
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    requireFlag: {
+                        enum: ["u", "v"]
+                    }
+                },
+                additionalProperties: false
+            }
+        ]
     },
 
     create(context) {
 
         const sourceCode = context.sourceCode;
 
+        const {
+            requireFlag
+        } = context.options[0] ?? {};
+
         return {
             "Literal[regex]"(node) {
                 const flags = node.regex.flags || "";
 
-                if (!flags.includes("u") && !flags.includes("v")) {
+                const missingFlag = checkFlags(requireFlag, flags);
+
+                if (missingFlag) {
                     context.report({
-                        messageId: "requireUFlag",
+                        messageId: requireFlag === "v" ? "requireVFlag" : "requireUFlag",
                         node,
-                        suggest: isValidWithUnicodeFlag(context.languageOptions.ecmaVersion, node.regex.pattern)
+                        suggest: isValidWithUnicodeFlag(context.languageOptions.ecmaVersion, node.regex.pattern, requireFlag)
                             ? [
                                 {
                                     fix(fixer) {
-                                        return fixer.insertTextAfter(node, "u");
+                                        const replaceFlag = requireFlag ?? "u";
+                                        const regex = sourceCode.getText(node);
+                                        const slashPos = regex.lastIndexOf("/");
+
+                                        if (requireFlag) {
+                                            const flag = requireFlag === "u" ? "v" : "u";
+
+                                            if (regex.includes(flag, slashPos)) {
+                                                return fixer.replaceText(
+                                                    node,
+                                                    regex.slice(0, slashPos) +
+                                                    regex.slice(slashPos).replace(flag, requireFlag)
+                                                );
+                                            }
+                                        }
+
+                                        return fixer.insertTextAfter(node, replaceFlag);
                                     },
-                                    messageId: "addUFlag"
+                                    messageId: requireFlag === "v" ? "addVFlag" : "addUFlag"
                                 }
                             ]
                             : null
@@ -85,22 +139,49 @@ module.exports = {
                     const pattern = getStringIfConstant(patternNode, scope);
                     const flags = getStringIfConstant(flagsNode, scope);
 
-                    if (!flagsNode || (typeof flags === "string" && !flags.includes("u") && !flags.includes("v"))) {
+                    let missingFlag = !flagsNode;
+
+                    if (typeof flags === "string") {
+                        missingFlag = checkFlags(requireFlag, flags);
+                    }
+
+                    if (missingFlag) {
                         context.report({
-                            messageId: "requireUFlag",
+                            messageId: requireFlag === "v" ? "requireVFlag" : "requireUFlag",
                             node: refNode,
-                            suggest: typeof pattern === "string" && isValidWithUnicodeFlag(context.languageOptions.ecmaVersion, pattern)
+                            suggest: typeof pattern === "string" && isValidWithUnicodeFlag(context.languageOptions.ecmaVersion, pattern, requireFlag)
                                 ? [
                                     {
                                         fix(fixer) {
+                                            const replaceFlag = requireFlag ?? "u";
+
                                             if (flagsNode) {
                                                 if ((flagsNode.type === "Literal" && typeof flagsNode.value === "string") || flagsNode.type === "TemplateLiteral") {
                                                     const flagsNodeText = sourceCode.getText(flagsNode);
+                                                    const flag = requireFlag === "u" ? "v" : "u";
+
+                                                    if (flags.includes(flag)) {
+
+                                                        // Avoid replacing "u" in escapes like `\uXXXX`
+                                                        if (flagsNode.type === "Literal" && flagsNode.raw.includes("\\")) {
+                                                            return null;
+                                                        }
+
+                                                        // Avoid replacing "u" in expressions like "`${regularFlags}g`"
+                                                        if (flagsNode.type === "TemplateLiteral" && (
+                                                            flagsNode.expressions.length ||
+                                                            flagsNode.quasis.some(({ value: { raw } }) => raw.includes("\\"))
+                                                        )) {
+                                                            return null;
+                                                        }
+
+                                                        return fixer.replaceText(flagsNode, flagsNodeText.replace(flag, replaceFlag));
+                                                    }
 
                                                     return fixer.replaceText(flagsNode, [
                                                         flagsNodeText.slice(0, flagsNodeText.length - 1),
                                                         flagsNodeText.slice(flagsNodeText.length - 1)
-                                                    ].join("u"));
+                                                    ].join(replaceFlag));
                                                 }
 
                                                 // We intentionally don't suggest concatenating + "u" to non-literals
@@ -112,11 +193,11 @@ module.exports = {
                                             return fixer.insertTextAfter(
                                                 penultimateToken,
                                                 astUtils.isCommaToken(penultimateToken)
-                                                    ? ' "u",'
-                                                    : ', "u"'
+                                                    ? ` "${replaceFlag}",`
+                                                    : `, "${replaceFlag}"`
                                             );
                                         },
-                                        messageId: "addUFlag"
+                                        messageId: requireFlag === "v" ? "addVFlag" : "addUFlag"
                                     }
                                 ]
                                 : null

data/node_modules/eslint/lib/rules/utils/regular-expressions.js

@@ -14,12 +14,16 @@ const REGEXPP_LATEST_ECMA_VERSION = 2025;
  * Checks if the given regular expression pattern would be valid with the `u` flag.
  * @param {number} ecmaVersion ECMAScript version to parse in.
  * @param {string} pattern The regular expression pattern to verify.
+ * @param {"u"|"v"} flag The type of Unicode flag
  * @returns {boolean} `true` if the pattern would be valid with the `u` flag.
  * `false` if the pattern would be invalid with the `u` flag or the configured
  * ecmaVersion doesn't support the `u` flag.
  */
-function isValidWithUnicodeFlag(ecmaVersion, pattern) {
-    if (ecmaVersion <= 5) { // ecmaVersion <= 5 doesn't support the 'u' flag
+function isValidWithUnicodeFlag(ecmaVersion, pattern, flag = "u") {
+    if (flag === "u" && ecmaVersion <= 5) { // ecmaVersion <= 5 doesn't support the 'u' flag
+        return false;
+    }
+    if (flag === "v" && ecmaVersion <= 2023) {
         return false;
     }
 
@@ -28,7 +32,11 @@ function isValidWithUnicodeFlag(ecmaVersion, pattern) {
     });
 
     try {
-        validator.validatePattern(pattern, void 0, void 0, { unicode: /* uFlag = */ true });
+        validator.validatePattern(pattern, void 0, void 0, flag === "u" ? {
+            unicode: /* uFlag = */ true
+        } : {
+            unicodeSets: true
+        });
     } catch {
         return false;
     }