eslint 5.14.1 → 5.15.3

package/lib/rules/max-nested-callbacks.js

@@ -32,13 +32,11 @@ module.exports = {
                         properties: {
                             maximum: {
                                 type: "integer",
-                                minimum: 0,
-                                default: 10
+                                minimum: 0
                             },
                             max: {
                                 type: "integer",
-                                minimum: 0,
-                                default: 10
+                                minimum: 0
                             }
                         },
                         additionalProperties: false
@@ -59,7 +57,10 @@ module.exports = {
         const option = context.options[0];
         let THRESHOLD = 10;
 
-        if (typeof option === "object") {
+        if (
+            typeof option === "object" &&
+            (Object.prototype.hasOwnProperty.call(option, "maximum") || Object.prototype.hasOwnProperty.call(option, "max"))
+        ) {
             THRESHOLD = option.maximum || option.max;
         } else if (typeof option === "number") {
             THRESHOLD = option;

package/lib/rules/max-params.js

@@ -40,13 +40,11 @@ module.exports = {
                         properties: {
                             maximum: {
                                 type: "integer",
-                                minimum: 0,
-                                default: 3
+                                minimum: 0
                             },
                             max: {
                                 type: "integer",
-                                minimum: 0,
-                                default: 3
+                                minimum: 0
                             }
                         },
                         additionalProperties: false
@@ -64,7 +62,10 @@ module.exports = {
         const option = context.options[0];
         let numParams = 3;
 
-        if (typeof option === "object") {
+        if (
+            typeof option === "object" &&
+            (Object.prototype.hasOwnProperty.call(option, "maximum") || Object.prototype.hasOwnProperty.call(option, "max"))
+        ) {
             numParams = option.maximum || option.max;
         }
         if (typeof option === "number") {

package/lib/rules/max-statements-per-line.js

@@ -57,7 +57,7 @@ module.exports = {
         // Helpers
         //--------------------------------------------------------------------------
 
-        const SINGLE_CHILD_ALLOWED = /^(?:(?:DoWhile|For|ForIn|ForOf|If|Labeled|While)Statement|Export(?:Default|Named)Declaration)$/;
+        const SINGLE_CHILD_ALLOWED = /^(?:(?:DoWhile|For|ForIn|ForOf|If|Labeled|While)Statement|Export(?:Default|Named)Declaration)$/u;
 
         /**
          * Reports with the first extra statement, and clears it.

package/lib/rules/max-statements.js

@@ -40,13 +40,11 @@ module.exports = {
                         properties: {
                             maximum: {
                                 type: "integer",
-                                minimum: 0,
-                                default: 10
+                                minimum: 0
                             },
                             max: {
                                 type: "integer",
-                                minimum: 0,
-                                default: 10
+                                minimum: 0
                             }
                         },
                         additionalProperties: false
@@ -80,7 +78,10 @@ module.exports = {
             topLevelFunctions = [];
         let maxStatements = 10;
 
-        if (typeof option === "object") {
+        if (
+            typeof option === "object" &&
+            (Object.prototype.hasOwnProperty.call(option, "maximum") || Object.prototype.hasOwnProperty.call(option, "max"))
+        ) {
             maxStatements = option.maximum || option.max;
         } else if (typeof option === "number") {
             maxStatements = option;

package/lib/rules/multiline-comment-style.js

@@ -52,7 +52,7 @@ module.exports = {
             }
             return commentGroup[0].value
                 .split(astUtils.LINEBREAK_MATCHER)
-                .map(line => line.replace(/^\s*\*?/, ""));
+                .map(line => line.replace(/^\s*\*?/u, ""));
         }
 
         /**
@@ -103,9 +103,9 @@ module.exports = {
             const lines = commentGroup[0].value.split(astUtils.LINEBREAK_MATCHER);
 
             return commentGroup[0].type === "Block" &&
-                /^\*\s*$/.test(lines[0]) &&
-                lines.slice(1, -1).every(line => /^\s* /.test(line)) &&
-                /^\s*$/.test(lines[lines.length - 1]);
+                /^\*\s*$/u.test(lines[0]) &&
+                lines.slice(1, -1).every(line => /^\s* /u.test(line)) &&
+                /^\s*$/u.test(lines[lines.length - 1]);
         }
 
         /**
@@ -143,7 +143,7 @@ module.exports = {
                     const lines = block.value.split(astUtils.LINEBREAK_MATCHER);
                     const expectedLinePrefix = `${sourceCode.text.slice(block.range[0] - block.loc.start.column, block.range[0])} *`;
 
-                    if (!/^\*?\s*$/.test(lines[0])) {
+                    if (!/^\*?\s*$/u.test(lines[0])) {
                         const start = block.value.startsWith("*") ? block.range[0] + 1 : block.range[0];
 
                         context.report({
@@ -156,7 +156,7 @@ module.exports = {
                         });
                     }
 
-                    if (!/^\s*$/.test(lines[lines.length - 1])) {
+                    if (!/^\s*$/u.test(lines[lines.length - 1])) {
                         context.report({
                             loc: {
                                 start: { line: block.loc.end.line, column: block.loc.end.column - 2 },
@@ -176,12 +176,12 @@ module.exports = {
                                     start: { line: lineNumber, column: 0 },
                                     end: { line: lineNumber, column: sourceCode.lines[lineNumber - 1].length }
                                 },
-                                messageId: /^\s*\*/.test(lineText)
+                                messageId: /^\s*\*/u.test(lineText)
                                     ? "alignment"
                                     : "missingStar",
                                 fix(fixer) {
                                     const lineStartIndex = sourceCode.getIndexFromLoc({ line: lineNumber, column: 0 });
-                                    const linePrefixLength = lineText.match(/^\s*\*? ?/)[0].length;
+                                    const linePrefixLength = lineText.match(/^\s*\*? ?/u)[0].length;
                                     const commentStartIndex = lineStartIndex + linePrefixLength;
 
                                     const replacementText = lineNumber === block.loc.end.line || lineText.length === linePrefixLength
@@ -244,7 +244,7 @@ module.exports = {
                         const block = commentGroup[0];
                         const lines = block.value.split(astUtils.LINEBREAK_MATCHER).filter(line => line.trim());
 
-                        if (lines.length > 0 && lines.every(line => /^\s*\*/.test(line))) {
+                        if (lines.length > 0 && lines.every(line => /^\s*\*/u.test(line))) {
                             context.report({
                                 loc: {
                                     start: block.loc.start,

package/lib/rules/new-cap.js

@@ -136,10 +136,10 @@ module.exports = {
         const skipProperties = config.properties === false;
 
         const newIsCapExceptions = checkArray(config, "newIsCapExceptions", []).reduce(invert, {});
-        const newIsCapExceptionPattern = config.newIsCapExceptionPattern ? new RegExp(config.newIsCapExceptionPattern) : null;
+        const newIsCapExceptionPattern = config.newIsCapExceptionPattern ? new RegExp(config.newIsCapExceptionPattern) : null; // eslint-disable-line require-unicode-regexp
 
         const capIsNewExceptions = calculateCapIsNewExceptions(config);
-        const capIsNewExceptionPattern = config.capIsNewExceptionPattern ? new RegExp(config.capIsNewExceptionPattern) : null;
+        const capIsNewExceptionPattern = config.capIsNewExceptionPattern ? new RegExp(config.capIsNewExceptionPattern) : null; // eslint-disable-line require-unicode-regexp
 
         const listeners = {};
 

package/lib/rules/no-alert.js

@@ -20,7 +20,7 @@ const getPropertyName = require("../util/ast-utils").getStaticPropertyName;
  * @returns {boolean} Whether or not the name is prohibited.
  */
 function isProhibitedIdentifier(name) {
-    return /^(alert|confirm|prompt)$/.test(name);
+    return /^(alert|confirm|prompt)$/u.test(name);
 }
 
 /**

package/lib/rules/no-caller.js

@@ -35,7 +35,7 @@ module.exports = {
                 const objectName = node.object.name,
                     propertyName = node.property.name;
 
-                if (objectName === "arguments" && !node.computed && propertyName && propertyName.match(/^calle[er]$/)) {
+                if (objectName === "arguments" && !node.computed && propertyName && propertyName.match(/^calle[er]$/u)) {
                     context.report({ node, messageId: "unexpected", data: { prop: propertyName } });
                 }
 

package/lib/rules/no-dupe-keys.js

@@ -15,8 +15,8 @@ const astUtils = require("../util/ast-utils");
 // Helpers
 //------------------------------------------------------------------------------
 
-const GET_KIND = /^(?:init|get)$/;
-const SET_KIND = /^(?:init|set)$/;
+const GET_KIND = /^(?:init|get)$/u;
+const SET_KIND = /^(?:init|set)$/u;
 
 /**
  * The class which stores properties' information of an object.

package/lib/rules/no-else-return.js

@@ -82,7 +82,7 @@ module.exports = {
                      * after the if block
                      */
                     const ifBlockMaybeUnsafe = node.parent.consequent.type !== "BlockStatement" && lastIfToken.value !== ";";
-                    const elseBlockUnsafe = /^[([/+`-]/.test(firstTokenOfElseBlock.value);
+                    const elseBlockUnsafe = /^[([/+`-]/u.test(firstTokenOfElseBlock.value);
 
                     if (ifBlockMaybeUnsafe && elseBlockUnsafe) {
                         return null;
@@ -94,7 +94,7 @@ module.exports = {
                     if (lastTokenOfElseBlock.value !== ";") {
                         const nextToken = sourceCode.getTokenAfter(endToken);
 
-                        const nextTokenUnsafe = nextToken && /^[([/+`-]/.test(nextToken.value);
+                        const nextTokenUnsafe = nextToken && /^[([/+`-]/u.test(nextToken.value);
                         const nextTokenOnSameLine = nextToken && nextToken.loc.start.line === lastTokenOfElseBlock.loc.start.line;
 
                         /*

package/lib/rules/no-empty-character-class.js

@@ -21,7 +21,7 @@
  * 4. `[gimuy]*`: optional regexp flags
  * 5. `$`: fix the match at the end of the string
  */
-const regex = /^\/([^\\[]|\\.|\[([^\\\]]|\\.)+])*\/[gimuys]*$/;
+const regex = /^\/([^\\[]|\\.|\[([^\\\]]|\\.)+\])*\/[gimuys]*$/u;
 
 //------------------------------------------------------------------------------
 // Rule Definition

package/lib/rules/no-extra-parens.js

@@ -44,11 +44,11 @@ module.exports = {
                         {
                             type: "object",
                             properties: {
-                                conditionalAssign: { type: "boolean", default: true },
-                                nestedBinaryExpressions: { type: "boolean", default: true },
-                                returnAssign: { type: "boolean", default: true },
+                                conditionalAssign: { type: "boolean" },
+                                nestedBinaryExpressions: { type: "boolean" },
+                                returnAssign: { type: "boolean" },
                                 ignoreJSX: { enum: ["none", "all", "single-line", "multi-line"] },
-                                enforceForArrowConditionals: { type: "boolean", default: true }
+                                enforceForArrowConditionals: { type: "boolean" }
                             },
                             additionalProperties: false
                         }
@@ -471,6 +471,7 @@ module.exports = {
             const firstToken = isParenthesised(node) ? sourceCode.getTokenBefore(node) : sourceCode.getFirstToken(node);
             const secondToken = sourceCode.getTokenAfter(firstToken, astUtils.isNotOpeningParenToken);
             const thirdToken = secondToken ? sourceCode.getTokenAfter(secondToken) : null;
+            const tokenAfterClosingParens = secondToken ? sourceCode.getTokenAfter(secondToken, astUtils.isNotClosingParenToken) : null;
 
             if (
                 astUtils.isOpeningParenToken(firstToken) &&
@@ -479,7 +480,12 @@ module.exports = {
                     secondToken.type === "Keyword" && (
                         secondToken.value === "function" ||
                         secondToken.value === "class" ||
-                        secondToken.value === "let" && astUtils.isOpeningBracketToken(sourceCode.getTokenAfter(secondToken, astUtils.isNotClosingParenToken))
+                        secondToken.value === "let" &&
+                            tokenAfterClosingParens &&
+                            (
+                                astUtils.isOpeningBracketToken(tokenAfterClosingParens) ||
+                                tokenAfterClosingParens.type === "Identifier"
+                            )
                     ) ||
                     secondToken && secondToken.type === "Identifier" && secondToken.value === "async" && thirdToken && thirdToken.type === "Keyword" && thirdToken.value === "function"
                 )

package/lib/rules/no-fallthrough.js

@@ -14,7 +14,7 @@ const lodash = require("lodash");
 // Helpers
 //------------------------------------------------------------------------------
 
-const DEFAULT_FALLTHROUGH_COMMENT = /falls?\s?through/i;
+const DEFAULT_FALLTHROUGH_COMMENT = /falls?\s?through/iu;
 
 /**
  * Checks whether or not a given node has a fallthrough comment.
@@ -95,7 +95,7 @@ module.exports = {
         let fallthroughCommentPattern = null;
 
         if (options.commentPattern) {
-            fallthroughCommentPattern = new RegExp(options.commentPattern);
+            fallthroughCommentPattern = new RegExp(options.commentPattern); // eslint-disable-line require-unicode-regexp
         } else {
             fallthroughCommentPattern = DEFAULT_FALLTHROUGH_COMMENT;
         }

package/lib/rules/no-implicit-coercion.js

@@ -11,7 +11,7 @@ const astUtils = require("../util/ast-utils");
 // Helpers
 //------------------------------------------------------------------------------
 
-const INDEX_OF_PATTERN = /^(?:i|lastI)ndexOf$/;
+const INDEX_OF_PATTERN = /^(?:i|lastI)ndexOf$/u;
 const ALLOWABLE_OPERATORS = ["~", "!!", "+", "*"];
 
 /**

package/lib/rules/no-implied-eval.js

@@ -24,7 +24,7 @@ module.exports = {
     },
 
     create(context) {
-        const CALLEE_RE = /^(setTimeout|setInterval|execScript)$/;
+        const CALLEE_RE = /^(setTimeout|setInterval|execScript)$/u;
 
         /*
          * Figures out if we should inspect a given binary expression. Is a stack

package/lib/rules/no-invalid-regexp.js

@@ -10,7 +10,7 @@
 
 const RegExpValidator = require("regexpp").RegExpValidator;
 const validator = new RegExpValidator({ ecmaVersion: 2018 });
-const validFlags = /[gimuys]/g;
+const validFlags = /[gimuys]/gu;
 const undefined1 = void 0;
 
 //------------------------------------------------------------------------------
@@ -51,7 +51,7 @@ module.exports = {
             const temp = options.allowConstructorFlags.join("").replace(validFlags, "");
 
             if (temp) {
-                allowedFlags = new RegExp(`[${temp}]`, "gi");
+                allowedFlags = new RegExp(`[${temp}]`, "giu");
             }
         }
 

package/lib/rules/no-irregular-whitespace.js

@@ -16,9 +16,9 @@ const astUtils = require("../util/ast-utils");
 // Constants
 //------------------------------------------------------------------------------
 
-const ALL_IRREGULARS = /[\f\v\u0085\ufeff\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u202f\u205f\u3000\u2028\u2029]/;
-const IRREGULAR_WHITESPACE = /[\f\v\u0085\ufeff\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u202f\u205f\u3000]+/mg;
-const IRREGULAR_LINE_TERMINATORS = /[\u2028\u2029]/mg;
+const ALL_IRREGULARS = /[\f\v\u0085\ufeff\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u202f\u205f\u3000\u2028\u2029]/u;
+const IRREGULAR_WHITESPACE = /[\f\v\u0085\ufeff\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u202f\u205f\u3000]+/mgu;
+const IRREGULAR_LINE_TERMINATORS = /[\u2028\u2029]/mgu;
 const LINE_BREAK = astUtils.createGlobalLinebreakMatcher();
 
 //------------------------------------------------------------------------------

package/lib/rules/no-lonely-if.js

@@ -58,7 +58,7 @@ module.exports = {
                                 node.consequent.type !== "BlockStatement" && lastIfToken.value !== ";" && tokenAfterElseBlock &&
                                 (
                                     node.consequent.loc.end.line === tokenAfterElseBlock.loc.start.line ||
-                                    /^[([/+`-]/.test(tokenAfterElseBlock.value) ||
+                                    /^[([/+`-]/u.test(tokenAfterElseBlock.value) ||
                                     lastIfToken.value === "++" ||
                                     lastIfToken.value === "--"
                                 )

package/lib/rules/no-mixed-operators.js

@@ -34,7 +34,7 @@ const DEFAULT_GROUPS = [
     LOGICAL_OPERATORS,
     RELATIONAL_OPERATORS
 ];
-const TARGET_NODE_TYPE = /^(?:Binary|Logical)Expression$/;
+const TARGET_NODE_TYPE = /^(?:Binary|Logical)Expression$/u;
 
 /**
  * Normalizes options.

package/lib/rules/no-mixed-requires.js

@@ -30,12 +30,10 @@ module.exports = {
                         type: "object",
                         properties: {
                             grouping: {
-                                type: "boolean",
-                                default: false
+                                type: "boolean"
                             },
                             allowCall: {
-                                type: "boolean",
-                                default: false
+                                type: "boolean"
                             }
                         },
                         additionalProperties: false
@@ -158,7 +156,7 @@ module.exports = {
                 // "var fs = require('fs');"
                 return REQ_CORE;
             }
-            if (/^\.{0,2}\//.test(arg.value)) {
+            if (/^\.{0,2}\//u.test(arg.value)) {
 
                 // "var utils = require('./utils');"
                 return REQ_FILE;

package/lib/rules/no-mixed-spaces-and-tabs.js

@@ -88,7 +88,7 @@ module.exports = {
                  * or the reverse before non-tab/-space
                  * characters begin.
                  */
-                let regex = /^(?=[\t ]*(\t | \t))/;
+                let regex = /^(?=[\t ]*(\t | \t))/u;
                 const lines = sourceCode.lines,
                     comments = sourceCode.getAllComments();
 
@@ -114,7 +114,7 @@ module.exports = {
                      * At least one space followed by a tab
                      * before non-tab/-space characters begin.
                      */
-                    regex = /^(?=[\t ]* \t)/;
+                    regex = /^(?=[\t ]* \t)/u;
                 }
 
                 lines.forEach((line, i) => {

package/lib/rules/no-octal-escape.js

@@ -32,7 +32,7 @@ module.exports = {
                     return;
                 }
 
-                const match = node.raw.match(/^([^\\]|\\[^0-7])*\\([0-3][0-7]{1,2}|[4-7][0-7]|[0-7])/);
+                const match = node.raw.match(/^([^\\]|\\[^0-7])*\\([0-3][0-7]{1,2}|[4-7][0-7]|[0-7])/u);
 
                 if (match) {
                     const octalDigit = match[2];

package/lib/rules/no-octal.js

@@ -28,7 +28,7 @@ module.exports = {
         return {
 
             Literal(node) {
-                if (typeof node.value === "number" && /^0[0-7]/.test(node.raw)) {
+                if (typeof node.value === "number" && /^0[0-7]/u.test(node.raw)) {
                     context.report({ node, message: "Octal literals should not be used." });
                 }
             }

package/lib/rules/no-param-reassign.js

@@ -8,7 +8,7 @@
 // Rule Definition
 //------------------------------------------------------------------------------
 
-const stopNodePattern = /(?:Statement|Declaration|Function(?:Expression)?|Program)$/;
+const stopNodePattern = /(?:Statement|Declaration|Function(?:Expression)?|Program)$/u;
 
 module.exports = {
     meta: {

package/lib/rules/no-path-concat.js

@@ -24,7 +24,7 @@ module.exports = {
 
     create(context) {
 
-        const MATCHER = /^__(?:dir|file)name$/;
+        const MATCHER = /^__(?:dir|file)name$/u;
 
         //--------------------------------------------------------------------------
         // Public

package/lib/rules/no-regex-spaces.js

@@ -39,7 +39,7 @@ module.exports = {
          * @private
          */
         function checkRegex(node, value, valueStart) {
-            const multipleSpacesRegex = /( {2,})( [+*{?]|[^+*{?]|$)/,
+            const multipleSpacesRegex = /( {2,})( [+*{?]|[^+*{?]|$)/u,
                 regexResults = multipleSpacesRegex.exec(value);
 
             if (regexResults !== null) {

package/lib/rules/no-return-assign.js

@@ -14,7 +14,7 @@ const astUtils = require("../util/ast-utils");
 // Helpers
 //------------------------------------------------------------------------------
 
-const SENTINEL_TYPE = /^(?:[a-zA-Z]+?Statement|ArrowFunctionExpression|FunctionExpression|ClassExpression)$/;
+const SENTINEL_TYPE = /^(?:[a-zA-Z]+?Statement|ArrowFunctionExpression|FunctionExpression|ClassExpression)$/u;
 
 //------------------------------------------------------------------------------
 // Rule Definition

package/lib/rules/no-self-assign.js

@@ -15,7 +15,7 @@ const astUtils = require("../util/ast-utils");
 // Helpers
 //------------------------------------------------------------------------------
 
-const SPACES = /\s+/g;
+const SPACES = /\s+/gu;
 
 /**
  * Checks whether the property of 2 given member expression nodes are the same

package/lib/rules/no-tabs.js

@@ -9,8 +9,8 @@
 // Helpers
 //------------------------------------------------------------------------------
 
-const tabRegex = /\t+/g;
-const anyNonWhitespaceRegex = /\S/;
+const tabRegex = /\t+/gu;
+const anyNonWhitespaceRegex = /\S/u;
 
 //------------------------------------------------------------------------------
 // Public Interface

package/lib/rules/no-template-curly-in-string.js

@@ -23,7 +23,7 @@ module.exports = {
     },
 
     create(context) {
-        const regex = /\$\{[^}]+\}/;
+        const regex = /\$\{[^}]+\}/u;
 
         return {
             Literal(node) {

package/lib/rules/no-trailing-spaces.js

@@ -111,8 +111,8 @@ module.exports = {
                  * fetch the source code and do matching via regexps.
                  */
 
-                const re = new RegExp(NONBLANK),
-                    skipMatch = new RegExp(SKIP_BLANK),
+                const re = new RegExp(NONBLANK, "u"),
+                    skipMatch = new RegExp(SKIP_BLANK, "u"),
                     lines = sourceCode.lines,
                     linebreaks = sourceCode.getText().match(astUtils.createGlobalLinebreakMatcher()),
                     comments = sourceCode.getAllComments(),

package/lib/rules/no-unexpected-multiline.js

@@ -36,7 +36,7 @@ module.exports = {
 
     create(context) {
 
-        const REGEX_FLAG_MATCHER = /^[gimsuy]+$/;
+        const REGEX_FLAG_MATCHER = /^[gimsuy]+$/u;
 
         const sourceCode = context.getSourceCode();
 

package/lib/rules/no-unmodified-loop-condition.js

@@ -16,11 +16,11 @@ const Traverser = require("../util/traverser"),
 // Helpers
 //------------------------------------------------------------------------------
 
-const SENTINEL_PATTERN = /(?:(?:Call|Class|Function|Member|New|Yield)Expression|Statement|Declaration)$/;
-const LOOP_PATTERN = /^(?:DoWhile|For|While)Statement$/; // for-in/of statements don't have `test` property.
-const GROUP_PATTERN = /^(?:BinaryExpression|ConditionalExpression)$/;
-const SKIP_PATTERN = /^(?:ArrowFunction|Class|Function)Expression$/;
-const DYNAMIC_PATTERN = /^(?:Call|Member|New|TaggedTemplate|Yield)Expression$/;
+const SENTINEL_PATTERN = /(?:(?:Call|Class|Function|Member|New|Yield)Expression|Statement|Declaration)$/u;
+const LOOP_PATTERN = /^(?:DoWhile|For|While)Statement$/u; // for-in/of statements don't have `test` property.
+const GROUP_PATTERN = /^(?:BinaryExpression|ConditionalExpression)$/u;
+const SKIP_PATTERN = /^(?:ArrowFunction|Class|Function)Expression$/u;
+const DYNAMIC_PATTERN = /^(?:Call|Member|New|TaggedTemplate|Yield)Expression$/u;
 
 /**
  * @typedef {Object} LoopConditionInfo

package/lib/rules/no-unsafe-finally.js

@@ -9,9 +9,9 @@
 // Helpers
 //------------------------------------------------------------------------------
 
-const SENTINEL_NODE_TYPE_RETURN_THROW = /^(?:Program|(?:Function|Class)(?:Declaration|Expression)|ArrowFunctionExpression)$/;
-const SENTINEL_NODE_TYPE_BREAK = /^(?:Program|(?:Function|Class)(?:Declaration|Expression)|ArrowFunctionExpression|DoWhileStatement|WhileStatement|ForOfStatement|ForInStatement|ForStatement|SwitchStatement)$/;
-const SENTINEL_NODE_TYPE_CONTINUE = /^(?:Program|(?:Function|Class)(?:Declaration|Expression)|ArrowFunctionExpression|DoWhileStatement|WhileStatement|ForOfStatement|ForInStatement|ForStatement)$/;
+const SENTINEL_NODE_TYPE_RETURN_THROW = /^(?:Program|(?:Function|Class)(?:Declaration|Expression)|ArrowFunctionExpression)$/u;
+const SENTINEL_NODE_TYPE_BREAK = /^(?:Program|(?:Function|Class)(?:Declaration|Expression)|ArrowFunctionExpression|DoWhileStatement|WhileStatement|ForOfStatement|ForInStatement|ForStatement|SwitchStatement)$/u;
+const SENTINEL_NODE_TYPE_CONTINUE = /^(?:Program|(?:Function|Class)(?:Declaration|Expression)|ArrowFunctionExpression|DoWhileStatement|WhileStatement|ForOfStatement|ForInStatement|ForStatement)$/u;
 
 
 //------------------------------------------------------------------------------

package/lib/rules/no-unused-expressions.js

@@ -88,7 +88,7 @@ module.exports = {
                 grandparent = ancestors[ancestors.length - 2];
 
             return (parent.type === "Program" || parent.type === "BlockStatement" &&
-                    (/Function/.test(grandparent.type))) &&
+                    (/Function/u.test(grandparent.type))) &&
                     directives(parent).indexOf(node) >= 0;
         }
 
@@ -116,7 +116,7 @@ module.exports = {
                 return true;
             }
 
-            return /^(?:Assignment|Call|New|Update|Yield|Await)Expression$/.test(node.type) ||
+            return /^(?:Assignment|Call|New|Update|Yield|Await)Expression$/u.test(node.type) ||
                 (node.type === "UnaryExpression" && ["delete", "void"].indexOf(node.operator) >= 0);
         }