less 3.10.1 → 3.11.1

package/packages/less/node_modules/eslint/lib/rules/no-self-compare.js

@@ -0,0 +1,56 @@
+/**
+ * @fileoverview Rule to flag comparison where left part is the same as the right
+ * part.
+ * @author Ilya Volodin
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        type: "problem",
+
+        docs: {
+            description: "disallow comparisons where both sides are exactly the same",
+            category: "Best Practices",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/no-self-compare"
+        },
+
+        schema: []
+    },
+
+    create(context) {
+        const sourceCode = context.getSourceCode();
+
+        /**
+         * Determines whether two nodes are composed of the same tokens.
+         * @param {ASTNode} nodeA The first node
+         * @param {ASTNode} nodeB The second node
+         * @returns {boolean} true if the nodes have identical token representations
+         */
+        function hasSameTokens(nodeA, nodeB) {
+            const tokensA = sourceCode.getTokens(nodeA);
+            const tokensB = sourceCode.getTokens(nodeB);
+
+            return tokensA.length === tokensB.length &&
+                tokensA.every((token, index) => token.type === tokensB[index].type && token.value === tokensB[index].value);
+        }
+
+        return {
+
+            BinaryExpression(node) {
+                const operators = new Set(["===", "==", "!==", "!=", ">", "<", ">=", "<="]);
+
+                if (operators.has(node.operator) && hasSameTokens(node.left, node.right)) {
+                    context.report({ node, message: "Comparing to itself is potentially pointless." });
+                }
+            }
+        };
+
+    }
+};

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

@@ -0,0 +1,115 @@
+/**
+ * @fileoverview Rule to flag use of comma operator
+ * @author Brandon Mills
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("../util/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "disallow comma operators",
+            category: "Best Practices",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/no-sequences"
+        },
+
+        schema: []
+    },
+
+    create(context) {
+        const sourceCode = context.getSourceCode();
+
+        /**
+         * Parts of the grammar that are required to have parens.
+         */
+        const parenthesized = {
+            DoWhileStatement: "test",
+            IfStatement: "test",
+            SwitchStatement: "discriminant",
+            WhileStatement: "test",
+            WithStatement: "object",
+            ArrowFunctionExpression: "body"
+
+            /*
+             * Omitting CallExpression - commas are parsed as argument separators
+             * Omitting NewExpression - commas are parsed as argument separators
+             * Omitting ForInStatement - parts aren't individually parenthesised
+             * Omitting ForStatement - parts aren't individually parenthesised
+             */
+        };
+
+        /**
+         * Determines whether a node is required by the grammar to be wrapped in
+         * parens, e.g. the test of an if statement.
+         * @param {ASTNode} node - The AST node
+         * @returns {boolean} True if parens around node belong to parent node.
+         */
+        function requiresExtraParens(node) {
+            return node.parent && parenthesized[node.parent.type] &&
+                    node === node.parent[parenthesized[node.parent.type]];
+        }
+
+        /**
+         * Check if a node is wrapped in parens.
+         * @param {ASTNode} node - The AST node
+         * @returns {boolean} True if the node has a paren on each side.
+         */
+        function isParenthesised(node) {
+            return astUtils.isParenthesised(sourceCode, node);
+        }
+
+        /**
+         * Check if a node is wrapped in two levels of parens.
+         * @param {ASTNode} node - The AST node
+         * @returns {boolean} True if two parens surround the node on each side.
+         */
+        function isParenthesisedTwice(node) {
+            const previousToken = sourceCode.getTokenBefore(node, 1),
+                nextToken = sourceCode.getTokenAfter(node, 1);
+
+            return isParenthesised(node) && previousToken && nextToken &&
+                astUtils.isOpeningParenToken(previousToken) && previousToken.range[1] <= node.range[0] &&
+                astUtils.isClosingParenToken(nextToken) && nextToken.range[0] >= node.range[1];
+        }
+
+        return {
+            SequenceExpression(node) {
+
+                // Always allow sequences in for statement update
+                if (node.parent.type === "ForStatement" &&
+                        (node === node.parent.init || node === node.parent.update)) {
+                    return;
+                }
+
+                // Wrapping a sequence in extra parens indicates intent
+                if (requiresExtraParens(node)) {
+                    if (isParenthesisedTwice(node)) {
+                        return;
+                    }
+                } else {
+                    if (isParenthesised(node)) {
+                        return;
+                    }
+                }
+
+                const child = sourceCode.getTokenAfter(node.expressions[0]);
+
+                context.report({ node, loc: child.loc.start, message: "Unexpected use of comma operator." });
+            }
+        };
+
+    }
+};

package/packages/less/node_modules/eslint/lib/rules/no-shadow-restricted-names.js

@@ -0,0 +1,60 @@
+/**
+ * @fileoverview Disallow shadowing of NaN, undefined, and Infinity (ES5 section 15.1.1)
+ * @author Michael Ficarra
+ */
+"use strict";
+
+/**
+ * Determines if a variable safely shadows undefined.
+ * This is the case when a variable named `undefined` is never assigned to a value (i.e. it always shares the same value
+ * as the global).
+ * @param {eslintScope.Variable} variable The variable to check
+ * @returns {boolean} true if this variable safely shadows `undefined`
+ */
+function safelyShadowsUndefined(variable) {
+    return variable.name === "undefined" &&
+        variable.references.every(ref => !ref.isWrite()) &&
+        variable.defs.every(def => def.node.type === "VariableDeclarator" && def.node.init === null);
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "disallow identifiers from shadowing restricted names",
+            category: "Variables",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/no-shadow-restricted-names"
+        },
+
+        schema: []
+    },
+
+    create(context) {
+
+
+        const RESTRICTED = new Set(["undefined", "NaN", "Infinity", "arguments", "eval"]);
+
+        return {
+            "VariableDeclaration, :function, CatchClause"(node) {
+                for (const variable of context.getDeclaredVariables(node)) {
+                    if (variable.defs.length > 0 && RESTRICTED.has(variable.name) && !safelyShadowsUndefined(variable)) {
+                        context.report({
+                            node: variable.defs[0].name,
+                            message: "Shadowing of global property '{{idName}}'.",
+                            data: {
+                                idName: variable.name
+                            }
+                        });
+                    }
+                }
+            }
+        };
+
+    }
+};

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

@@ -0,0 +1,191 @@
+/**
+ * @fileoverview Rule to flag on declaring variables already declared in the outer scope
+ * @author Ilya Volodin
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("../util/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "disallow variable declarations from shadowing variables declared in the outer scope",
+            category: "Variables",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/no-shadow"
+        },
+
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    builtinGlobals: { type: "boolean", default: false },
+                    hoist: { enum: ["all", "functions", "never"], default: "functions" },
+                    allow: {
+                        type: "array",
+                        items: {
+                            type: "string"
+                        }
+                    }
+                },
+                additionalProperties: false
+            }
+        ]
+    },
+
+    create(context) {
+
+        const options = {
+            builtinGlobals: context.options[0] && context.options[0].builtinGlobals,
+            hoist: (context.options[0] && context.options[0].hoist) || "functions",
+            allow: (context.options[0] && context.options[0].allow) || []
+        };
+
+        /**
+         * Check if variable name is allowed.
+         *
+         * @param  {ASTNode} variable The variable to check.
+         * @returns {boolean} Whether or not the variable name is allowed.
+         */
+        function isAllowed(variable) {
+            return options.allow.indexOf(variable.name) !== -1;
+        }
+
+        /**
+         * Checks if a variable of the class name in the class scope of ClassDeclaration.
+         *
+         * ClassDeclaration creates two variables of its name into its outer scope and its class scope.
+         * So we should ignore the variable in the class scope.
+         *
+         * @param {Object} variable The variable to check.
+         * @returns {boolean} Whether or not the variable of the class name in the class scope of ClassDeclaration.
+         */
+        function isDuplicatedClassNameVariable(variable) {
+            const block = variable.scope.block;
+
+            return block.type === "ClassDeclaration" && block.id === variable.identifiers[0];
+        }
+
+        /**
+         * Checks if a variable is inside the initializer of scopeVar.
+         *
+         * To avoid reporting at declarations such as `var a = function a() {};`.
+         * But it should report `var a = function(a) {};` or `var a = function() { function a() {} };`.
+         *
+         * @param {Object} variable The variable to check.
+         * @param {Object} scopeVar The scope variable to look for.
+         * @returns {boolean} Whether or not the variable is inside initializer of scopeVar.
+         */
+        function isOnInitializer(variable, scopeVar) {
+            const outerScope = scopeVar.scope;
+            const outerDef = scopeVar.defs[0];
+            const outer = outerDef && outerDef.parent && outerDef.parent.range;
+            const innerScope = variable.scope;
+            const innerDef = variable.defs[0];
+            const inner = innerDef && innerDef.name.range;
+
+            return (
+                outer &&
+                inner &&
+                outer[0] < inner[0] &&
+                inner[1] < outer[1] &&
+                ((innerDef.type === "FunctionName" && innerDef.node.type === "FunctionExpression") || innerDef.node.type === "ClassExpression") &&
+                outerScope === innerScope.upper
+            );
+        }
+
+        /**
+         * Get a range of a variable's identifier node.
+         * @param {Object} variable The variable to get.
+         * @returns {Array|undefined} The range of the variable's identifier node.
+         */
+        function getNameRange(variable) {
+            const def = variable.defs[0];
+
+            return def && def.name.range;
+        }
+
+        /**
+         * Checks if a variable is in TDZ of scopeVar.
+         * @param {Object} variable The variable to check.
+         * @param {Object} scopeVar The variable of TDZ.
+         * @returns {boolean} Whether or not the variable is in TDZ of scopeVar.
+         */
+        function isInTdz(variable, scopeVar) {
+            const outerDef = scopeVar.defs[0];
+            const inner = getNameRange(variable);
+            const outer = getNameRange(scopeVar);
+
+            return (
+                inner &&
+                outer &&
+                inner[1] < outer[0] &&
+
+                // Excepts FunctionDeclaration if is {"hoist":"function"}.
+                (options.hoist !== "functions" || !outerDef || outerDef.node.type !== "FunctionDeclaration")
+            );
+        }
+
+        /**
+         * Checks the current context for shadowed variables.
+         * @param {Scope} scope - Fixme
+         * @returns {void}
+         */
+        function checkForShadows(scope) {
+            const variables = scope.variables;
+
+            for (let i = 0; i < variables.length; ++i) {
+                const variable = variables[i];
+
+                // Skips "arguments" or variables of a class name in the class scope of ClassDeclaration.
+                if (variable.identifiers.length === 0 ||
+                    isDuplicatedClassNameVariable(variable) ||
+                    isAllowed(variable)
+                ) {
+                    continue;
+                }
+
+                // Gets shadowed variable.
+                const shadowed = astUtils.getVariableByName(scope.upper, variable.name);
+
+                if (shadowed &&
+                    (shadowed.identifiers.length > 0 || (options.builtinGlobals && "writeable" in shadowed)) &&
+                    !isOnInitializer(variable, shadowed) &&
+                    !(options.hoist !== "all" && isInTdz(variable, shadowed))
+                ) {
+                    context.report({
+                        node: variable.identifiers[0],
+                        message: "'{{name}}' is already declared in the upper scope.",
+                        data: variable
+                    });
+                }
+            }
+        }
+
+        return {
+            "Program:exit"() {
+                const globalScope = context.getScope();
+                const stack = globalScope.childScopes.slice();
+
+                while (stack.length) {
+                    const scope = stack.pop();
+
+                    stack.push(...scope.childScopes);
+                    checkForShadows(scope);
+                }
+            }
+        };
+
+    }
+};

package/packages/less/node_modules/eslint/lib/rules/no-spaced-func.js

@@ -0,0 +1,79 @@
+/**
+ * @fileoverview Rule to check that spaced function application
+ * @author Matt DuVall <http://www.mattduvall.com>
+ * @deprecated in ESLint v3.3.0
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        type: "layout",
+
+        docs: {
+            description: "disallow spacing between function identifiers and their applications (deprecated)",
+            category: "Stylistic Issues",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/no-spaced-func"
+        },
+
+        deprecated: true,
+
+        replacedBy: ["func-call-spacing"],
+
+        fixable: "whitespace",
+        schema: []
+    },
+
+    create(context) {
+
+        const sourceCode = context.getSourceCode();
+
+        /**
+         * Check if open space is present in a function name
+         * @param {ASTNode} node node to evaluate
+         * @returns {void}
+         * @private
+         */
+        function detectOpenSpaces(node) {
+            const lastCalleeToken = sourceCode.getLastToken(node.callee);
+            let prevToken = lastCalleeToken,
+                parenToken = sourceCode.getTokenAfter(lastCalleeToken);
+
+            // advances to an open parenthesis.
+            while (
+                parenToken &&
+                parenToken.range[1] < node.range[1] &&
+                parenToken.value !== "("
+            ) {
+                prevToken = parenToken;
+                parenToken = sourceCode.getTokenAfter(parenToken);
+            }
+
+            // look for a space between the callee and the open paren
+            if (parenToken &&
+                parenToken.range[1] < node.range[1] &&
+                sourceCode.isSpaceBetweenTokens(prevToken, parenToken)
+            ) {
+                context.report({
+                    node,
+                    loc: lastCalleeToken.loc.start,
+                    message: "Unexpected space between function name and paren.",
+                    fix(fixer) {
+                        return fixer.removeRange([prevToken.range[1], parenToken.range[0]]);
+                    }
+                });
+            }
+        }
+
+        return {
+            CallExpression: detectOpenSpaces,
+            NewExpression: detectOpenSpaces
+        };
+
+    }
+};

package/packages/less/node_modules/eslint/lib/rules/no-sparse-arrays.js

@@ -0,0 +1,46 @@
+/**
+ * @fileoverview Disallow sparse arrays
+ * @author Nicholas C. Zakas
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        type: "problem",
+
+        docs: {
+            description: "disallow sparse arrays",
+            category: "Possible Errors",
+            recommended: true,
+            url: "https://eslint.org/docs/rules/no-sparse-arrays"
+        },
+
+        schema: []
+    },
+
+    create(context) {
+
+
+        //--------------------------------------------------------------------------
+        // Public
+        //--------------------------------------------------------------------------
+
+        return {
+
+            ArrayExpression(node) {
+
+                const emptySpot = node.elements.indexOf(null) > -1;
+
+                if (emptySpot) {
+                    context.report({ node, message: "Unexpected comma in middle of array." });
+                }
+            }
+
+        };
+
+    }
+};

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

@@ -0,0 +1,57 @@
+/**
+ * @fileoverview Rule to check for properties whose identifier ends with the string Sync
+ * @author Matt DuVall<http://mattduvall.com/>
+ */
+
+/* jshint node:true */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "disallow synchronous methods",
+            category: "Node.js and CommonJS",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/no-sync"
+        },
+
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    allowAtRootLevel: {
+                        type: "boolean",
+                        default: false
+                    }
+                },
+                additionalProperties: false
+            }
+        ]
+    },
+
+    create(context) {
+        const selector = context.options[0] && context.options[0].allowAtRootLevel
+            ? ":function MemberExpression[property.name=/.*Sync$/]"
+            : "MemberExpression[property.name=/.*Sync$/]";
+
+        return {
+            [selector](node) {
+                context.report({
+                    node,
+                    message: "Unexpected sync method: '{{propertyName}}'.",
+                    data: {
+                        propertyName: node.property.name
+                    }
+                });
+            }
+        };
+
+    }
+};

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

@@ -0,0 +1,68 @@
+/**
+ * @fileoverview Rule to check for tabs inside a file
+ * @author Gyandeep Singh
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const tabRegex = /\t+/gu;
+const anyNonWhitespaceRegex = /\S/u;
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        type: "layout",
+
+        docs: {
+            description: "disallow all tabs",
+            category: "Stylistic Issues",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/no-tabs"
+        },
+        schema: [{
+            type: "object",
+            properties: {
+                allowIndentationTabs: {
+                    type: "boolean",
+                    default: false
+                }
+            },
+            additionalProperties: false
+        }]
+    },
+
+    create(context) {
+        const sourceCode = context.getSourceCode();
+        const allowIndentationTabs = context.options && context.options[0] && context.options[0].allowIndentationTabs;
+
+        return {
+            Program(node) {
+                sourceCode.getLines().forEach((line, index) => {
+                    let match;
+
+                    while ((match = tabRegex.exec(line)) !== null) {
+                        if (allowIndentationTabs && !anyNonWhitespaceRegex.test(line.slice(0, match.index))) {
+                            continue;
+                        }
+
+                        context.report({
+                            node,
+                            loc: {
+                                line: index + 1,
+                                column: match.index
+                            },
+                            message: "Unexpected tab character."
+                        });
+                    }
+                });
+            }
+        };
+    }
+};