eslint 5.13.0 → 5.15.1

package/lib/rules/require-jsdoc.js

@@ -23,22 +23,28 @@ module.exports = {
                         type: "object",
                         properties: {
                             ClassDeclaration: {
-                                type: "boolean"
+                                type: "boolean",
+                                default: false
                             },
                             MethodDefinition: {
-                                type: "boolean"
+                                type: "boolean",
+                                default: false
                             },
                             FunctionDeclaration: {
-                                type: "boolean"
+                                type: "boolean",
+                                default: true
                             },
                             ArrowFunctionExpression: {
-                                type: "boolean"
+                                type: "boolean",
+                                default: false
                             },
                             FunctionExpression: {
-                                type: "boolean"
+                                type: "boolean",
+                                default: false
                             }
                         },
-                        additionalProperties: false
+                        additionalProperties: false,
+                        default: {}
                     }
                 },
                 additionalProperties: false
@@ -58,7 +64,7 @@ module.exports = {
             ArrowFunctionExpression: false,
             FunctionExpression: false
         };
-        const options = Object.assign(DEFAULT_OPTIONS, context.options[0] && context.options[0].require || {});
+        const options = Object.assign(DEFAULT_OPTIONS, context.options[0] && context.options[0].require);
 
         /**
          * Report the error message

package/lib/rules/semi-spacing.js

@@ -29,10 +29,12 @@ module.exports = {
                 type: "object",
                 properties: {
                     before: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: false
                     },
                     after: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: true
                     }
                 },
                 additionalProperties: false
@@ -48,12 +50,8 @@ module.exports = {
             requireSpaceAfter = true;
 
         if (typeof config === "object") {
-            if (Object.prototype.hasOwnProperty.call(config, "before")) {
-                requireSpaceBefore = config.before;
-            }
-            if (Object.prototype.hasOwnProperty.call(config, "after")) {
-                requireSpaceAfter = config.after;
-            }
+            requireSpaceBefore = config.before;
+            requireSpaceAfter = config.after;
         }
 
         /**

package/lib/rules/semi.js

@@ -72,11 +72,11 @@ module.exports = {
 
     create(context) {
 
-        const OPT_OUT_PATTERN = /^[-[(/+`]/; // One of [(/+-`
+        const OPT_OUT_PATTERN = /^[-[(/+`]/u; // One of [(/+-`
         const options = context.options[1];
         const never = context.options[0] === "never";
         const exceptOneLine = Boolean(options && options.omitLastInOneLineBlock);
-        const beforeStatementContinuationChars = (options && options.beforeStatementContinuationChars) || "any";
+        const beforeStatementContinuationChars = options && options.beforeStatementContinuationChars || "any";
         const sourceCode = context.getSourceCode();
 
         //--------------------------------------------------------------------------
@@ -291,7 +291,7 @@ module.exports = {
             const parent = node.parent;
 
             if ((parent.type !== "ForStatement" || parent.init !== node) &&
-                (!/^For(?:In|Of)Statement/.test(parent.type) || parent.left !== node)
+                (!/^For(?:In|Of)Statement/u.test(parent.type) || parent.left !== node)
             ) {
                 checkForSemicolon(node);
             }
@@ -318,7 +318,7 @@ module.exports = {
                 }
             },
             ExportDefaultDeclaration(node) {
-                if (!/(?:Class|Function)Declaration/.test(node.declaration.type)) {
+                if (!/(?:Class|Function)Declaration/u.test(node.declaration.type)) {
                     checkForSemicolon(node);
                 }
             }

package/lib/rules/sort-imports.js

@@ -25,7 +25,8 @@ module.exports = {
                 type: "object",
                 properties: {
                     ignoreCase: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: false
                     },
                     memberSyntaxSortOrder: {
                         type: "array",
@@ -37,10 +38,12 @@ module.exports = {
                         maxItems: 4
                     },
                     ignoreDeclarationSort: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: false
                     },
                     ignoreMemberSort: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: false
                     }
                 },
                 additionalProperties: false

package/lib/rules/sort-keys.js

@@ -90,10 +90,12 @@ module.exports = {
                 type: "object",
                 properties: {
                     caseSensitive: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: true
                     },
                     natural: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: false
                     }
                 },
                 additionalProperties: false
@@ -106,8 +108,8 @@ module.exports = {
         // Parse options.
         const order = context.options[0] || "asc";
         const options = context.options[1];
-        const insensitive = (options && options.caseSensitive) === false;
-        const natual = Boolean(options && options.natural);
+        const insensitive = options && options.caseSensitive === false;
+        const natual = options && options.natural;
         const isValidOrder = isValidOrders[
             order + (insensitive ? "I" : "") + (natual ? "N" : "")
         ];
@@ -127,8 +129,14 @@ module.exports = {
                 stack = stack.upper;
             },
 
+            SpreadElement(node) {
+                if (node.parent.type === "ObjectExpression") {
+                    stack.prevName = null;
+                }
+            },
+
             Property(node) {
-                if (node.parent.type === "ObjectPattern" || node.parent.properties.some(n => n.type === "SpreadElement")) {
+                if (node.parent.type === "ObjectPattern") {
                     return;
                 }
 

package/lib/rules/sort-vars.js

@@ -25,7 +25,8 @@ module.exports = {
                 type: "object",
                 properties: {
                     ignoreCase: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: false
                     }
                 },
                 additionalProperties: false

package/lib/rules/space-infix-ops.js

@@ -26,7 +26,8 @@ module.exports = {
                 type: "object",
                 properties: {
                     int32Hint: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: false
                     }
                 },
                 additionalProperties: false

package/lib/rules/space-unary-ops.js

@@ -32,10 +32,12 @@ module.exports = {
                 type: "object",
                 properties: {
                     words: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: true
                     },
                     nonwords: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: false
                     },
                     overrides: {
                         type: "object",
@@ -58,7 +60,7 @@ module.exports = {
     },
 
     create(context) {
-        const options = context.options && Array.isArray(context.options) && context.options[0] || { words: true, nonwords: false };
+        const options = context.options[0] || { words: true, nonwords: false };
 
         const sourceCode = context.getSourceCode();
 

package/lib/rules/spaced-comment.js

@@ -126,7 +126,7 @@ function createAlwaysStylePattern(markers, exceptions) {
     pattern += "?"; // or nothing.
     pattern += createExceptionsPattern(exceptions);
 
-    return new RegExp(pattern);
+    return new RegExp(pattern); // eslint-disable-line require-unicode-regexp
 }
 
 /**
@@ -142,7 +142,7 @@ function createAlwaysStylePattern(markers, exceptions) {
 function createNeverStylePattern(markers) {
     const pattern = `^(${markers.map(escape).join("|")})?[ \t]+`;
 
-    return new RegExp(pattern);
+    return new RegExp(pattern); // eslint-disable-line require-unicode-regexp
 }
 
 //------------------------------------------------------------------------------
@@ -215,7 +215,8 @@ module.exports = {
                                 }
                             },
                             balanced: {
-                                type: "boolean"
+                                type: "boolean",
+                                default: false
                             }
                         },
                         additionalProperties: false
@@ -249,9 +250,9 @@ module.exports = {
             // Create RegExp object for valid patterns.
             rule[type] = {
                 beginRegex: requireSpace ? createAlwaysStylePattern(markers, exceptions) : createNeverStylePattern(markers),
-                endRegex: balanced && requireSpace ? new RegExp(`${createExceptionsPattern(exceptions)}$`) : new RegExp(endNeverPattern),
+                endRegex: balanced && requireSpace ? new RegExp(`${createExceptionsPattern(exceptions)}$`) : new RegExp(endNeverPattern), // eslint-disable-line require-unicode-regexp
                 hasExceptions: exceptions.length > 0,
-                markers: new RegExp(`^(${markers.map(escape).join("|")})`)
+                markers: new RegExp(`^(${markers.map(escape).join("|")})`) // eslint-disable-line require-unicode-regexp
             };
 
             return rule;

package/lib/rules/switch-colon-spacing.js

@@ -30,8 +30,8 @@ module.exports = {
             {
                 type: "object",
                 properties: {
-                    before: { type: "boolean" },
-                    after: { type: "boolean" }
+                    before: { type: "boolean", default: false },
+                    after: { type: "boolean", default: true }
                 },
                 additionalProperties: false
             }

package/lib/rules/template-curly-spacing.js

@@ -15,8 +15,8 @@ const astUtils = require("../util/ast-utils");
 // Helpers
 //------------------------------------------------------------------------------
 
-const OPEN_PAREN = /\$\{$/;
-const CLOSE_PAREN = /^\}/;
+const OPEN_PAREN = /\$\{$/u;
+const CLOSE_PAREN = /^\}/u;
 
 //------------------------------------------------------------------------------
 // Rule Definition

package/lib/rules/use-isnan.js

@@ -30,7 +30,7 @@ module.exports = {
 
         return {
             BinaryExpression(node) {
-                if (/^(?:[<>]|[!=]=)=?$/.test(node.operator) && (node.left.name === "NaN" || node.right.name === "NaN")) {
+                if (/^(?:[<>]|[!=]=)=?$/u.test(node.operator) && (node.left.name === "NaN" || node.right.name === "NaN")) {
                     context.report({ node, messageId: "useIsNaN" });
                 }
             }

package/lib/rules/valid-jsdoc.js

@@ -42,22 +42,27 @@ module.exports = {
                         }
                     },
                     requireReturn: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: true
                     },
                     requireParamDescription: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: true
                     },
                     requireReturnDescription: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: true
                     },
                     matchDescription: {
                         type: "string"
                     },
                     requireReturnType: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: true
                     },
                     requireParamType: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: true
                     }
                 },
                 additionalProperties: false
@@ -295,7 +300,7 @@ module.exports = {
                     });
                 } catch (ex) {
 
-                    if (/braces/i.test(ex.message)) {
+                    if (/braces/iu.test(ex.message)) {
                         context.report({ node: jsdocNode, messageId: "missingBrace" });
                     } else {
                         context.report({ node: jsdocNode, messageId: "syntaxError" });
@@ -477,7 +482,7 @@ module.exports = {
                 }
 
                 if (options.matchDescription) {
-                    const regex = new RegExp(options.matchDescription);
+                    const regex = new RegExp(options.matchDescription); // eslint-disable-line require-unicode-regexp
 
                     if (!regex.test(jsdoc.description)) {
                         context.report({ node: jsdocNode, messageId: "unsatisfiedDesc" });

package/lib/rules/valid-typeof.js

@@ -24,7 +24,8 @@ module.exports = {
                 type: "object",
                 properties: {
                     requireStringLiterals: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: false
                     }
                 },
                 additionalProperties: false

package/lib/rules/vars-on-top.js

@@ -117,7 +117,7 @@ module.exports = {
          * @returns {void}
          */
         function blockScopeVarCheck(node, parent, grandParent) {
-            if (!(/Function/.test(grandParent.type) &&
+            if (!(/Function/u.test(grandParent.type) &&
                     parent.type === "BlockStatement" &&
                     isVarOnTop(node, parent.body))) {
                 context.report({ node, messageId: "top" });

package/lib/rules/wrap-iife.js

@@ -34,7 +34,8 @@ module.exports = {
                 type: "object",
                 properties: {
                     functionPrototypeMethods: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: false
                     }
                 },
                 additionalProperties: false
@@ -52,7 +53,7 @@ module.exports = {
     create(context) {
 
         const style = context.options[0] || "outside";
-        const includeFunctionPrototypeMethods = (context.options[1] && context.options[1].functionPrototypeMethods) || false;
+        const includeFunctionPrototypeMethods = context.options[1] && context.options[1].functionPrototypeMethods;
 
         const sourceCode = context.getSourceCode();
 

package/lib/rules/yoda.js

@@ -20,7 +20,7 @@ const astUtils = require("../util/ast-utils");
  * @returns {boolean} Whether or not it is a comparison operator.
  */
 function isComparisonOperator(operator) {
-    return (/^(==|===|!=|!==|<|>|<=|>=)$/).test(operator);
+    return (/^(==|===|!=|!==|<|>|<=|>=)$/u).test(operator);
 }
 
 /**
@@ -29,7 +29,7 @@ function isComparisonOperator(operator) {
  * @returns {boolean} Whether or not it is an equality operator.
  */
 function isEqualityOperator(operator) {
-    return (/^(==|===)$/).test(operator);
+    return (/^(==|===)$/u).test(operator);
 }
 
 /**
@@ -169,10 +169,12 @@ module.exports = {
                 type: "object",
                 properties: {
                     exceptRange: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: false
                     },
                     onlyEquality: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: false
                     }
                 },
                 additionalProperties: false

package/lib/util/ajv.js

@@ -17,6 +17,7 @@ const Ajv = require("ajv"),
 
 const ajv = new Ajv({
     meta: false,
+    useDefaults: true,
     validateSchema: false,
     missingRefs: "ignore",
     verbose: true,

package/lib/util/ast-utils.js

@@ -16,19 +16,19 @@ const espree = require("espree");
 // Helpers
 //------------------------------------------------------------------------------
 
-const anyFunctionPattern = /^(?:Function(?:Declaration|Expression)|ArrowFunctionExpression)$/;
-const anyLoopPattern = /^(?:DoWhile|For|ForIn|ForOf|While)Statement$/;
-const arrayOrTypedArrayPattern = /Array$/;
-const arrayMethodPattern = /^(?:every|filter|find|findIndex|forEach|map|some)$/;
-const bindOrCallOrApplyPattern = /^(?:bind|call|apply)$/;
-const breakableTypePattern = /^(?:(?:Do)?While|For(?:In|Of)?|Switch)Statement$/;
-const thisTagPattern = /^[\s*]*@this/m;
+const anyFunctionPattern = /^(?:Function(?:Declaration|Expression)|ArrowFunctionExpression)$/u;
+const anyLoopPattern = /^(?:DoWhile|For|ForIn|ForOf|While)Statement$/u;
+const arrayOrTypedArrayPattern = /Array$/u;
+const arrayMethodPattern = /^(?:every|filter|find|findIndex|forEach|map|some)$/u;
+const bindOrCallOrApplyPattern = /^(?:bind|call|apply)$/u;
+const breakableTypePattern = /^(?:(?:Do)?While|For(?:In|Of)?|Switch)Statement$/u;
+const thisTagPattern = /^[\s*]*@this/mu;
 
 
-const COMMENTS_IGNORE_PATTERN = /^\s*(?:eslint|jshint\s+|jslint\s+|istanbul\s+|globals?\s+|exported\s+|jscs)/;
+const COMMENTS_IGNORE_PATTERN = /^\s*(?:eslint|jshint\s+|jslint\s+|istanbul\s+|globals?\s+|exported\s+|jscs)/u;
 const LINEBREAKS = new Set(["\r\n", "\r", "\n", "\u2028", "\u2029"]);
-const LINEBREAK_MATCHER = /\r\n|[\r\n\u2028\u2029]/;
-const SHEBANG_MATCHER = /^#!([^\r\n]+)/;
+const LINEBREAK_MATCHER = /\r\n|[\r\n\u2028\u2029]/u;
+const SHEBANG_MATCHER = /^#!([^\r\n]+)/u;
 
 // A set of node types that can contain a list of statements
 const STATEMENT_LIST_PARENTS = new Set(["Program", "BlockStatement", "SwitchCase"]);
@@ -398,7 +398,7 @@ function getOpeningParenOfParams(node, sourceCode) {
  * @returns {RegExp} A global regular expression that matches line terminators
  */
 function createGlobalLinebreakMatcher() {
-    return new RegExp(LINEBREAK_MATCHER.source, "g");
+    return new RegExp(LINEBREAK_MATCHER.source, "gu");
 }
 
 /**
@@ -1006,7 +1006,7 @@ module.exports = {
      * '5'     // false
      */
     isDecimalInteger(node) {
-        return node.type === "Literal" && typeof node.value === "number" && /^(0|[1-9]\d*)$/.test(node.raw);
+        return node.type === "Literal" && typeof node.value === "number" && /^(0|[1-9]\d*)$/u.test(node.raw);
     },
 
     /**

package/lib/util/config-comment-parser.js

@@ -38,9 +38,9 @@ module.exports = class ConfigCommentParser {
         const items = {};
 
         // Collapse whitespace around `:` and `,` to make parsing easier
-        const trimmedString = string.replace(/\s*([:,])\s*/g, "$1");
+        const trimmedString = string.replace(/\s*([:,])\s*/gu, "$1");
 
-        trimmedString.split(/\s|,+/).forEach(name => {
+        trimmedString.split(/\s|,+/u).forEach(name => {
             if (!name) {
                 return;
             }
@@ -90,7 +90,7 @@ module.exports = class ConfigCommentParser {
          * But we are supporting that. So this is a fallback for that.
          */
         items = {};
-        const normalizedString = string.replace(/([a-zA-Z0-9\-/]+):/g, "\"$1\":").replace(/(]|[0-9])\s+(?=")/, "$1,");
+        const normalizedString = string.replace(/([a-zA-Z0-9\-/]+):/gu, "\"$1\":").replace(/(\]|[0-9])\s+(?=")/u, "$1,");
 
         try {
             items = JSON.parse(`{${normalizedString}}`);
@@ -128,7 +128,7 @@ module.exports = class ConfigCommentParser {
         const items = {};
 
         // Collapse whitespace around commas
-        string.replace(/\s*,\s*/g, ",").split(/,+/).forEach(name => {
+        string.replace(/\s*,\s*/gu, ",").split(/,+/u).forEach(name => {
             const trimmedName = name.trim();
 
             if (trimmedName) {

package/lib/util/glob-utils.js

@@ -52,7 +52,7 @@ function processPath(options) {
     const cwd = (options && options.cwd) || process.cwd();
     let extensions = (options && options.extensions) || [".js"];
 
-    extensions = extensions.map(ext => ext.replace(/^\./, ""));
+    extensions = extensions.map(ext => ext.replace(/^\./u, ""));
 
     let suffix = "/**";
 
@@ -74,7 +74,7 @@ function processPath(options) {
         const resolvedPath = path.resolve(cwd, pathname);
 
         if (directoryExists(resolvedPath)) {
-            newPath = pathname.replace(/[/\\]$/, "") + suffix;
+            newPath = pathname.replace(/[/\\]$/u, "") + suffix;
         }
 
         return pathUtils.convertPathToPosix(newPath);
@@ -169,7 +169,7 @@ function resolveFileGlobPatterns(patterns, options) {
     return patterns.map(processPathExtensions);
 }
 
-const dotfilesPattern = /(?:(?:^\.)|(?:[/\\]\.))[^/\\.].*/;
+const dotfilesPattern = /(?:(?:^\.)|(?:[/\\]\.))[^/\\.].*/u;
 
 /**
  * Build a list of absolute filesnames on which ESLint will act.

package/lib/util/ignored-paths.js

@@ -89,7 +89,7 @@ function mergeDefaultOptions(options) {
  */
 const normalizePathSeps = path.sep === "/"
     ? (str => str)
-    : ((seps, str) => str.replace(seps, "/")).bind(null, new RegExp(`\\${path.sep}`, "g"));
+    : ((seps, str) => str.replace(seps, "/")).bind(null, new RegExp(`\\${path.sep}`, "gu"));
 /* eslint-enable valid-jsdoc */
 
 /**
@@ -104,7 +104,7 @@ function relativize(globPattern, relativePathToOldBaseDir) {
     }
 
     const prefix = globPattern.startsWith("!") ? "!" : "";
-    const globWithoutPrefix = globPattern.replace(/^!/, "");
+    const globWithoutPrefix = globPattern.replace(/^!/u, "");
 
     if (globWithoutPrefix.startsWith("/")) {
         return `${prefix}/${normalizePathSeps(relativePathToOldBaseDir)}${globWithoutPrefix}`;
@@ -284,7 +284,7 @@ class IgnoredPaths {
             }
 
             // If it's only Windows drive letter, it needs \
-            if (/^[A-Z]:$/.test(this._baseDir)) {
+            if (/^[A-Z]:$/u.test(this._baseDir)) {
                 this._baseDir += "\\";
             }
 
@@ -300,7 +300,7 @@ class IgnoredPaths {
      */
     readIgnoreFile(filePath) {
         if (typeof this.cache[filePath] === "undefined") {
-            this.cache[filePath] = fs.readFileSync(filePath, "utf8").split(/\r?\n/g).filter(Boolean);
+            this.cache[filePath] = fs.readFileSync(filePath, "utf8").split(/\r?\n/gu).filter(Boolean);
         }
         return this.cache[filePath];
     }

package/lib/util/interpolate.js

@@ -15,7 +15,7 @@ module.exports = (text, data) => {
     }
 
     // Substitution content for any {{ }} markers.
-    return text.replace(/\{\{([^{}]+?)\}\}/g, (fullMatch, termWithWhitespace) => {
+    return text.replace(/\{\{([^{}]+?)\}\}/gu, (fullMatch, termWithWhitespace) => {
         const term = termWithWhitespace.trim();
 
         if (term in data) {

package/lib/util/naming.js

@@ -13,7 +13,7 @@ const pathUtils = require("../util/path-utils");
 // Private
 //------------------------------------------------------------------------------
 
-const NAMESPACE_REGEX = /^@.*\//i;
+const NAMESPACE_REGEX = /^@.*\//iu;
 
 /**
  * Brings package name to correct format based on prefix
@@ -40,8 +40,8 @@ function normalizePackageName(name, prefix) {
          * it's a scoped package
          * package name is the prefix, or just a username
          */
-        const scopedPackageShortcutRegex = new RegExp(`^(@[^/]+)(?:/(?:${prefix})?)?$`),
-            scopedPackageNameRegex = new RegExp(`^${prefix}(-|$)`);
+        const scopedPackageShortcutRegex = new RegExp(`^(@[^/]+)(?:/(?:${prefix})?)?$`, "u"),
+            scopedPackageNameRegex = new RegExp(`^${prefix}(-|$)`, "u");
 
         if (scopedPackageShortcutRegex.test(normalizedName)) {
             normalizedName = normalizedName.replace(scopedPackageShortcutRegex, `$1/${prefix}`);
@@ -51,7 +51,7 @@ function normalizePackageName(name, prefix) {
              * for scoped packages, insert the prefix after the first / unless
              * the path is already @scope/eslint or @scope/eslint-xxx-yyy
              */
-            normalizedName = normalizedName.replace(/^@([^/]+)\/(.*)$/, `@$1/${prefix}-$2`);
+            normalizedName = normalizedName.replace(/^@([^/]+)\/(.*)$/u, `@$1/${prefix}-$2`);
         }
     } else if (normalizedName.indexOf(`${prefix}-`) !== 0) {
         normalizedName = `${prefix}-${normalizedName}`;
@@ -68,13 +68,13 @@ function normalizePackageName(name, prefix) {
  */
 function getShorthandName(fullname, prefix) {
     if (fullname[0] === "@") {
-        let matchResult = new RegExp(`^(@[^/]+)/${prefix}$`).exec(fullname);
+        let matchResult = new RegExp(`^(@[^/]+)/${prefix}$`, "u").exec(fullname);
 
         if (matchResult) {
             return matchResult[1];
         }
 
-        matchResult = new RegExp(`^(@[^/]+)/${prefix}-(.+)$`).exec(fullname);
+        matchResult = new RegExp(`^(@[^/]+)/${prefix}-(.+)$`, "u").exec(fullname);
         if (matchResult) {
             return `${matchResult[1]}/${matchResult[2]}`;
         }

package/lib/util/node-event-generator.js

@@ -157,7 +157,7 @@ function compareSpecificity(selectorA, selectorB) {
  */
 function tryParseSelector(rawSelector) {
     try {
-        return esquery.parse(rawSelector.replace(/:exit$/, ""));
+        return esquery.parse(rawSelector.replace(/:exit$/u, ""));
     } catch (err) {
         if (typeof err.offset === "number") {
             throw new SyntaxError(`Syntax error in selector "${rawSelector}" at position ${err.offset}: ${err.message}`);