eslint 4.18.0 → 4.19.1

package/lib/load-rules.js

@@ -20,16 +20,15 @@ const rulesDirCache = {};
 
 /**
  * Load all rule modules from specified directory.
- * @param {string} [rulesDir] Path to rules directory, may be relative. Defaults to `lib/rules`.
+ * @param {string} [relativeRulesDir] Path to rules directory, may be relative. Defaults to `lib/rules`.
  * @param {string} cwd Current working directory
  * @returns {Object} Loaded rule modules by rule ids (file names).
  */
-module.exports = function(rulesDir, cwd) {
-    if (!rulesDir) {
-        rulesDir = path.join(__dirname, "rules");
-    } else {
-        rulesDir = path.resolve(cwd, rulesDir);
-    }
+module.exports = function(relativeRulesDir, cwd) {
+
+    const rulesDir = relativeRulesDir
+        ? path.resolve(cwd, relativeRulesDir)
+        : path.join(__dirname, "rules");
 
     // cache will help performance as IO operation are expensive
     if (rulesDirCache[rulesDir]) {

package/lib/rules/accessor-pairs.js

@@ -58,11 +58,11 @@ function isPropertyDescriptor(node) {
      * Object.defineProperties(obj, {foo: {set: ...}})
      * Object.create(proto, {foo: {set: ...}})
      */
-    node = node.parent.parent;
+    const grandparent = node.parent.parent;
 
-    return node.type === "ObjectExpression" && (
-        isArgumentOfMethodCall(node, 1, "Object", "create") ||
-        isArgumentOfMethodCall(node, 1, "Object", "defineProperties")
+    return grandparent.type === "ObjectExpression" && (
+        isArgumentOfMethodCall(grandparent, 1, "Object", "create") ||
+        isArgumentOfMethodCall(grandparent, 1, "Object", "defineProperties")
     );
 }
 

package/lib/rules/array-callback-return.js

@@ -71,8 +71,10 @@ function isTargetMethod(node) {
  * @returns {boolean} `true` if the node is the callback of an array method.
  */
 function isCallbackOfArrayMethod(node) {
-    while (node) {
-        const parent = node.parent;
+    let currentNode = node;
+
+    while (currentNode) {
+        const parent = currentNode.parent;
 
         switch (parent.type) {
 
@@ -82,7 +84,7 @@ function isCallbackOfArrayMethod(node) {
              */
             case "LogicalExpression":
             case "ConditionalExpression":
-                node = parent;
+                currentNode = parent;
                 break;
 
             /*
@@ -99,7 +101,7 @@ function isCallbackOfArrayMethod(node) {
                 if (func === null || !astUtils.isCallee(func)) {
                     return false;
                 }
-                node = func.parent;
+                currentNode = func.parent;
                 break;
             }
 
@@ -112,13 +114,13 @@ function isCallbackOfArrayMethod(node) {
                 if (astUtils.isArrayFromMethod(parent.callee)) {
                     return (
                         parent.arguments.length >= 2 &&
-                        parent.arguments[1] === node
+                        parent.arguments[1] === currentNode
                     );
                 }
                 if (isTargetMethod(parent.callee)) {
                     return (
                         parent.arguments.length >= 1 &&
-                        parent.arguments[0] === node
+                        parent.arguments[0] === currentNode
                     );
                 }
                 return false;

package/lib/rules/array-element-newline.js

@@ -59,16 +59,16 @@ module.exports = {
         /**
          * Normalizes a given option value.
          *
-         * @param {string|Object|undefined} option - An option value to parse.
+         * @param {string|Object|undefined} providedOption - An option value to parse.
          * @returns {{multiline: boolean, minItems: number}} Normalized option object.
          */
-        function normalizeOptionValue(option) {
+        function normalizeOptionValue(providedOption) {
             let multiline = false;
             let minItems;
 
-            option = option || "always";
+            const option = providedOption || "always";
 
-            if (option === "always" || option.minItems === 0) {
+            if (!option || option === "always" || option.minItems === 0) {
                 minItems = 0;
             } else if (option === "never") {
                 minItems = Number.POSITIVE_INFINITY;

package/lib/rules/curly.js

@@ -137,12 +137,14 @@ module.exports = {
                     return true;
                 }
 
-                node = node.consequent.body[0];
-                while (node) {
-                    if (node.type === "IfStatement" && !node.alternate) {
+                for (
+                    let currentNode = node.consequent.body[0];
+                    currentNode;
+                    currentNode = astUtils.getTrailingStatement(currentNode)
+                ) {
+                    if (currentNode.type === "IfStatement" && !currentNode.alternate) {
                         return true;
                     }
-                    node = astUtils.getTrailingStatement(node);
                 }
             }
 
@@ -311,14 +313,13 @@ module.exports = {
         function prepareIfChecks(node) {
             const preparedChecks = [];
 
-            do {
-                preparedChecks.push(prepareCheck(node, node.consequent, "if", { condition: true }));
-                if (node.alternate && node.alternate.type !== "IfStatement") {
-                    preparedChecks.push(prepareCheck(node, node.alternate, "else"));
+            for (let currentNode = node; currentNode; currentNode = currentNode.alternate) {
+                preparedChecks.push(prepareCheck(currentNode, currentNode.consequent, "if", { condition: true }));
+                if (currentNode.alternate && currentNode.alternate.type !== "IfStatement") {
+                    preparedChecks.push(prepareCheck(currentNode, currentNode.alternate, "else"));
                     break;
                 }
-                node = node.alternate;
-            } while (node);
+            }
 
             if (consistent) {
 

package/lib/rules/generator-star-spacing.js

@@ -85,7 +85,6 @@ module.exports = {
         }
 
         const modes = (function(option) {
-            option = option || {};
             const defaults = optionToDefinition(option, optionDefinitions.before);
 
             return {
@@ -93,7 +92,7 @@ module.exports = {
                 anonymous: optionToDefinition(option.anonymous, defaults),
                 method: optionToDefinition(option.method, defaults)
             };
-        }(context.options[0]));
+        }(context.options[0] || {}));
 
         const sourceCode = context.getSourceCode();
 

package/lib/rules/indent-legacy.js

@@ -505,12 +505,9 @@ module.exports = {
          */
         function getParentNodeByType(node, type, stopAtList) {
             let parent = node.parent;
+            const stopAtSet = new Set(stopAtList || ["Program"]);
 
-            if (!stopAtList) {
-                stopAtList = ["Program"];
-            }
-
-            while (parent.type !== type && stopAtList.indexOf(parent.type) === -1 && parent.type !== "Program") {
+            while (parent.type !== type && !stopAtSet.has(parent.type) && parent.type !== "Program") {
                 parent = parent.parent;
             }
 
@@ -941,19 +938,19 @@ module.exports = {
         /**
          * Returns the expected indentation for the case statement
          * @param {ASTNode} node node to examine
-         * @param {int} [switchIndent] indent for switch statement
+         * @param {int} [providedSwitchIndent] indent for switch statement
          * @returns {int} indent size
          */
-        function expectedCaseIndent(node, switchIndent) {
+        function expectedCaseIndent(node, providedSwitchIndent) {
             const switchNode = (node.type === "SwitchStatement") ? node : node.parent;
+            const switchIndent = typeof providedSwitchIndent === "undefined"
+                ? getNodeIndent(switchNode).goodChar
+                : providedSwitchIndent;
             let caseIndent;
 
             if (caseIndentStore[switchNode.loc.start.line]) {
                 return caseIndentStore[switchNode.loc.start.line];
             }
-            if (typeof switchIndent === "undefined") {
-                switchIndent = getNodeIndent(switchNode).goodChar;
-            }
 
             if (switchNode.cases.length > 0 && options.SwitchCase === 0) {
                 caseIndent = switchIndent;

package/lib/rules/indent.js

@@ -779,6 +779,19 @@ module.exports = {
             return (statement.type === "ExpressionStatement" || statement.type === "VariableDeclaration") && statement.parent.type === "Program";
         }
 
+        /**
+         * Counts the number of linebreaks that follow the last non-whitespace character in a string
+         * @param {string} string The string to check
+         * @returns {number} The number of JavaScript linebreaks that follow the last non-whitespace character,
+         * or the total number of linebreaks if the string is all whitespace.
+         */
+        function countTrailingLinebreaks(string) {
+            const trailingWhitespace = string.match(/\s*$/)[0];
+            const linebreakMatches = trailingWhitespace.match(astUtils.createGlobalLinebreakMatcher());
+
+            return linebreakMatches === null ? 0 : linebreakMatches.length;
+        }
+
         /**
          * Check indentation for lists of elements (arrays, objects, function params)
          * @param {ASTNode[]} elements List of elements that should be offset
@@ -836,8 +849,12 @@ module.exports = {
                 } else {
                     const previousElement = elements[index - 1];
                     const firstTokenOfPreviousElement = previousElement && getFirstToken(previousElement);
+                    const previousElementLastToken = previousElement && sourceCode.getLastToken(previousElement);
 
-                    if (previousElement && sourceCode.getLastToken(previousElement).loc.end.line > startToken.loc.end.line) {
+                    if (
+                        previousElement &&
+                        previousElementLastToken.loc.end.line - countTrailingLinebreaks(previousElementLastToken.value) > startToken.loc.end.line
+                    ) {
                         offsets.setDesiredOffsets(element.range, firstTokenOfPreviousElement, 0);
                     }
                 }
@@ -980,6 +997,8 @@ module.exports = {
             return !node || node.loc.start.line === token.loc.start.line;
         }
 
+        const ignoredNodeFirstTokens = new Set();
+
         const baseOffsetListeners = {
             "ArrayExpression, ArrayPattern"(node) {
                 const openingBracket = sourceCode.getFirstToken(node);
@@ -1010,15 +1029,6 @@ module.exports = {
                     addElementListIndent(node.params, openingParen, closingParen, options.FunctionExpression.parameters);
                 }
                 addBlocklessNodeIndent(node.body);
-
-                let arrowToken;
-
-                if (node.params.length) {
-                    arrowToken = sourceCode.getTokenAfter(node.params[node.params.length - 1], astUtils.isArrowToken);
-                } else {
-                    arrowToken = sourceCode.getFirstToken(node, astUtils.isArrowToken);
-                }
-                offsets.setDesiredOffset(arrowToken, sourceCode.getFirstToken(node), 0);
             },
 
             AssignmentExpression(node) {
@@ -1128,9 +1138,6 @@ module.exports = {
                          */
                         offsets.setDesiredOffset(firstAlternateToken, firstToken, 1);
                     }
-
-                    offsets.setDesiredOffsets([questionMarkToken.range[1], colonToken.range[0]], firstConsequentToken, 0);
-                    offsets.setDesiredOffsets([colonToken.range[1], node.range[1]], firstAlternateToken, 0);
                 }
             },
 
@@ -1272,20 +1279,9 @@ module.exports = {
             SwitchStatement(node) {
                 const openingCurly = sourceCode.getTokenAfter(node.discriminant, astUtils.isOpeningBraceToken);
                 const closingCurly = sourceCode.getLastToken(node);
-                const caseKeywords = node.cases.map(switchCase => sourceCode.getFirstToken(switchCase));
 
                 offsets.setDesiredOffsets([openingCurly.range[1], closingCurly.range[0]], openingCurly, options.SwitchCase);
 
-                node.cases.forEach((switchCase, index) => {
-                    const caseKeyword = caseKeywords[index];
-
-                    if (!(switchCase.consequent.length === 1 && switchCase.consequent[0].type === "BlockStatement")) {
-                        const tokenAfterCurrentCase = index === node.cases.length - 1 ? closingCurly : caseKeywords[index + 1];
-
-                        offsets.setDesiredOffsets([caseKeyword.range[1], tokenAfterCurrentCase.range[0]], caseKeyword, 1);
-                    }
-                });
-
                 if (node.cases.length) {
                     sourceCode.getTokensBetween(
                         node.cases[node.cases.length - 1],
@@ -1295,6 +1291,15 @@ module.exports = {
                 }
             },
 
+            SwitchCase(node) {
+                if (!(node.consequent.length === 1 && node.consequent[0].type === "BlockStatement")) {
+                    const caseKeyword = sourceCode.getFirstToken(node);
+                    const tokenAfterCurrentCase = sourceCode.getTokenAfter(node);
+
+                    offsets.setDesiredOffsets([caseKeyword.range[1], tokenAfterCurrentCase.range[0]], caseKeyword, 1);
+                }
+            },
+
             TemplateLiteral(node) {
                 node.expressions.forEach((expression, index) => {
                     const previousQuasi = node.quasis[index];
@@ -1385,7 +1390,6 @@ module.exports = {
                 const firstToken = sourceCode.getFirstToken(node);
 
                 offsets.setDesiredOffsets(node.name.range, firstToken, 1);
-                offsets.setDesiredOffset(sourceCode.getLastToken(node), firstToken, 0);
             },
 
             JSXExpressionContainer(node) {
@@ -1397,7 +1401,15 @@ module.exports = {
                     openingCurly,
                     1
                 );
-                offsets.setDesiredOffset(closingCurly, openingCurly, 0);
+            },
+
+            "*"(node) {
+                const firstToken = sourceCode.getFirstToken(node);
+
+                // Ensure that the children of every node are indented at least as much as the first token.
+                if (firstToken && !ignoredNodeFirstTokens.has(firstToken)) {
+                    offsets.setDesiredOffsets(node.range, firstToken, 0);
+                }
             }
         };
 
@@ -1406,7 +1418,8 @@ module.exports = {
         /*
          * To ignore the indentation of a node:
          * 1. Don't call the node's listener when entering it (if it has a listener)
-         * 2. Call `ignoreNode` on the node sometime after exiting it and before validating offsets.
+         * 2. Don't set any offsets against the first token of the node.
+         * 3. Call `ignoreNode` on the node sometime after exiting it and before validating offsets.
          */
         const offsetListeners = lodash.mapValues(
             baseOffsetListeners,
@@ -1434,7 +1447,16 @@ module.exports = {
 
         // For each ignored node selector, set up a listener to collect it into the `ignoredNodes` set.
         const ignoredNodes = new Set();
-        const addToIgnoredNodes = ignoredNodes.add.bind(ignoredNodes);
+
+        /**
+         * Ignores a node
+         * @param {ASTNode} node The node to ignore
+         * @returns {void}
+         */
+        function addToIgnoredNodes(node) {
+            ignoredNodes.add(node);
+            ignoredNodeFirstTokens.add(sourceCode.getFirstToken(node));
+        }
 
         const ignoredNodeListeners = options.ignoredNodes.reduce(
             (listeners, ignoredSelector) => Object.assign(listeners, { [ignoredSelector]: addToIgnoredNodes }),
@@ -1457,7 +1479,7 @@ module.exports = {
 
                     // If a node's type is nonstandard, we can't tell how its children should be offset, so ignore it.
                     if (!KNOWN_NODES.has(node.type)) {
-                        ignoredNodes.add(node);
+                        addToIgnoredNodes(node);
                     }
                 },
                 "Program:exit"() {

package/lib/rules/keyword-spacing.js

@@ -108,13 +108,10 @@ module.exports = {
          * Reports a given token if there are not space(s) before the token.
          *
          * @param {Token} token - A token to report.
-         * @param {RegExp|undefined} pattern - Optional. A pattern of the previous
-         *      token to check.
+         * @param {RegExp} pattern - A pattern of the previous token to check.
          * @returns {void}
          */
         function expectSpaceBefore(token, pattern) {
-            pattern = pattern || PREV_TOKEN;
-
             const prevToken = sourceCode.getTokenBefore(token);
 
             if (prevToken &&
@@ -138,13 +135,10 @@ module.exports = {
          * Reports a given token if there are space(s) before the token.
          *
          * @param {Token} token - A token to report.
-         * @param {RegExp|undefined} pattern - Optional. A pattern of the previous
-         *      token to check.
+         * @param {RegExp} pattern - A pattern of the previous token to check.
          * @returns {void}
          */
         function unexpectSpaceBefore(token, pattern) {
-            pattern = pattern || PREV_TOKEN;
-
             const prevToken = sourceCode.getTokenBefore(token);
 
             if (prevToken &&
@@ -168,13 +162,10 @@ module.exports = {
          * Reports a given token if there are not space(s) after the token.
          *
          * @param {Token} token - A token to report.
-         * @param {RegExp|undefined} pattern - Optional. A pattern of the next
-         *      token to check.
+         * @param {RegExp} pattern - A pattern of the next token to check.
          * @returns {void}
          */
         function expectSpaceAfter(token, pattern) {
-            pattern = pattern || NEXT_TOKEN;
-
             const nextToken = sourceCode.getTokenAfter(token);
 
             if (nextToken &&
@@ -198,13 +189,10 @@ module.exports = {
          * Reports a given token if there are space(s) after the token.
          *
          * @param {Token} token - A token to report.
-         * @param {RegExp|undefined} pattern - Optional. A pattern of the next
-         *      token to check.
+         * @param {RegExp} pattern - A pattern of the next token to check.
          * @returns {void}
          */
         function unexpectSpaceAfter(token, pattern) {
-            pattern = pattern || NEXT_TOKEN;
-
             const nextToken = sourceCode.getTokenAfter(token);
 
             if (nextToken &&
@@ -274,7 +262,7 @@ module.exports = {
          * @returns {void}
          */
         function checkSpacingBefore(token, pattern) {
-            checkMethodMap[token.value].before(token, pattern);
+            checkMethodMap[token.value].before(token, pattern || PREV_TOKEN);
         }
 
         /**
@@ -287,7 +275,7 @@ module.exports = {
          * @returns {void}
          */
         function checkSpacingAfter(token, pattern) {
-            checkMethodMap[token.value].after(token, pattern);
+            checkMethodMap[token.value].after(token, pattern || NEXT_TOKEN);
         }
 
         /**

package/lib/rules/max-len.js

@@ -213,7 +213,8 @@ module.exports = {
          * @returns {ASTNode[]} An array of string nodes.
          */
         function getAllStrings() {
-            return sourceCode.ast.tokens.filter(token => token.type === "String");
+            return sourceCode.ast.tokens.filter(token => (token.type === "String" ||
+                (token.type === "JSXText" && sourceCode.getNodeByRangeIndex(token.range[0] - 1).type === "JSXAttribute")));
         }
 
         /**
@@ -287,6 +288,7 @@ module.exports = {
                  * line is a comment
                  */
                 let lineIsComment = false;
+                let textToMeasure;
 
                 /*
                  * We can short-circuit the comment checks if we're already out of
@@ -305,12 +307,17 @@ module.exports = {
 
                     if (isFullLineComment(line, lineNumber, comment)) {
                         lineIsComment = true;
+                        textToMeasure = line;
                     } else if (ignoreTrailingComments && isTrailingComment(line, lineNumber, comment)) {
-                        line = stripTrailingComment(line, comment);
+                        textToMeasure = stripTrailingComment(line, comment);
+                    } else {
+                        textToMeasure = line;
                     }
+                } else {
+                    textToMeasure = line;
                 }
-                if (ignorePattern && ignorePattern.test(line) ||
-                    ignoreUrls && URL_REGEXP.test(line) ||
+                if (ignorePattern && ignorePattern.test(textToMeasure) ||
+                    ignoreUrls && URL_REGEXP.test(textToMeasure) ||
                     ignoreStrings && stringsByLine[lineNumber] ||
                     ignoreTemplateLiterals && templateLiteralsByLine[lineNumber] ||
                     ignoreRegExpLiterals && regExpLiteralsByLine[lineNumber]
@@ -320,7 +327,7 @@ module.exports = {
                     return;
                 }
 
-                const lineLength = computeLineLength(line, tabWidth);
+                const lineLength = computeLineLength(textToMeasure, tabWidth);
                 const commentLengthApplies = lineIsComment && maxCommentLength;
 
                 if (lineIsComment && ignoreComments) {

package/lib/rules/no-await-in-loop.js

@@ -84,7 +84,7 @@ module.exports = {
             while (parent && !isBoundary(parent)) {
                 if (isLooped(node, parent)) {
                     context.report({
-                        node,
+                        node: awaitNode,
                         messageId: "unexpectedAwait"
                     });
                     return;

package/lib/rules/no-buffer-constructor.js

@@ -11,7 +11,7 @@
 module.exports = {
     meta: {
         docs: {
-            description: "disallow use of the Buffer() constructor",
+            description: "disallow use of the `Buffer()` constructor",
             category: "Node.js and CommonJS",
             recommended: false,
             url: "https://eslint.org/docs/rules/no-buffer-constructor"

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

@@ -5,6 +5,44 @@
 
 "use strict";
 
+const RegExpValidator = require("regexpp").RegExpValidator;
+const collector = new class {
+    constructor() {
+        this.ecmaVersion = 2018;
+        this._source = "";
+        this._controlChars = [];
+        this._validator = new RegExpValidator(this);
+    }
+
+    onPatternEnter() {
+        this._controlChars = [];
+    }
+
+    onCharacter(start, end, cp) {
+        if (cp >= 0x00 &&
+            cp <= 0x1F &&
+            (
+                this._source.codePointAt(start) === cp ||
+                this._source.slice(start, end).startsWith("\\x") ||
+                this._source.slice(start, end).startsWith("\\u")
+            )
+        ) {
+            this._controlChars.push(`\\x${`0${cp.toString(16)}`.slice(-2)}`);
+        }
+    }
+
+    collectControlChars(regexpStr) {
+        try {
+            this._source = regexpStr;
+            this._validator.validatePattern(regexpStr); // Call onCharacter hook
+        } catch (err) {
+
+            // Ignore syntax errors in RegExp.
+        }
+        return this._controlChars;
+    }
+}();
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -33,87 +71,28 @@ module.exports = {
          * @returns {RegExp|null} Regex if found else null
          * @private
          */
-        function getRegExp(node) {
-            if (node.value instanceof RegExp) {
-                return node.value;
+        function getRegExpPattern(node) {
+            if (node.regex) {
+                return node.regex.pattern;
             }
-            if (typeof node.value === "string") {
-
-                const parent = context.getAncestors().pop();
-
-                if ((parent.type === "NewExpression" || parent.type === "CallExpression") &&
-                    parent.callee.type === "Identifier" && parent.callee.name === "RegExp"
-                ) {
-
-                    // there could be an invalid regular expression string
-                    try {
-                        return new RegExp(node.value);
-                    } catch (ex) {
-                        return null;
-                    }
-                }
+            if (typeof node.value === "string" &&
+                (node.parent.type === "NewExpression" || node.parent.type === "CallExpression") &&
+                node.parent.callee.type === "Identifier" &&
+                node.parent.callee.name === "RegExp" &&
+                node.parent.arguments[0] === node
+            ) {
+                return node.value;
             }
 
             return null;
         }
 
-
-        const controlChar = /[\x00-\x1f]/g; // eslint-disable-line no-control-regex
-        const consecutiveSlashes = /\\+/g;
-        const consecutiveSlashesAtEnd = /\\+$/g;
-        const stringControlChar = /\\x[01][0-9a-f]/ig;
-        const stringControlCharWithoutSlash = /x[01][0-9a-f]/ig;
-
-        /**
-         * Return a list of the control characters in the given regex string
-         * @param {string} regexStr regex as string to check
-         * @returns {array} returns a list of found control characters on given string
-         * @private
-         */
-        function getControlCharacters(regexStr) {
-
-            // check control characters, if RegExp object used
-            const controlChars = regexStr.match(controlChar) || [];
-
-            let stringControlChars = [];
-
-            // check substr, if regex literal used
-            const subStrIndex = regexStr.search(stringControlChar);
-
-            if (subStrIndex > -1) {
-
-                // is it escaped, check backslash count
-                const possibleEscapeCharacters = regexStr.slice(0, subStrIndex).match(consecutiveSlashesAtEnd);
-
-                const hasControlChars = possibleEscapeCharacters === null || !(possibleEscapeCharacters[0].length % 2);
-
-                if (hasControlChars) {
-                    stringControlChars = regexStr.slice(subStrIndex, -1)
-                        .split(consecutiveSlashes)
-                        .filter(Boolean)
-                        .map(x => {
-                            const match = x.match(stringControlCharWithoutSlash) || [x];
-
-                            return `\\${match[0]}`;
-                        });
-                }
-            }
-
-            return controlChars.map(x => {
-                const hexCode = `0${x.charCodeAt(0).toString(16)}`.slice(-2);
-
-                return `\\x${hexCode}`;
-            }).concat(stringControlChars);
-        }
-
         return {
             Literal(node) {
-                const regex = getRegExp(node);
-
-                if (regex) {
-                    const computedValue = regex.toString();
+                const pattern = getRegExpPattern(node);
 
-                    const controlCharacters = getControlCharacters(computedValue);
+                if (pattern) {
+                    const controlCharacters = collector.collectControlChars(pattern);
 
                     if (controlCharacters.length > 0) {
                         context.report({