less 3.10.1 → 3.11.1

package/packages/less/node_modules/eslint/lib/rules/no-implicit-coercion.js

@@ -0,0 +1,296 @@
+/**
+ * @fileoverview A rule to disallow the type conversions with shorter notations.
+ * @author Toru Nagashima
+ */
+
+"use strict";
+
+const astUtils = require("../util/ast-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const INDEX_OF_PATTERN = /^(?:i|lastI)ndexOf$/u;
+const ALLOWABLE_OPERATORS = ["~", "!!", "+", "*"];
+
+/**
+ * Parses and normalizes an option object.
+ * @param {Object} options - An option object to parse.
+ * @returns {Object} The parsed and normalized option object.
+ */
+function parseOptions(options) {
+    return {
+        boolean: "boolean" in options ? options.boolean : true,
+        number: "number" in options ? options.number : true,
+        string: "string" in options ? options.string : true,
+        allow: options.allow || []
+    };
+}
+
+/**
+ * Checks whether or not a node is a double logical nigating.
+ * @param {ASTNode} node - An UnaryExpression node to check.
+ * @returns {boolean} Whether or not the node is a double logical nigating.
+ */
+function isDoubleLogicalNegating(node) {
+    return (
+        node.operator === "!" &&
+        node.argument.type === "UnaryExpression" &&
+        node.argument.operator === "!"
+    );
+}
+
+/**
+ * Checks whether or not a node is a binary negating of `.indexOf()` method calling.
+ * @param {ASTNode} node - An UnaryExpression node to check.
+ * @returns {boolean} Whether or not the node is a binary negating of `.indexOf()` method calling.
+ */
+function isBinaryNegatingOfIndexOf(node) {
+    return (
+        node.operator === "~" &&
+        node.argument.type === "CallExpression" &&
+        node.argument.callee.type === "MemberExpression" &&
+        node.argument.callee.property.type === "Identifier" &&
+        INDEX_OF_PATTERN.test(node.argument.callee.property.name)
+    );
+}
+
+/**
+ * Checks whether or not a node is a multiplying by one.
+ * @param {BinaryExpression} node - A BinaryExpression node to check.
+ * @returns {boolean} Whether or not the node is a multiplying by one.
+ */
+function isMultiplyByOne(node) {
+    return node.operator === "*" && (
+        node.left.type === "Literal" && node.left.value === 1 ||
+        node.right.type === "Literal" && node.right.value === 1
+    );
+}
+
+/**
+ * Checks whether the result of a node is numeric or not
+ * @param {ASTNode} node The node to test
+ * @returns {boolean} true if the node is a number literal or a `Number()`, `parseInt` or `parseFloat` call
+ */
+function isNumeric(node) {
+    return (
+        node.type === "Literal" && typeof node.value === "number" ||
+        node.type === "CallExpression" && (
+            node.callee.name === "Number" ||
+            node.callee.name === "parseInt" ||
+            node.callee.name === "parseFloat"
+        )
+    );
+}
+
+/**
+ * Returns the first non-numeric operand in a BinaryExpression. Designed to be
+ * used from bottom to up since it walks up the BinaryExpression trees using
+ * node.parent to find the result.
+ * @param {BinaryExpression} node The BinaryExpression node to be walked up on
+ * @returns {ASTNode|null} The first non-numeric item in the BinaryExpression tree or null
+ */
+function getNonNumericOperand(node) {
+    const left = node.left,
+        right = node.right;
+
+    if (right.type !== "BinaryExpression" && !isNumeric(right)) {
+        return right;
+    }
+
+    if (left.type !== "BinaryExpression" && !isNumeric(left)) {
+        return left;
+    }
+
+    return null;
+}
+
+/**
+ * Checks whether a node is an empty string literal or not.
+ * @param {ASTNode} node The node to check.
+ * @returns {boolean} Whether or not the passed in node is an
+ * empty string literal or not.
+ */
+function isEmptyString(node) {
+    return astUtils.isStringLiteral(node) && (node.value === "" || (node.type === "TemplateLiteral" && node.quasis.length === 1 && node.quasis[0].value.cooked === ""));
+}
+
+/**
+ * Checks whether or not a node is a concatenating with an empty string.
+ * @param {ASTNode} node - A BinaryExpression node to check.
+ * @returns {boolean} Whether or not the node is a concatenating with an empty string.
+ */
+function isConcatWithEmptyString(node) {
+    return node.operator === "+" && (
+        (isEmptyString(node.left) && !astUtils.isStringLiteral(node.right)) ||
+        (isEmptyString(node.right) && !astUtils.isStringLiteral(node.left))
+    );
+}
+
+/**
+ * Checks whether or not a node is appended with an empty string.
+ * @param {ASTNode} node - An AssignmentExpression node to check.
+ * @returns {boolean} Whether or not the node is appended with an empty string.
+ */
+function isAppendEmptyString(node) {
+    return node.operator === "+=" && isEmptyString(node.right);
+}
+
+/**
+ * Returns the operand that is not an empty string from a flagged BinaryExpression.
+ * @param {ASTNode} node - The flagged BinaryExpression node to check.
+ * @returns {ASTNode} The operand that is not an empty string from a flagged BinaryExpression.
+ */
+function getNonEmptyOperand(node) {
+    return isEmptyString(node.left) ? node.right : node.left;
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "disallow shorthand type conversions",
+            category: "Best Practices",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/no-implicit-coercion"
+        },
+
+        fixable: "code",
+
+        schema: [{
+            type: "object",
+            properties: {
+                boolean: {
+                    type: "boolean",
+                    default: true
+                },
+                number: {
+                    type: "boolean",
+                    default: true
+                },
+                string: {
+                    type: "boolean",
+                    default: true
+                },
+                allow: {
+                    type: "array",
+                    items: {
+                        enum: ALLOWABLE_OPERATORS
+                    },
+                    uniqueItems: true
+                }
+            },
+            additionalProperties: false
+        }]
+    },
+
+    create(context) {
+        const options = parseOptions(context.options[0] || {});
+        const sourceCode = context.getSourceCode();
+
+        /**
+         * Reports an error and autofixes the node
+         * @param {ASTNode} node - An ast node to report the error on.
+         * @param {string} recommendation - The recommended code for the issue
+         * @param {bool} shouldFix - Whether this report should fix the node
+         * @returns {void}
+         */
+        function report(node, recommendation, shouldFix) {
+            context.report({
+                node,
+                message: "use `{{recommendation}}` instead.",
+                data: {
+                    recommendation
+                },
+                fix(fixer) {
+                    if (!shouldFix) {
+                        return null;
+                    }
+
+                    const tokenBefore = sourceCode.getTokenBefore(node);
+
+                    if (
+                        tokenBefore &&
+                        tokenBefore.range[1] === node.range[0] &&
+                        !astUtils.canTokensBeAdjacent(tokenBefore, recommendation)
+                    ) {
+                        return fixer.replaceText(node, ` ${recommendation}`);
+                    }
+                    return fixer.replaceText(node, recommendation);
+                }
+            });
+        }
+
+        return {
+            UnaryExpression(node) {
+                let operatorAllowed;
+
+                // !!foo
+                operatorAllowed = options.allow.indexOf("!!") >= 0;
+                if (!operatorAllowed && options.boolean && isDoubleLogicalNegating(node)) {
+                    const recommendation = `Boolean(${sourceCode.getText(node.argument.argument)})`;
+
+                    report(node, recommendation, true);
+                }
+
+                // ~foo.indexOf(bar)
+                operatorAllowed = options.allow.indexOf("~") >= 0;
+                if (!operatorAllowed && options.boolean && isBinaryNegatingOfIndexOf(node)) {
+                    const recommendation = `${sourceCode.getText(node.argument)} !== -1`;
+
+                    report(node, recommendation, false);
+                }
+
+                // +foo
+                operatorAllowed = options.allow.indexOf("+") >= 0;
+                if (!operatorAllowed && options.number && node.operator === "+" && !isNumeric(node.argument)) {
+                    const recommendation = `Number(${sourceCode.getText(node.argument)})`;
+
+                    report(node, recommendation, true);
+                }
+            },
+
+            // Use `:exit` to prevent double reporting
+            "BinaryExpression:exit"(node) {
+                let operatorAllowed;
+
+                // 1 * foo
+                operatorAllowed = options.allow.indexOf("*") >= 0;
+                const nonNumericOperand = !operatorAllowed && options.number && isMultiplyByOne(node) && getNonNumericOperand(node);
+
+                if (nonNumericOperand) {
+                    const recommendation = `Number(${sourceCode.getText(nonNumericOperand)})`;
+
+                    report(node, recommendation, true);
+                }
+
+                // "" + foo
+                operatorAllowed = options.allow.indexOf("+") >= 0;
+                if (!operatorAllowed && options.string && isConcatWithEmptyString(node)) {
+                    const recommendation = `String(${sourceCode.getText(getNonEmptyOperand(node))})`;
+
+                    report(node, recommendation, true);
+                }
+            },
+
+            AssignmentExpression(node) {
+
+                // foo += ""
+                const operatorAllowed = options.allow.indexOf("+") >= 0;
+
+                if (!operatorAllowed && options.string && isAppendEmptyString(node)) {
+                    const code = sourceCode.getText(getNonEmptyOperand(node));
+                    const recommendation = `${code} = String(${code})`;
+
+                    report(node, recommendation, true);
+                }
+            }
+        };
+    }
+};

package/packages/less/node_modules/eslint/lib/rules/no-implicit-globals.js

@@ -0,0 +1,58 @@
+/**
+ * @fileoverview Rule to check for implicit global variables and functions.
+ * @author Joshua Peek
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "disallow variable and `function` declarations in the global scope",
+            category: "Best Practices",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/no-implicit-globals"
+        },
+
+        schema: []
+    },
+
+    create(context) {
+        return {
+            Program() {
+                const scope = context.getScope();
+
+                scope.variables.forEach(variable => {
+                    if (variable.writeable) {
+                        return;
+                    }
+
+                    variable.defs.forEach(def => {
+                        if (def.type === "FunctionName" || (def.type === "Variable" && def.parent.kind === "var")) {
+                            context.report({ node: def.node, message: "Implicit global variable, assign as global property instead." });
+                        }
+                    });
+                });
+
+                scope.implicit.variables.forEach(variable => {
+                    const scopeVariable = scope.set.get(variable.name);
+
+                    if (scopeVariable && scopeVariable.writeable) {
+                        return;
+                    }
+
+                    variable.defs.forEach(def => {
+                        context.report({ node: def.node, message: "Implicit global variable, assign as global property instead." });
+                    });
+                });
+            }
+        };
+
+    }
+};

package/packages/less/node_modules/eslint/lib/rules/no-implied-eval.js

@@ -0,0 +1,164 @@
+/**
+ * @fileoverview Rule to flag use of implied eval via setTimeout and setInterval
+ * @author James Allardice
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "disallow the use of `eval()`-like methods",
+            category: "Best Practices",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/no-implied-eval"
+        },
+
+        schema: []
+    },
+
+    create(context) {
+        const CALLEE_RE = /^(setTimeout|setInterval|execScript)$/u;
+
+        /*
+         * Figures out if we should inspect a given binary expression. Is a stack
+         * of stacks, where the first element in each substack is a CallExpression.
+         */
+        const impliedEvalAncestorsStack = [];
+
+        //--------------------------------------------------------------------------
+        // Helpers
+        //--------------------------------------------------------------------------
+
+        /**
+         * Get the last element of an array, without modifying arr, like pop(), but non-destructive.
+         * @param {Array} arr What to inspect
+         * @returns {*} The last element of arr
+         * @private
+         */
+        function last(arr) {
+            return arr ? arr[arr.length - 1] : null;
+        }
+
+        /**
+         * Checks if the given MemberExpression node is a potentially implied eval identifier on window.
+         * @param {ASTNode} node The MemberExpression node to check.
+         * @returns {boolean} Whether or not the given node is potentially an implied eval.
+         * @private
+         */
+        function isImpliedEvalMemberExpression(node) {
+            const object = node.object,
+                property = node.property,
+                hasImpliedEvalName = CALLEE_RE.test(property.name) || CALLEE_RE.test(property.value);
+
+            return object.name === "window" && hasImpliedEvalName;
+        }
+
+        /**
+         * Determines if a node represents a call to a potentially implied eval.
+         *
+         * This checks the callee name and that there's an argument, but not the type of the argument.
+         *
+         * @param {ASTNode} node The CallExpression to check.
+         * @returns {boolean} True if the node matches, false if not.
+         * @private
+         */
+        function isImpliedEvalCallExpression(node) {
+            const isMemberExpression = (node.callee.type === "MemberExpression"),
+                isIdentifier = (node.callee.type === "Identifier"),
+                isImpliedEvalCallee =
+                    (isIdentifier && CALLEE_RE.test(node.callee.name)) ||
+                    (isMemberExpression && isImpliedEvalMemberExpression(node.callee));
+
+            return isImpliedEvalCallee && node.arguments.length;
+        }
+
+        /**
+         * Checks that the parent is a direct descendent of an potential implied eval CallExpression, and if the parent is a CallExpression, that we're the first argument.
+         * @param {ASTNode} node The node to inspect the parent of.
+         * @returns {boolean} Was the parent a direct descendent, and is the child therefore potentially part of a dangerous argument?
+         * @private
+         */
+        function hasImpliedEvalParent(node) {
+
+            // make sure our parent is marked
+            return node.parent === last(last(impliedEvalAncestorsStack)) &&
+
+                // if our parent is a CallExpression, make sure we're the first argument
+                (node.parent.type !== "CallExpression" || node === node.parent.arguments[0]);
+        }
+
+        /**
+         * Checks if our parent is marked as part of an implied eval argument. If
+         * so, collapses the top of impliedEvalAncestorsStack and reports on the
+         * original CallExpression.
+         * @param {ASTNode} node The CallExpression to check.
+         * @returns {boolean} True if the node matches, false if not.
+         * @private
+         */
+        function checkString(node) {
+            if (hasImpliedEvalParent(node)) {
+
+                // remove the entire substack, to avoid duplicate reports
+                const substack = impliedEvalAncestorsStack.pop();
+
+                context.report({ node: substack[0], message: "Implied eval. Consider passing a function instead of a string." });
+            }
+        }
+
+        //--------------------------------------------------------------------------
+        // Public
+        //--------------------------------------------------------------------------
+
+        return {
+            CallExpression(node) {
+                if (isImpliedEvalCallExpression(node)) {
+
+                    // call expressions create a new substack
+                    impliedEvalAncestorsStack.push([node]);
+                }
+            },
+
+            "CallExpression:exit"(node) {
+                if (node === last(last(impliedEvalAncestorsStack))) {
+
+                    /*
+                     * Destroys the entire sub-stack, rather than just using
+                     * last(impliedEvalAncestorsStack).pop(), as a CallExpression is
+                     * always the bottom of a impliedEvalAncestorsStack substack.
+                     */
+                    impliedEvalAncestorsStack.pop();
+                }
+            },
+
+            BinaryExpression(node) {
+                if (node.operator === "+" && hasImpliedEvalParent(node)) {
+                    last(impliedEvalAncestorsStack).push(node);
+                }
+            },
+
+            "BinaryExpression:exit"(node) {
+                if (node === last(last(impliedEvalAncestorsStack))) {
+                    last(impliedEvalAncestorsStack).pop();
+                }
+            },
+
+            Literal(node) {
+                if (typeof node.value === "string") {
+                    checkString(node);
+                }
+            },
+
+            TemplateLiteral(node) {
+                checkString(node);
+            }
+        };
+
+    }
+};

package/packages/less/node_modules/eslint/lib/rules/no-inline-comments.js

@@ -0,0 +1,68 @@
+/**
+ * @fileoverview Enforces or disallows inline comments.
+ * @author Greg Cochard
+ */
+"use strict";
+
+const astUtils = require("../util/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "disallow inline comments after code",
+            category: "Stylistic Issues",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/no-inline-comments"
+        },
+
+        schema: []
+    },
+
+    create(context) {
+        const sourceCode = context.getSourceCode();
+
+        /**
+         * Will check that comments are not on lines starting with or ending with code
+         * @param {ASTNode} node The comment node to check
+         * @private
+         * @returns {void}
+         */
+        function testCodeAroundComment(node) {
+
+            // Get the whole line and cut it off at the start of the comment
+            const startLine = String(sourceCode.lines[node.loc.start.line - 1]);
+            const endLine = String(sourceCode.lines[node.loc.end.line - 1]);
+
+            const preamble = startLine.slice(0, node.loc.start.column).trim();
+
+            // Also check after the comment
+            const postamble = endLine.slice(node.loc.end.column).trim();
+
+            // Check that this comment isn't an ESLint directive
+            const isDirective = astUtils.isDirectiveComment(node);
+
+            // Should be empty if there was only whitespace around the comment
+            if (!isDirective && (preamble || postamble)) {
+                context.report({ node, message: "Unexpected comment inline with code." });
+            }
+        }
+
+        //--------------------------------------------------------------------------
+        // Public
+        //--------------------------------------------------------------------------
+
+        return {
+            Program() {
+                const comments = sourceCode.getAllComments();
+
+                comments.filter(token => token.type !== "Shebang").forEach(testCodeAroundComment);
+            }
+        };
+    }
+};

package/packages/less/node_modules/eslint/lib/rules/no-inner-declarations.js

@@ -0,0 +1,92 @@
+/**
+ * @fileoverview Rule to enforce declarations in program or function body root.
+ * @author Brandon Mills
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        type: "problem",
+
+        docs: {
+            description: "disallow variable or `function` declarations in nested blocks",
+            category: "Possible Errors",
+            recommended: true,
+            url: "https://eslint.org/docs/rules/no-inner-declarations"
+        },
+
+        schema: [
+            {
+                enum: ["functions", "both"]
+            }
+        ]
+    },
+
+    create(context) {
+
+        /**
+         * Find the nearest Program or Function ancestor node.
+         * @returns {Object} Ancestor's type and distance from node.
+         */
+        function nearestBody() {
+            const ancestors = context.getAncestors();
+            let ancestor = ancestors.pop(),
+                generation = 1;
+
+            while (ancestor && ["Program", "FunctionDeclaration",
+                "FunctionExpression", "ArrowFunctionExpression"
+            ].indexOf(ancestor.type) < 0) {
+                generation += 1;
+                ancestor = ancestors.pop();
+            }
+
+            return {
+
+                // Type of containing ancestor
+                type: ancestor.type,
+
+                // Separation between ancestor and node
+                distance: generation
+            };
+        }
+
+        /**
+         * Ensure that a given node is at a program or function body's root.
+         * @param {ASTNode} node Declaration node to check.
+         * @returns {void}
+         */
+        function check(node) {
+            const body = nearestBody(),
+                valid = ((body.type === "Program" && body.distance === 1) ||
+                    body.distance === 2);
+
+            if (!valid) {
+                context.report({
+                    node,
+                    message: "Move {{type}} declaration to {{body}} root.",
+                    data: {
+                        type: (node.type === "FunctionDeclaration" ? "function" : "variable"),
+                        body: (body.type === "Program" ? "program" : "function body")
+                    }
+                });
+            }
+        }
+
+        return {
+
+            FunctionDeclaration: check,
+            VariableDeclaration(node) {
+                if (context.options[0] === "both" && node.kind === "var") {
+                    check(node);
+                }
+            }
+
+        };
+
+    }
+};