eslint 6.5.0 → 6.7.1

package/lib/rule-tester/rule-tester.js

@@ -78,8 +78,7 @@ const hasOwnProperty = Function.call.bind(Object.hasOwnProperty);
 /**
  * Clones a given value deeply.
  * Note: This ignores `parent` property.
- *
- * @param {any} x - A value to clone.
+ * @param {any} x A value to clone.
  * @returns {any} A cloned value.
  */
 function cloneDeeplyExcludesParent(x) {
@@ -104,8 +103,7 @@ function cloneDeeplyExcludesParent(x) {
 
 /**
  * Freezes a given value deeply.
- *
- * @param {any} x - A value to freeze.
+ * @param {any} x A value to freeze.
  * @returns {void}
  */
 function freezeDeeply(x) {
@@ -146,8 +144,8 @@ const IT = Symbol("it");
 /**
  * This is `it` default handler if `it` don't exist.
  * @this {Mocha}
- * @param {string} text - The description of the test case.
- * @param {Function} method - The logic of the test case.
+ * @param {string} text The description of the test case.
+ * @param {Function} method The logic of the test case.
  * @returns {any} Returned value of `method`.
  */
 function itDefaultHandler(text, method) {
@@ -164,8 +162,8 @@ function itDefaultHandler(text, method) {
 /**
  * This is `describe` default handler if `describe` don't exist.
  * @this {Mocha}
- * @param {string} text - The description of the test case.
- * @param {Function} method - The logic of the test case.
+ * @param {string} text The description of the test case.
+ * @param {Function} method The logic of the test case.
  * @returns {any} Returned value of `method`.
  */
 function describeDefaultHandler(text, method) {
@@ -351,7 +349,7 @@ class RuleTester {
                 filename = item.filename;
             }
 
-            if (Object.prototype.hasOwnProperty.call(item, "options")) {
+            if (hasOwnProperty(item, "options")) {
                 assert(Array.isArray(item.options), "options must be an array");
                 config.rules[ruleName] = [1].concat(item.options);
             } else {
@@ -579,21 +577,55 @@ class RuleTester {
                             assert.strictEqual(message.nodeType, error.type, `Error type should be ${error.type}, found ${message.nodeType}`);
                         }
 
-                        if (Object.prototype.hasOwnProperty.call(error, "line")) {
+                        if (hasOwnProperty(error, "line")) {
                             assert.strictEqual(message.line, error.line, `Error line should be ${error.line}`);
                         }
 
-                        if (Object.prototype.hasOwnProperty.call(error, "column")) {
+                        if (hasOwnProperty(error, "column")) {
                             assert.strictEqual(message.column, error.column, `Error column should be ${error.column}`);
                         }
 
-                        if (Object.prototype.hasOwnProperty.call(error, "endLine")) {
+                        if (hasOwnProperty(error, "endLine")) {
                             assert.strictEqual(message.endLine, error.endLine, `Error endLine should be ${error.endLine}`);
                         }
 
-                        if (Object.prototype.hasOwnProperty.call(error, "endColumn")) {
+                        if (hasOwnProperty(error, "endColumn")) {
                             assert.strictEqual(message.endColumn, error.endColumn, `Error endColumn should be ${error.endColumn}`);
                         }
+
+                        if (hasOwnProperty(error, "suggestions")) {
+
+                            // Support asserting there are no suggestions
+                            if (!error.suggestions) {
+                                assert.strictEqual(message.suggestions, error.suggestions, `Error should have no suggestions on error with message: "${message.message}"`);
+                            } else {
+                                assert.strictEqual(Array.isArray(message.suggestions), true, `Error should have an array of suggestions. Instead received "${message.suggestions}" on error with message: "${message.message}"`);
+                                assert.strictEqual(message.suggestions.length, error.suggestions.length, `Error should have ${error.suggestions.length} suggestions. Instead found ${message.suggestions.length} suggestions`);
+
+                                error.suggestions.forEach((expectedSuggestion, index) => {
+                                    const actualSuggestion = message.suggestions[index];
+
+                                    /**
+                                     * Tests equality of a suggestion key if that key is defined in the expected output.
+                                     * @param {string} key Key to validate from the suggestion object
+                                     * @returns {void}
+                                     */
+                                    function assertSuggestionKeyEquals(key) {
+                                        if (hasOwnProperty(expectedSuggestion, key)) {
+                                            assert.deepStrictEqual(actualSuggestion[key], expectedSuggestion[key], `Error suggestion at index: ${index} should have desc of: "${actualSuggestion[key]}"`);
+                                        }
+                                    }
+                                    assertSuggestionKeyEquals("desc");
+                                    assertSuggestionKeyEquals("messageId");
+
+                                    if (hasOwnProperty(expectedSuggestion, "output")) {
+                                        const codeWithAppliedSuggestion = SourceCodeFixer.applyFixes(item.code, [actualSuggestion]).output;
+
+                                        assert.strictEqual(codeWithAppliedSuggestion, expectedSuggestion.output, `Expected the applied suggestion fix to match the test suggestion output for suggestion at index: ${index} on error with message: "${message.message}"`);
+                                    }
+                                });
+                            }
+                        }
                     } else {
 
                         // Message was an unexpected type
@@ -602,7 +634,7 @@ class RuleTester {
                 }
             }
 
-            if (Object.prototype.hasOwnProperty.call(item, "output")) {
+            if (hasOwnProperty(item, "output")) {
                 if (item.output === null) {
                     assert.strictEqual(
                         result.output,

package/lib/rules/accessor-pairs.js

@@ -79,7 +79,7 @@ function areEqualKeys(left, right) {
 
 /**
  * Checks whether or not a given node is of an accessor kind ('get' or 'set').
- * @param {ASTNode} node - A node to check.
+ * @param {ASTNode} node A node to check.
  * @returns {boolean} `true` if the node is of an accessor kind.
  */
 function isAccessorKind(node) {
@@ -88,8 +88,8 @@ function isAccessorKind(node) {
 
 /**
  * Checks whether or not a given node is an `Identifier` node which was named a given name.
- * @param {ASTNode} node - A node to check.
- * @param {string} name - An expected name of the node.
+ * @param {ASTNode} node A node to check.
+ * @param {string} name An expected name of the node.
  * @returns {boolean} `true` if the node is an `Identifier` node which was named as expected.
  */
 function isIdentifier(node, name) {
@@ -98,10 +98,10 @@ function isIdentifier(node, name) {
 
 /**
  * Checks whether or not a given node is an argument of a specified method call.
- * @param {ASTNode} node - A node to check.
- * @param {number} index - An expected index of the node in arguments.
- * @param {string} object - An expected name of the object of the method.
- * @param {string} property - An expected name of the method.
+ * @param {ASTNode} node A node to check.
+ * @param {number} index An expected index of the node in arguments.
+ * @param {string} object An expected name of the object of the method.
+ * @param {string} property An expected name of the method.
  * @returns {boolean} `true` if the node is an argument of the specified method call.
  */
 function isArgumentOfMethodCall(node, index, object, property) {
@@ -119,7 +119,7 @@ function isArgumentOfMethodCall(node, index, object, property) {
 
 /**
  * Checks whether or not a given node is a property descriptor.
- * @param {ASTNode} node - A node to check.
+ * @param {ASTNode} node A node to check.
  * @returns {boolean} `true` if the node is a property descriptor.
  */
 function isPropertyDescriptor(node) {

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

@@ -65,8 +65,7 @@ module.exports = {
 
         /**
          * Normalizes a given option value.
-         *
-         * @param {string|Object|undefined} option - An option value to parse.
+         * @param {string|Object|undefined} option An option value to parse.
          * @returns {{multiline: boolean, minItems: number}} Normalized option object.
          */
         function normalizeOptionValue(option) {
@@ -97,8 +96,7 @@ module.exports = {
 
         /**
          * Normalizes a given option value.
-         *
-         * @param {string|Object|undefined} options - An option value to parse.
+         * @param {string|Object|undefined} options An option value to parse.
          * @returns {{ArrayExpression: {multiline: boolean, minItems: number}, ArrayPattern: {multiline: boolean, minItems: number}}} Normalized option object.
          */
         function normalizeOptions(options) {
@@ -109,8 +107,8 @@ module.exports = {
 
         /**
          * Reports that there shouldn't be a linebreak after the first token
-         * @param {ASTNode} node - The node to report in the event of an error.
-         * @param {Token} token - The token to use for the report.
+         * @param {ASTNode} node The node to report in the event of an error.
+         * @param {Token} token The token to use for the report.
          * @returns {void}
          */
         function reportNoBeginningLinebreak(node, token) {
@@ -132,8 +130,8 @@ module.exports = {
 
         /**
          * Reports that there shouldn't be a linebreak before the last token
-         * @param {ASTNode} node - The node to report in the event of an error.
-         * @param {Token} token - The token to use for the report.
+         * @param {ASTNode} node The node to report in the event of an error.
+         * @param {Token} token The token to use for the report.
          * @returns {void}
          */
         function reportNoEndingLinebreak(node, token) {
@@ -155,8 +153,8 @@ module.exports = {
 
         /**
          * Reports that there should be a linebreak after the first token
-         * @param {ASTNode} node - The node to report in the event of an error.
-         * @param {Token} token - The token to use for the report.
+         * @param {ASTNode} node The node to report in the event of an error.
+         * @param {Token} token The token to use for the report.
          * @returns {void}
          */
         function reportRequiredBeginningLinebreak(node, token) {
@@ -172,8 +170,8 @@ module.exports = {
 
         /**
          * Reports that there should be a linebreak before the last token
-         * @param {ASTNode} node - The node to report in the event of an error.
-         * @param {Token} token - The token to use for the report.
+         * @param {ASTNode} node The node to report in the event of an error.
+         * @param {Token} token The token to use for the report.
          * @returns {void}
          */
         function reportRequiredEndingLinebreak(node, token) {
@@ -189,8 +187,7 @@ module.exports = {
 
         /**
          * Reports a given node if it violated this rule.
-         *
-         * @param {ASTNode} node - A node to check. This is an ArrayExpression node or an ArrayPattern node.
+         * @param {ASTNode} node A node to check. This is an ArrayExpression node or an ArrayPattern node.
          * @returns {void}
          */
         function check(node) {
@@ -219,7 +216,7 @@ module.exports = {
                 ) ||
                 (
                     options.consistent &&
-                    firstIncComment.loc.start.line !== openBracket.loc.end.line
+                    openBracket.loc.end.line !== first.loc.start.line
                 )
             );
 

package/lib/rules/array-bracket-spacing.js

@@ -59,7 +59,7 @@ module.exports = {
          * Determines whether an option is set, relative to the spacing option.
          * If spaced is "always", then check whether option is set to false.
          * If spaced is "never", then check whether option is set to true.
-         * @param {Object} option - The option to exclude.
+         * @param {Object} option The option to exclude.
          * @returns {boolean} Whether or not the property is excluded.
          */
         function isOptionSet(option) {
@@ -79,8 +79,8 @@ module.exports = {
 
         /**
          * Reports that there shouldn't be a space after the first token
-         * @param {ASTNode} node - The node to report in the event of an error.
-         * @param {Token} token - The token to use for the report.
+         * @param {ASTNode} node The node to report in the event of an error.
+         * @param {Token} token The token to use for the report.
          * @returns {void}
          */
         function reportNoBeginningSpace(node, token) {
@@ -101,8 +101,8 @@ module.exports = {
 
         /**
          * Reports that there shouldn't be a space before the last token
-         * @param {ASTNode} node - The node to report in the event of an error.
-         * @param {Token} token - The token to use for the report.
+         * @param {ASTNode} node The node to report in the event of an error.
+         * @param {Token} token The token to use for the report.
          * @returns {void}
          */
         function reportNoEndingSpace(node, token) {
@@ -123,8 +123,8 @@ module.exports = {
 
         /**
          * Reports that there should be a space after the first token
-         * @param {ASTNode} node - The node to report in the event of an error.
-         * @param {Token} token - The token to use for the report.
+         * @param {ASTNode} node The node to report in the event of an error.
+         * @param {Token} token The token to use for the report.
          * @returns {void}
          */
         function reportRequiredBeginningSpace(node, token) {
@@ -143,8 +143,8 @@ module.exports = {
 
         /**
          * Reports that there should be a space before the last token
-         * @param {ASTNode} node - The node to report in the event of an error.
-         * @param {Token} token - The token to use for the report.
+         * @param {ASTNode} node The node to report in the event of an error.
+         * @param {Token} token The token to use for the report.
          * @returns {void}
          */
         function reportRequiredEndingSpace(node, token) {
@@ -163,7 +163,7 @@ module.exports = {
 
         /**
          * Determines if a node is an object type
-         * @param {ASTNode} node - The node to check.
+         * @param {ASTNode} node The node to check.
          * @returns {boolean} Whether or not the node is an object type.
          */
         function isObjectType(node) {
@@ -172,7 +172,7 @@ module.exports = {
 
         /**
          * Determines if a node is an array type
-         * @param {ASTNode} node - The node to check.
+         * @param {ASTNode} node The node to check.
          * @returns {boolean} Whether or not the node is an array type.
          */
         function isArrayType(node) {
@@ -181,7 +181,7 @@ module.exports = {
 
         /**
          * Validates the spacing around array brackets
-         * @param {ASTNode} node - The node we're checking for spacing
+         * @param {ASTNode} node The node we're checking for spacing
          * @returns {void}
          */
         function validateArraySpacing(node) {

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

@@ -22,8 +22,7 @@ const TARGET_METHODS = /^(?:every|filter|find(?:Index)?|map|reduce(?:Right)?|som
 
 /**
  * Checks a given code path segment is reachable.
- *
- * @param {CodePathSegment} segment - A segment to check.
+ * @param {CodePathSegment} segment A segment to check.
  * @returns {boolean} `true` if the segment is reachable.
  */
 function isReachable(segment) {
@@ -35,9 +34,8 @@ function isReachable(segment) {
  *
  * - FunctionExpression -> the function name or `function` keyword.
  * - ArrowFunctionExpression -> `=>` token.
- *
- * @param {ASTNode} node - A function node to get.
- * @param {SourceCode} sourceCode - A source code to get tokens.
+ * @param {ASTNode} node A function node to get.
+ * @param {SourceCode} sourceCode A source code to get tokens.
  * @returns {ASTNode|Token} The node or the token of a location.
  */
 function getLocation(node, sourceCode) {
@@ -50,8 +48,7 @@ function getLocation(node, sourceCode) {
 /**
  * Checks a given node is a MemberExpression node which has the specified name's
  * property.
- *
- * @param {ASTNode} node - A node to check.
+ * @param {ASTNode} node A node to check.
  * @returns {boolean} `true` if the node is a MemberExpression node which has
  *      the specified name's property
  */
@@ -65,8 +62,7 @@ function isTargetMethod(node) {
 /**
  * Checks whether or not a given node is a function expression which is the
  * callback of an array method.
- *
- * @param {ASTNode} node - A node to check. This is one of
+ * @param {ASTNode} node A node to check. This is one of
  *      FunctionExpression or ArrowFunctionExpression.
  * @returns {boolean} `true` if the node is the callback of an array method.
  */
@@ -188,8 +184,7 @@ module.exports = {
          *
          * If the last code path segment is reachable, there are paths which are not
          * returned or thrown.
-         *
-         * @param {ASTNode} node - A node to check.
+         * @param {ASTNode} node A node to check.
          * @returns {void}
          */
         function checkLastSegment(node) {

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

@@ -62,8 +62,7 @@ module.exports = {
 
         /**
          * Normalizes a given option value.
-         *
-         * @param {string|Object|undefined} providedOption - 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(providedOption) {
@@ -90,8 +89,7 @@ module.exports = {
 
         /**
          * Normalizes a given option value.
-         *
-         * @param {string|Object|undefined} options - An option value to parse.
+         * @param {string|Object|undefined} options An option value to parse.
          * @returns {{ArrayExpression: {multiline: boolean, minItems: number}, ArrayPattern: {multiline: boolean, minItems: number}}} Normalized option object.
          */
         function normalizeOptions(options) {
@@ -102,7 +100,7 @@ module.exports = {
 
         /**
          * Reports that there shouldn't be a line break after the first token
-         * @param {Token} token - The token to use for the report.
+         * @param {Token} token The token to use for the report.
          * @returns {void}
          */
         function reportNoLineBreak(token) {
@@ -151,7 +149,7 @@ module.exports = {
 
         /**
          * Reports that there should be a line break after the first token
-         * @param {Token} token - The token to use for the report.
+         * @param {Token} token The token to use for the report.
          * @returns {void}
          */
         function reportRequiredLineBreak(token) {
@@ -171,8 +169,7 @@ module.exports = {
 
         /**
          * Reports a given node if it violated this rule.
-         *
-         * @param {ASTNode} node - A node to check. This is an ObjectExpression node or an ObjectPattern node.
+         * @param {ASTNode} node A node to check. This is an ObjectExpression node or an ObjectPattern node.
          * @returns {void}
          */
         function check(node) {

package/lib/rules/arrow-parens.js

@@ -16,7 +16,6 @@ const astUtils = require("./utils/ast-utils");
 
 /**
  * Get location should be reported by AST node.
- *
  * @param {ASTNode} node AST Node.
  * @returns {Location} Location information.
  */

package/lib/rules/block-scoped-var.js

@@ -31,7 +31,7 @@ module.exports = {
 
         /**
          * Makes a block scope.
-         * @param {ASTNode} node - A node of a scope.
+         * @param {ASTNode} node A node of a scope.
          * @returns {void}
          */
         function enterScope(node) {
@@ -48,7 +48,7 @@ module.exports = {
 
         /**
          * Reports a given reference.
-         * @param {eslint-scope.Reference} reference - A reference to report.
+         * @param {eslint-scope.Reference} reference A reference to report.
          * @returns {void}
          */
         function report(reference) {
@@ -59,7 +59,7 @@ module.exports = {
 
         /**
          * Finds and reports references which are outside of valid scopes.
-         * @param {ASTNode} node - A node to get variables.
+         * @param {ASTNode} node A node to get variables.
          * @returns {void}
          */
         function checkForVariables(node) {

package/lib/rules/block-spacing.js

@@ -41,7 +41,7 @@ module.exports = {
 
         /**
          * Gets the open brace token from a given node.
-         * @param {ASTNode} node - A BlockStatement/SwitchStatement node to get.
+         * @param {ASTNode} node A BlockStatement/SwitchStatement node to get.
          * @returns {Token} The token of the open brace.
          */
         function getOpenBrace(node) {
@@ -58,8 +58,8 @@ module.exports = {
          * Checks whether or not:
          *   - given tokens are on same line.
          *   - there is/isn't a space between given tokens.
-         * @param {Token} left - A token to check.
-         * @param {Token} right - The token which is next to `left`.
+         * @param {Token} left A token to check.
+         * @param {Token} right The token which is next to `left`.
          * @returns {boolean}
          *    When the option is `"always"`, `true` if there are one or more spaces between given tokens.
          *    When the option is `"never"`, `true` if there are not any spaces between given tokens.
@@ -74,7 +74,7 @@ module.exports = {
 
         /**
          * Reports invalid spacing style inside braces.
-         * @param {ASTNode} node - A BlockStatement/SwitchStatement node to get.
+         * @param {ASTNode} node A BlockStatement/SwitchStatement node to get.
          * @returns {void}
          */
         function checkSpacingInsideBraces(node) {

package/lib/rules/camelcase.js

@@ -28,6 +28,10 @@ module.exports = {
                         type: "boolean",
                         default: false
                     },
+                    ignoreImports: {
+                        type: "boolean",
+                        default: false
+                    },
                     properties: {
                         enum: ["always", "never"]
                     },
@@ -56,6 +60,7 @@ module.exports = {
         const options = context.options[0] || {};
         let properties = options.properties || "";
         const ignoreDestructuring = options.ignoreDestructuring;
+        const ignoreImports = options.ignoreImports;
         const allow = options.allow || [];
 
         if (properties !== "always" && properties !== "never") {
@@ -79,7 +84,7 @@ module.exports = {
         function isUnderscored(name) {
 
             // if there's an underscore, it might be A_CONSTANT, which is okay
-            return name.indexOf("_") > -1 && name !== name.toUpperCase();
+            return name.includes("_") && name !== name.toUpperCase();
         }
 
         /**
@@ -89,9 +94,9 @@ module.exports = {
          * @private
          */
         function isAllowed(name) {
-            return allow.findIndex(
+            return allow.some(
                 entry => name === entry || name.match(new RegExp(entry, "u"))
-            ) !== -1;
+            );
         }
 
         /**
@@ -127,7 +132,7 @@ module.exports = {
          * @private
          */
         function report(node) {
-            if (reported.indexOf(node) < 0) {
+            if (!reported.includes(node)) {
                 reported.push(node);
                 context.report({ node, messageId: "notCamelCase", data: { name: node.name } });
             }
@@ -209,10 +214,18 @@ module.exports = {
                     }
 
                 // Check if it's an import specifier
-                } else if (["ImportSpecifier", "ImportNamespaceSpecifier", "ImportDefaultSpecifier"].indexOf(node.parent.type) >= 0) {
+                } else if (["ImportSpecifier", "ImportNamespaceSpecifier", "ImportDefaultSpecifier"].includes(node.parent.type)) {
+
+                    if (node.parent.type === "ImportSpecifier" && ignoreImports) {
+                        return;
+                    }
 
                     // Report only if the local imported identifier is underscored
-                    if (node.parent.local && node.parent.local.name === node.name && nameIsUnderscored) {
+                    if (
+                        node.parent.local &&
+                        node.parent.local.name === node.name &&
+                        nameIsUnderscored
+                    ) {
                         report(node);
                     }
 

package/lib/rules/capitalized-comments.js

@@ -54,7 +54,6 @@ const DEFAULTS = {
  *   set is returned. Options specified in overrides will take priority
  *   over options specified in the main options object, which will in
  *   turn take priority over the rule's defaults.
- *
  * @param {Object|string} rawOptions The user-provided options.
  * @param {string} which Either "line" or "block".
  * @returns {Object} The normalized options.
@@ -65,7 +64,6 @@ function getNormalizedOptions(rawOptions, which) {
 
 /**
  * Get normalized options for block and line comments.
- *
  * @param {Object|string} rawOptions The user-provided options.
  * @returns {Object} An object with "Line" and "Block" keys and corresponding
  * normalized options objects.
@@ -82,7 +80,6 @@ function getAllNormalizedOptions(rawOptions = {}) {
  * options.
  *
  * This is done in order to avoid invoking the RegExp constructor repeatedly.
- *
  * @param {Object} normalizedOptions The normalized rule options.
  * @returns {void}
  */
@@ -162,7 +159,6 @@ module.exports = {
          * Also, it follows from this definition that only block comments can
          * be considered as possibly inline. This is because line comments
          * would consume any following tokens on the same line as the comment.
-         *
          * @param {ASTNode} comment The comment node to check.
          * @returns {boolean} True if the comment is an inline comment, false
          * otherwise.
@@ -181,7 +177,6 @@ module.exports = {
 
         /**
          * Determine if a comment follows another comment.
-         *
          * @param {ASTNode} comment The comment to check.
          * @returns {boolean} True if the comment follows a valid comment.
          */
@@ -196,7 +191,6 @@ module.exports = {
 
         /**
          * Check a comment to determine if it is valid for this rule.
-         *
          * @param {ASTNode} comment The comment node to process.
          * @param {Object} options The options for checking this comment.
          * @returns {boolean} True if the comment is valid, false otherwise.
@@ -261,7 +255,6 @@ module.exports = {
 
         /**
          * Process a comment to determine if it needs to be reported.
-         *
          * @param {ASTNode} comment The comment node to process.
          * @returns {void}
          */

package/lib/rules/class-methods-use-this.js

@@ -61,7 +61,7 @@ module.exports = {
 
         /**
          * Check if the node is an instance method
-         * @param {ASTNode} node - node to check
+         * @param {ASTNode} node node to check
          * @returns {boolean} True if its an instance method
          * @private
          */
@@ -71,7 +71,7 @@ module.exports = {
 
         /**
          * Check if the node is an instance method not excluded by config
-         * @param {ASTNode} node - node to check
+         * @param {ASTNode} node node to check
          * @returns {boolean} True if it is an instance method, and not excluded by config
          * @private
          */
@@ -84,7 +84,7 @@ module.exports = {
          * Checks if we are leaving a function that is a method, and reports if 'this' has not been used.
          * Static methods and the constructor are exempt.
          * Then pops the context off the stack.
-         * @param {ASTNode} node - A function node that was entered.
+         * @param {ASTNode} node A function node that was entered.
          * @returns {void}
          * @private
          */