less 3.10.1 → 3.11.1

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/dist/rules/ban-types.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util = __importStar(require("../util"));
+function stringifyTypeName(node, sourceCode) {
+    return sourceCode.getText(node).replace(/ /g, '');
+}
+function getCustomMessage(bannedType) {
+    if (bannedType === null) {
+        return '';
+    }
+    if (typeof bannedType === 'string') {
+        return ` ${bannedType}`;
+    }
+    if (bannedType.message) {
+        return ` ${bannedType.message}`;
+    }
+    return '';
+}
+exports.default = util.createRule({
+    name: 'ban-types',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforces that types will not to be used',
+            category: 'Best Practices',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        messages: {
+            bannedTypeMessage: "Don't use '{{name}}' as a type.{{customMessage}}",
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    types: {
+                        type: 'object',
+                        additionalProperties: {
+                            oneOf: [
+                                { type: 'null' },
+                                { type: 'string' },
+                                {
+                                    type: 'object',
+                                    properties: {
+                                        message: { type: 'string' },
+                                        fixWith: { type: 'string' },
+                                    },
+                                    additionalProperties: false,
+                                },
+                            ],
+                        },
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [
+        {
+            types: {
+                String: {
+                    message: 'Use string instead',
+                    fixWith: 'string',
+                },
+                Boolean: {
+                    message: 'Use boolean instead',
+                    fixWith: 'boolean',
+                },
+                Number: {
+                    message: 'Use number instead',
+                    fixWith: 'number',
+                },
+                Object: {
+                    message: 'Use Record<string, any> instead',
+                    fixWith: 'Record<string, any>',
+                },
+                Symbol: {
+                    message: 'Use symbol instead',
+                    fixWith: 'symbol',
+                },
+            },
+        },
+    ],
+    create(context, [{ types: bannedTypes }]) {
+        return {
+            TSTypeReference({ typeName }) {
+                const name = stringifyTypeName(typeName, context.getSourceCode());
+                if (name in bannedTypes) {
+                    const bannedType = bannedTypes[name];
+                    const customMessage = getCustomMessage(bannedType);
+                    const fixWith = bannedType && bannedType.fixWith;
+                    context.report({
+                        node: typeName,
+                        messageId: 'bannedTypeMessage',
+                        data: {
+                            name: name,
+                            customMessage,
+                        },
+                        fix: fixWith ? fixer => fixer.replaceText(typeName, fixWith) : null,
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=ban-types.js.map

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/dist/rules/ban-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ban-types.js","sourceRoot":"","sources":["../../src/rules/ban-types.ts"],"names":[],"mappings":"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"}

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/dist/rules/camelcase.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const experimental_utils_1 = require("@typescript-eslint/experimental-utils");
+const camelcase_1 = __importDefault(require("eslint/lib/rules/camelcase"));
+const util = __importStar(require("../util"));
+exports.default = util.createRule({
+    name: 'camelcase',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce camelCase naming convention',
+            category: 'Stylistic Issues',
+            recommended: 'error',
+        },
+        schema: camelcase_1.default.meta.schema,
+        messages: camelcase_1.default.meta.messages,
+    },
+    defaultOptions: [
+        {
+            allow: ['^UNSAFE_'],
+            ignoreDestructuring: false,
+            properties: 'never',
+        },
+    ],
+    create(context, [options]) {
+        const rules = camelcase_1.default.create(context);
+        const TS_PROPERTY_TYPES = [
+            experimental_utils_1.AST_NODE_TYPES.TSPropertySignature,
+            experimental_utils_1.AST_NODE_TYPES.ClassProperty,
+            experimental_utils_1.AST_NODE_TYPES.TSParameterProperty,
+            experimental_utils_1.AST_NODE_TYPES.TSAbstractClassProperty,
+        ];
+        const properties = options.properties;
+        const allow = options.allow;
+        /**
+         * Checks if a string contains an underscore and isn't all upper-case
+         * @param  name The string to check.
+         */
+        function isUnderscored(name) {
+            // if there's an underscore, it might be A_CONSTANT, which is okay
+            return name.indexOf('_') > -1 && name !== name.toUpperCase();
+        }
+        /**
+         * Checks if a string match the ignore list
+         * @param name The string to check.
+         * @returns if the string is ignored
+         * @private
+         */
+        function isAllowed(name) {
+            return (allow.findIndex(entry => name === entry || name.match(new RegExp(entry)) !== null) !== -1);
+        }
+        /**
+         * Checks if the the node is a valid TypeScript property type.
+         * @param node the node to be validated.
+         * @returns true if the node is a TypeScript property type.
+         * @private
+         */
+        function isTSPropertyType(node) {
+            if (!node.parent) {
+                return false;
+            }
+            if (TS_PROPERTY_TYPES.includes(node.parent.type)) {
+                return true;
+            }
+            if (node.parent.type === experimental_utils_1.AST_NODE_TYPES.AssignmentPattern) {
+                return (node.parent.parent !== undefined &&
+                    TS_PROPERTY_TYPES.includes(node.parent.parent.type));
+            }
+            return false;
+        }
+        return {
+            Identifier(node) {
+                /*
+                 * Leading and trailing underscores are commonly used to flag
+                 * private/protected identifiers, strip them
+                 */
+                const name = node.name.replace(/^_+|_+$/g, '');
+                // First, we ignore the node if it match the ignore list
+                if (isAllowed(name)) {
+                    return;
+                }
+                // Check TypeScript specific nodes
+                if (isTSPropertyType(node)) {
+                    if (properties === 'always' && isUnderscored(name)) {
+                        context.report({
+                            node,
+                            messageId: 'notCamelCase',
+                            data: { name: node.name },
+                        });
+                    }
+                    return;
+                }
+                // Let the base rule deal with the rest
+                rules.Identifier(node);
+            },
+        };
+    },
+});
+//# sourceMappingURL=camelcase.js.map

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/dist/rules/camelcase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"camelcase.js","sourceRoot":"","sources":["../../src/rules/camelcase.ts"],"names":[],"mappings":"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"}

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/dist/rules/class-name-casing.js

@@ -0,0 +1,91 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const experimental_utils_1 = require("@typescript-eslint/experimental-utils");
+const util = __importStar(require("../util"));
+exports.default = util.createRule({
+    name: 'class-name-casing',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Require PascalCased class and interface names',
+            category: 'Best Practices',
+            recommended: 'error',
+        },
+        messages: {
+            notPascalCased: "{{friendlyName}} '{{name}}' must be PascalCased.",
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        /**
+         * Determine if the identifier name is PascalCased
+         * @param name The identifier name
+         */
+        function isPascalCase(name) {
+            return /^[A-Z][0-9A-Za-z]*$/.test(name);
+        }
+        /**
+         * Report a class declaration as invalid
+         * @param decl The declaration
+         * @param id The name of the declaration
+         */
+        function report(decl, id) {
+            let friendlyName;
+            switch (decl.type) {
+                case experimental_utils_1.AST_NODE_TYPES.ClassDeclaration:
+                case experimental_utils_1.AST_NODE_TYPES.ClassExpression:
+                    friendlyName = decl.abstract ? 'Abstract class' : 'Class';
+                    break;
+                case experimental_utils_1.AST_NODE_TYPES.TSInterfaceDeclaration:
+                    friendlyName = 'Interface';
+                    break;
+                default:
+                    friendlyName = decl.type;
+            }
+            context.report({
+                node: id,
+                messageId: 'notPascalCased',
+                data: {
+                    friendlyName,
+                    name: id.name,
+                },
+            });
+        }
+        return {
+            'ClassDeclaration, TSInterfaceDeclaration, ClassExpression'(node) {
+                // class expressions (i.e. export default class {}) are OK
+                if (node.id && !isPascalCase(node.id.name)) {
+                    report(node, node.id);
+                }
+            },
+            "VariableDeclarator[init.type='ClassExpression']"(node) {
+                if (node.id.type === experimental_utils_1.AST_NODE_TYPES.ArrayPattern ||
+                    node.id.type === experimental_utils_1.AST_NODE_TYPES.ObjectPattern) {
+                    // TODO - handle the BindingPattern case maybe?
+                    /*
+                    // this example makes me barf, but it's valid code
+                    var { bar } = class {
+                      static bar() { return 2 }
+                    }
+                    */
+                }
+                else {
+                    const id = node.id;
+                    const nodeInit = node.init;
+                    if (id && !nodeInit.id && !isPascalCase(id.name)) {
+                        report(nodeInit, id);
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=class-name-casing.js.map

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/dist/rules/class-name-casing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"class-name-casing.js","sourceRoot":"","sources":["../../src/rules/class-name-casing.ts"],"names":[],"mappings":";;;;;;;;;AAAA,8EAG+C;AAC/C,8CAAgC;AAEhC,kBAAe,IAAI,CAAC,UAAU,CAAC;IAC7B,IAAI,EAAE,mBAAmB;IACzB,IAAI,EAAE;QACJ,IAAI,EAAE,YAAY;QAClB,IAAI,EAAE;YACJ,WAAW,EAAE,+CAA+C;YAC5D,QAAQ,EAAE,gBAAgB;YAC1B,WAAW,EAAE,OAAO;SACrB;QACD,QAAQ,EAAE;YACR,cAAc,EAAE,kDAAkD;SACnE;QACD,MAAM,EAAE,EAAE;KACX;IACD,cAAc,EAAE,EAAE;IAClB,MAAM,CAAC,OAAO;QACZ;;;WAGG;QACH,SAAS,YAAY,CAAC,IAAY;YAChC,OAAO,qBAAqB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC1C,CAAC;QAED;;;;WAIG;QACH,SAAS,MAAM,CAAC,IAAmB,EAAE,EAAuB;YAC1D,IAAI,YAAY,CAAC;YAEjB,QAAQ,IAAI,CAAC,IAAI,EAAE;gBACjB,KAAK,mCAAc,CAAC,gBAAgB,CAAC;gBACrC,KAAK,mCAAc,CAAC,eAAe;oBACjC,YAAY,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,OAAO,CAAC;oBAC1D,MAAM;gBACR,KAAK,mCAAc,CAAC,sBAAsB;oBACxC,YAAY,GAAG,WAAW,CAAC;oBAC3B,MAAM;gBACR;oBACE,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC;aAC5B;YAED,OAAO,CAAC,MAAM,CAAC;gBACb,IAAI,EAAE,EAAE;gBACR,SAAS,EAAE,gBAAgB;gBAC3B,IAAI,EAAE;oBACJ,YAAY;oBACZ,IAAI,EAAE,EAAE,CAAC,IAAI;iBACd;aACF,CAAC,CAAC;QACL,CAAC;QAED,OAAO;YACL,2DAA2D,CACzD,IAG4B;gBAE5B,0DAA0D;gBAC1D,IAAI,IAAI,CAAC,EAAE,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE;oBAC1C,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC;iBACvB;YACH,CAAC;YACD,iDAAiD,CAC/C,IAAiC;gBAEjC,IACE,IAAI,CAAC,EAAE,CAAC,IAAI,KAAK,mCAAc,CAAC,YAAY;oBAC5C,IAAI,CAAC,EAAE,CAAC,IAAI,KAAK,mCAAc,CAAC,aAAa,EAC7C;oBACA,+CAA+C;oBAC/C;;;;;sBAKE;iBACH;qBAAM;oBACL,MAAM,EAAE,GAAG,IAAI,CAAC,EAAE,CAAC;oBACnB,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAgC,CAAC;oBAEvD,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,EAAE,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE;wBAChD,MAAM,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;qBACtB;iBACF;YACH,CAAC;SACF,CAAC;IACJ,CAAC;CACF,CAAC,CAAC"}

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-type-definitions.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util = __importStar(require("../util"));
+exports.default = util.createRule({
+    name: 'consistent-type-definitions',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Consistent with type definition either `interface` or `type`',
+            category: 'Stylistic Issues',
+            recommended: false,
+        },
+        messages: {
+            interfaceOverType: 'Use an `interface` instead of a `type`',
+            typeOverInterface: 'Use a `type` instead of an `interface`',
+        },
+        schema: [
+            {
+                enum: ['interface', 'type'],
+            },
+        ],
+        fixable: 'code',
+    },
+    defaultOptions: ['interface'],
+    create(context, [option]) {
+        const sourceCode = context.getSourceCode();
+        return {
+            "TSTypeAliasDeclaration[typeAnnotation.type='TSTypeLiteral']"(node) {
+                if (option === 'interface') {
+                    context.report({
+                        node: node.id,
+                        messageId: 'interfaceOverType',
+                        fix(fixer) {
+                            const typeNode = node.typeParameters || node.id;
+                            const fixes = [];
+                            const firstToken = sourceCode.getFirstToken(node);
+                            if (firstToken) {
+                                fixes.push(fixer.replaceText(firstToken, 'interface'));
+                                fixes.push(fixer.replaceTextRange([typeNode.range[1], node.typeAnnotation.range[0]], ' '));
+                            }
+                            const afterToken = sourceCode.getTokenAfter(node.typeAnnotation);
+                            if (afterToken &&
+                                afterToken.type === 'Punctuator' &&
+                                afterToken.value === ';') {
+                                fixes.push(fixer.remove(afterToken));
+                            }
+                            return fixes;
+                        },
+                    });
+                }
+            },
+            TSInterfaceDeclaration(node) {
+                if (option === 'type') {
+                    context.report({
+                        node: node.id,
+                        messageId: 'typeOverInterface',
+                        fix(fixer) {
+                            const typeNode = node.typeParameters || node.id;
+                            const fixes = [];
+                            const firstToken = sourceCode.getFirstToken(node);
+                            if (firstToken) {
+                                fixes.push(fixer.replaceText(firstToken, 'type'));
+                                fixes.push(fixer.replaceTextRange([typeNode.range[1], node.body.range[0]], ' = '));
+                            }
+                            if (node.extends) {
+                                node.extends.forEach(heritage => {
+                                    const typeIdentifier = sourceCode.getText(heritage);
+                                    fixes.push(fixer.insertTextAfter(node.body, ` & ${typeIdentifier}`));
+                                });
+                            }
+                            return fixes;
+                        },
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=consistent-type-definitions.js.map

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/dist/rules/consistent-type-definitions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consistent-type-definitions.js","sourceRoot":"","sources":["../../src/rules/consistent-type-definitions.ts"],"names":[],"mappings":"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"}

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/dist/rules/explicit-function-return-type.js

@@ -0,0 +1,203 @@
+"use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const experimental_utils_1 = require("@typescript-eslint/experimental-utils");
+const util = __importStar(require("../util"));
+exports.default = util.createRule({
+    name: 'explicit-function-return-type',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Require explicit return types on functions and class methods',
+            category: 'Stylistic Issues',
+            recommended: 'warn',
+        },
+        messages: {
+            missingReturnType: 'Missing return type on function.',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    allowExpressions: {
+                        type: 'boolean',
+                    },
+                    allowTypedFunctionExpressions: {
+                        type: 'boolean',
+                    },
+                    allowHigherOrderFunctions: {
+                        type: 'boolean',
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [
+        {
+            allowExpressions: false,
+            allowTypedFunctionExpressions: false,
+            allowHigherOrderFunctions: false,
+        },
+    ],
+    create(context, [options]) {
+        /**
+         * Checks if a node is a constructor.
+         * @param node The node to check
+         */
+        function isConstructor(node) {
+            return (!!node &&
+                node.type === experimental_utils_1.AST_NODE_TYPES.MethodDefinition &&
+                node.kind === 'constructor');
+        }
+        /**
+         * Checks if a node is a setter.
+         */
+        function isSetter(node) {
+            return (!!node &&
+                (node.type === experimental_utils_1.AST_NODE_TYPES.MethodDefinition ||
+                    node.type === experimental_utils_1.AST_NODE_TYPES.Property) &&
+                node.kind === 'set');
+        }
+        /**
+         * Checks if a node is a variable declarator with a type annotation.
+         * `const x: Foo = ...`
+         */
+        function isVariableDeclaratorWithTypeAnnotation(node) {
+            return (node.type === experimental_utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                !!node.id.typeAnnotation);
+        }
+        /**
+         * Checks if a node is a class property with a type annotation.
+         * `public x: Foo = ...`
+         */
+        function isClassPropertyWithTypeAnnotation(node) {
+            return (node.type === experimental_utils_1.AST_NODE_TYPES.ClassProperty && !!node.typeAnnotation);
+        }
+        /**
+         * Checks if a node is a type cast
+         * `(() => {}) as Foo`
+         * `<Foo>(() => {})`
+         */
+        function isTypeCast(node) {
+            return (node.type === experimental_utils_1.AST_NODE_TYPES.TSAsExpression ||
+                node.type === experimental_utils_1.AST_NODE_TYPES.TSTypeAssertion);
+        }
+        /**
+         * Checks if a node belongs to:
+         * `const x: Foo = { prop: () => {} }`
+         * `const x = { prop: () => {} } as Foo`
+         * `const x = <Foo>{ prop: () => {} }`
+         */
+        function isPropertyOfObjectWithType(parent) {
+            if (!parent || parent.type !== experimental_utils_1.AST_NODE_TYPES.Property) {
+                return false;
+            }
+            parent = parent.parent; // this shouldn't happen, checking just in case
+            /* istanbul ignore if */ if (!parent ||
+                parent.type !== experimental_utils_1.AST_NODE_TYPES.ObjectExpression) {
+                return false;
+            }
+            parent = parent.parent; // this shouldn't happen, checking just in case
+            /* istanbul ignore if */ if (!parent) {
+                return false;
+            }
+            return (isTypeCast(parent) ||
+                isClassPropertyWithTypeAnnotation(parent) ||
+                isVariableDeclaratorWithTypeAnnotation(parent));
+        }
+        /**
+         * Checks if a function belongs to:
+         * `() => () => ...`
+         * `() => function () { ... }`
+         * `() => { return () => ... }`
+         * `() => { return function () { ... } }`
+         * `function fn() { return () => ... }`
+         * `function fn() { return function() { ... } }`
+         */
+        function doesImmediatelyReturnFunctionExpression({ body, }) {
+            // Should always have a body; really checking just in case
+            /* istanbul ignore if */ if (!body) {
+                return false;
+            }
+            // Check if body is a block with a single statement
+            if (body.type === experimental_utils_1.AST_NODE_TYPES.BlockStatement &&
+                body.body.length === 1) {
+                const [statement] = body.body;
+                // Check if that statement is a return statement with an argument
+                if (statement.type === experimental_utils_1.AST_NODE_TYPES.ReturnStatement &&
+                    !!statement.argument) {
+                    // If so, check that returned argument as body
+                    body = statement.argument;
+                }
+            }
+            // Check if the body being returned is a function expression
+            return (body.type === experimental_utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                body.type === experimental_utils_1.AST_NODE_TYPES.FunctionExpression);
+        }
+        /**
+         * Checks if a node belongs to:
+         * `foo(() => 1)`
+         */
+        function isFunctionArgument(parent, child) {
+            return (parent.type === experimental_utils_1.AST_NODE_TYPES.CallExpression &&
+                // make sure this isn't an IIFE
+                parent.callee !== child);
+        }
+        /**
+         * Checks if a function declaration/expression has a return type.
+         */
+        function checkFunctionReturnType(node) {
+            if (options.allowHigherOrderFunctions &&
+                doesImmediatelyReturnFunctionExpression(node)) {
+                return;
+            }
+            if (node.returnType ||
+                isConstructor(node.parent) ||
+                isSetter(node.parent)) {
+                return;
+            }
+            if (util.isTypeScriptFile(context.getFilename())) {
+                context.report({
+                    node,
+                    messageId: 'missingReturnType',
+                });
+            }
+        }
+        /**
+         * Checks if a function declaration/expression has a return type.
+         */
+        function checkFunctionExpressionReturnType(node) {
+            // Should always have a parent; checking just in case
+            /* istanbul ignore else */ if (node.parent) {
+                if (options.allowTypedFunctionExpressions) {
+                    if (isTypeCast(node.parent) ||
+                        isVariableDeclaratorWithTypeAnnotation(node.parent) ||
+                        isClassPropertyWithTypeAnnotation(node.parent) ||
+                        isPropertyOfObjectWithType(node.parent) ||
+                        isFunctionArgument(node.parent, node)) {
+                        return;
+                    }
+                }
+                if (options.allowExpressions &&
+                    node.parent.type !== experimental_utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                    node.parent.type !== experimental_utils_1.AST_NODE_TYPES.MethodDefinition) {
+                    return;
+                }
+            }
+            checkFunctionReturnType(node);
+        }
+        return {
+            ArrowFunctionExpression: checkFunctionExpressionReturnType,
+            FunctionDeclaration: checkFunctionReturnType,
+            FunctionExpression: checkFunctionExpressionReturnType,
+        };
+    },
+});
+//# sourceMappingURL=explicit-function-return-type.js.map

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/dist/rules/explicit-function-return-type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"explicit-function-return-type.js","sourceRoot":"","sources":["../../src/rules/explicit-function-return-type.ts"],"names":[],"mappings":"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"}