less 3.10.1 → 3.11.1

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

@@ -0,0 +1,107 @@
+"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 require_await_1 = __importDefault(require("eslint/lib/rules/require-await"));
+const tsutils = __importStar(require("tsutils"));
+const util = __importStar(require("../util"));
+exports.default = util.createRule({
+    name: 'require-await',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow async functions which have no `await` expression',
+            category: 'Best Practices',
+            recommended: false,
+        },
+        schema: require_await_1.default.meta.schema,
+        messages: require_await_1.default.meta.messages,
+    },
+    defaultOptions: [],
+    create(context) {
+        const rules = require_await_1.default.create(context);
+        const parserServices = util.getParserServices(context);
+        const checker = parserServices.program.getTypeChecker();
+        let scopeInfo = null;
+        /**
+         * Push the scope info object to the stack.
+         *
+         * @returns {void}
+         */
+        function enterFunction(node) {
+            scopeInfo = {
+                upper: scopeInfo,
+                returnsPromise: false,
+            };
+            switch (node.type) {
+                case experimental_utils_1.AST_NODE_TYPES.FunctionDeclaration:
+                    rules.FunctionDeclaration(node);
+                    break;
+                case experimental_utils_1.AST_NODE_TYPES.FunctionExpression:
+                    rules.FunctionExpression(node);
+                    break;
+                case experimental_utils_1.AST_NODE_TYPES.ArrowFunctionExpression:
+                    rules.ArrowFunctionExpression(node);
+                    break;
+            }
+        }
+        /**
+         * Pop the top scope info object from the stack.
+         * Passes through to the base rule if the function doesn't return a promise
+         *
+         * @param {ASTNode} node - The node exiting
+         * @returns {void}
+         */
+        function exitFunction(node) {
+            if (scopeInfo) {
+                if (!scopeInfo.returnsPromise) {
+                    switch (node.type) {
+                        case experimental_utils_1.AST_NODE_TYPES.FunctionDeclaration:
+                            rules['FunctionDeclaration:exit'](node);
+                            break;
+                        case experimental_utils_1.AST_NODE_TYPES.FunctionExpression:
+                            rules['FunctionExpression:exit'](node);
+                            break;
+                        case experimental_utils_1.AST_NODE_TYPES.ArrowFunctionExpression:
+                            rules['ArrowFunctionExpression:exit'](node);
+                            break;
+                    }
+                }
+                scopeInfo = scopeInfo.upper;
+            }
+        }
+        return {
+            'FunctionDeclaration[async = true]': enterFunction,
+            'FunctionExpression[async = true]': enterFunction,
+            'ArrowFunctionExpression[async = true]': enterFunction,
+            'FunctionDeclaration[async = true]:exit': exitFunction,
+            'FunctionExpression[async = true]:exit': exitFunction,
+            'ArrowFunctionExpression[async = true]:exit': exitFunction,
+            ReturnStatement(node) {
+                if (!scopeInfo) {
+                    return;
+                }
+                const { expression } = parserServices.esTreeNodeToTSNodeMap.get(node);
+                if (!expression) {
+                    return;
+                }
+                const type = checker.getTypeAtLocation(expression);
+                if (tsutils.isThenableType(checker, expression, type)) {
+                    scopeInfo.returnsPromise = true;
+                }
+            },
+            AwaitExpression: rules.AwaitExpression,
+            ForOfStatement: rules.ForOfStatement,
+        };
+    },
+});
+//# sourceMappingURL=require-await.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"require-await.js","sourceRoot":"","sources":["../../src/rules/require-await.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,8EAI+C;AAC/C,mFAAsD;AACtD,iDAAmC;AAEnC,8CAAgC;AAUhC,kBAAe,IAAI,CAAC,UAAU,CAAsB;IAClD,IAAI,EAAE,eAAe;IACrB,IAAI,EAAE;QACJ,IAAI,EAAE,YAAY;QAClB,IAAI,EAAE;YACJ,WAAW,EAAE,2DAA2D;YACxE,QAAQ,EAAE,gBAAgB;YAC1B,WAAW,EAAE,KAAK;SACnB;QACD,MAAM,EAAE,uBAAQ,CAAC,IAAI,CAAC,MAAM;QAC5B,QAAQ,EAAE,uBAAQ,CAAC,IAAI,CAAC,QAAQ;KACjC;IACD,cAAc,EAAE,EAAE;IAClB,MAAM,CAAC,OAAO;QACZ,MAAM,KAAK,GAAG,uBAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QACvC,MAAM,cAAc,GAAG,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC;QACvD,MAAM,OAAO,GAAG,cAAc,CAAC,OAAO,CAAC,cAAc,EAAE,CAAC;QAExD,IAAI,SAAS,GAAqB,IAAI,CAAC;QAEvC;;;;WAIG;QACH,SAAS,aAAa,CACpB,IAGoC;YAEpC,SAAS,GAAG;gBACV,KAAK,EAAE,SAAS;gBAChB,cAAc,EAAE,KAAK;aACtB,CAAC;YAEF,QAAQ,IAAI,CAAC,IAAI,EAAE;gBACjB,KAAK,mCAAc,CAAC,mBAAmB;oBACrC,KAAK,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;oBAChC,MAAM;gBAER,KAAK,mCAAc,CAAC,kBAAkB;oBACpC,KAAK,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;oBAC/B,MAAM;gBAER,KAAK,mCAAc,CAAC,uBAAuB;oBACzC,KAAK,CAAC,uBAAuB,CAAC,IAAI,CAAC,CAAC;oBACpC,MAAM;aACT;QACH,CAAC;QAED;;;;;;WAMG;QACH,SAAS,YAAY,CACnB,IAGoC;YAEpC,IAAI,SAAS,EAAE;gBACb,IAAI,CAAC,SAAS,CAAC,cAAc,EAAE;oBAC7B,QAAQ,IAAI,CAAC,IAAI,EAAE;wBACjB,KAAK,mCAAc,CAAC,mBAAmB;4BACrC,KAAK,CAAC,0BAA0B,CAAC,CAAC,IAAI,CAAC,CAAC;4BACxC,MAAM;wBAER,KAAK,mCAAc,CAAC,kBAAkB;4BACpC,KAAK,CAAC,yBAAyB,CAAC,CAAC,IAAI,CAAC,CAAC;4BACvC,MAAM;wBAER,KAAK,mCAAc,CAAC,uBAAuB;4BACzC,KAAK,CAAC,8BAA8B,CAAC,CAAC,IAAI,CAAC,CAAC;4BAC5C,MAAM;qBACT;iBACF;gBAED,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC;aAC7B;QACH,CAAC;QAED,OAAO;YACL,mCAAmC,EAAE,aAAa;YAClD,kCAAkC,EAAE,aAAa;YACjD,uCAAuC,EAAE,aAAa;YACtD,wCAAwC,EAAE,YAAY;YACtD,uCAAuC,EAAE,YAAY;YACrD,4CAA4C,EAAE,YAAY;YAE1D,eAAe,CAAC,IAA8B;gBAC5C,IAAI,CAAC,SAAS,EAAE;oBACd,OAAO;iBACR;gBAED,MAAM,EAAE,UAAU,EAAE,GAAG,cAAc,CAAC,qBAAqB,CAAC,GAAG,CAE7D,IAAI,CAAC,CAAC;gBACR,IAAI,CAAC,UAAU,EAAE;oBACf,OAAO;iBACR;gBAED,MAAM,IAAI,GAAG,OAAO,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC;gBACnD,IAAI,OAAO,CAAC,cAAc,CAAC,OAAO,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE;oBACrD,SAAS,CAAC,cAAc,GAAG,IAAI,CAAC;iBACjC;YACH,CAAC;YAED,eAAe,EAAE,KAAK,CAAC,eAEtB;YACD,cAAc,EAAE,KAAK,CAAC,cAErB;SACF,CAAC;IACJ,CAAC;CACF,CAAC,CAAC"}

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/dist/rules/restrict-plus-operands.js

@@ -0,0 +1,107 @@
+"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 typescript_1 = __importDefault(require("typescript"));
+const util = __importStar(require("../util"));
+exports.default = util.createRule({
+    name: 'restrict-plus-operands',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'When adding two variables, operands must both be of type number or of type string',
+            category: 'Best Practices',
+            recommended: false,
+        },
+        messages: {
+            notNumbers: "Operands of '+' operation must either be both strings or both numbers.",
+            notStrings: "Operands of '+' operation must either be both strings or both numbers. Consider using a template literal.",
+            notBigInts: "Operands of '+' operation must be both bigints.",
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        const service = util.getParserServices(context);
+        const typeChecker = service.program.getTypeChecker();
+        /**
+         * Helper function to get base type of node
+         */
+        function getBaseTypeOfLiteralType(type) {
+            const constraint = type.getConstraint();
+            if (constraint &&
+                // for generic types with union constraints, it will return itself from getConstraint
+                // so we have to guard against infinite recursion...
+                constraint !== type) {
+                return getBaseTypeOfLiteralType(constraint);
+            }
+            if (type.isNumberLiteral()) {
+                return 'number';
+            }
+            if (type.isStringLiteral()) {
+                return 'string';
+            }
+            // is BigIntLiteral
+            if (type.flags & typescript_1.default.TypeFlags.BigIntLiteral) {
+                return 'bigint';
+            }
+            if (type.isUnion()) {
+                const types = type.types.map(getBaseTypeOfLiteralType);
+                return types.every(value => value === types[0]) ? types[0] : 'invalid';
+            }
+            const stringType = typeChecker.typeToString(type);
+            if (stringType === 'number' ||
+                stringType === 'string' ||
+                stringType === 'bigint') {
+                return stringType;
+            }
+            return 'invalid';
+        }
+        /**
+         * Helper function to get base type of node
+         * @param node the node to be evaluated.
+         */
+        function getNodeType(node) {
+            const tsNode = service.esTreeNodeToTSNodeMap.get(node);
+            const type = typeChecker.getTypeAtLocation(tsNode);
+            return getBaseTypeOfLiteralType(type);
+        }
+        return {
+            "BinaryExpression[operator='+']"(node) {
+                const leftType = getNodeType(node.left);
+                const rightType = getNodeType(node.right);
+                if (leftType === 'invalid' ||
+                    rightType === 'invalid' ||
+                    leftType !== rightType) {
+                    if (leftType === 'string' || rightType === 'string') {
+                        context.report({
+                            node,
+                            messageId: 'notStrings',
+                        });
+                    }
+                    else if (leftType === 'bigint' || rightType === 'bigint') {
+                        context.report({
+                            node,
+                            messageId: 'notBigInts',
+                        });
+                    }
+                    else {
+                        context.report({
+                            node,
+                            messageId: 'notNumbers',
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=restrict-plus-operands.js.map

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/dist/rules/restrict-plus-operands.js.map

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

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

@@ -0,0 +1,66 @@
+"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 semi_1 = __importDefault(require("eslint/lib/rules/semi"));
+const util = __importStar(require("../util"));
+exports.default = util.createRule({
+    name: 'semi',
+    meta: {
+        type: 'layout',
+        docs: {
+            description: 'Require or disallow semicolons instead of ASI',
+            category: 'Stylistic Issues',
+            recommended: false,
+        },
+        fixable: 'code',
+        schema: semi_1.default.meta.schema,
+        messages: semi_1.default.meta.messages,
+    },
+    defaultOptions: [
+        'always',
+        {
+            omitLastInOneLineBlock: false,
+            beforeStatementContinuationChars: 'any',
+        },
+    ],
+    create(context) {
+        const rules = semi_1.default.create(context);
+        const checkForSemicolon = rules.ExpressionStatement;
+        /*
+          The following nodes are handled by the member-delimiter-style rule
+          AST_NODE_TYPES.TSCallSignatureDeclaration,
+          AST_NODE_TYPES.TSConstructSignatureDeclaration,
+          AST_NODE_TYPES.TSIndexSignature,
+          AST_NODE_TYPES.TSMethodSignature,
+          AST_NODE_TYPES.TSPropertySignature,
+        */
+        const nodesToCheck = [
+            experimental_utils_1.AST_NODE_TYPES.ClassProperty,
+            experimental_utils_1.AST_NODE_TYPES.TSAbstractClassProperty,
+            experimental_utils_1.AST_NODE_TYPES.TSAbstractMethodDefinition,
+            experimental_utils_1.AST_NODE_TYPES.TSDeclareFunction,
+            experimental_utils_1.AST_NODE_TYPES.TSExportAssignment,
+            experimental_utils_1.AST_NODE_TYPES.TSImportEqualsDeclaration,
+            experimental_utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration,
+        ].reduce((acc, node) => {
+            acc[node] = checkForSemicolon;
+            return acc;
+        }, {});
+        return Object.assign({}, rules, nodesToCheck, { ExportDefaultDeclaration(node) {
+                if (node.declaration.type !== experimental_utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) {
+                    rules.ExportDefaultDeclaration(node);
+                }
+            } });
+    },
+});
+//# sourceMappingURL=semi.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"semi.js","sourceRoot":"","sources":["../../src/rules/semi.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,8EAI+C;AAC/C,iEAA6C;AAC7C,8CAAgC;AAKhC,kBAAe,IAAI,CAAC,UAAU,CAAsB;IAClD,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE;QACJ,IAAI,EAAE,QAAQ;QACd,IAAI,EAAE;YACJ,WAAW,EAAE,+CAA+C;YAC5D,QAAQ,EAAE,kBAAkB;YAC5B,WAAW,EAAE,KAAK;SACnB;QACD,OAAO,EAAE,MAAM;QACf,MAAM,EAAE,cAAQ,CAAC,IAAI,CAAC,MAAM;QAC5B,QAAQ,EAAE,cAAQ,CAAC,IAAI,CAAC,QAAQ;KACjC;IACD,cAAc,EAAE;QACd,QAAQ;QACR;YACE,sBAAsB,EAAE,KAAK;YAC7B,gCAAgC,EAAE,KAAK;SACxC;KACF;IACD,MAAM,CAAC,OAAO;QACZ,MAAM,KAAK,GAAG,cAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QACvC,MAAM,iBAAiB,GAAG,KAAK,CAAC,mBAE/B,CAAC;QAEF;;;;;;;UAOE;QACF,MAAM,YAAY,GAAG;YACnB,mCAAc,CAAC,aAAa;YAC5B,mCAAc,CAAC,uBAAuB;YACtC,mCAAc,CAAC,0BAA0B;YACzC,mCAAc,CAAC,iBAAiB;YAChC,mCAAc,CAAC,kBAAkB;YACjC,mCAAc,CAAC,yBAAyB;YACxC,mCAAc,CAAC,sBAAsB;SACtC,CAAC,MAAM,CAAwB,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE;YAC5C,GAAG,CAAC,IAAc,CAAC,GAAG,iBAAiB,CAAC;YACxC,OAAO,GAAG,CAAC;QACb,CAAC,EAAE,EAAE,CAAC,CAAC;QAEP,yBACK,KAAK,EACL,YAAY,IACf,wBAAwB,CAAC,IAAI;gBAC3B,IAAI,IAAI,CAAC,WAAW,CAAC,IAAI,KAAK,mCAAc,CAAC,sBAAsB,EAAE;oBACnE,KAAK,CAAC,wBAAwB,CAAC,IAAI,CAAC,CAAC;iBACtC;YACH,CAAC,IACD;IACJ,CAAC;CACF,CAAC,CAAC"}

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/dist/rules/strict-boolean-expressions.js

@@ -0,0 +1,87 @@
+"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 typescript_1 = __importDefault(require("typescript"));
+const tsutils = __importStar(require("tsutils"));
+const util = __importStar(require("../util"));
+exports.default = util.createRule({
+    name: 'strict-boolean-expressions',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Restricts the types allowed in boolean expressions',
+            category: 'Best Practices',
+            recommended: false,
+        },
+        schema: [],
+        messages: {
+            strictBooleanExpression: 'Unexpected non-boolean in conditional.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const service = util.getParserServices(context);
+        const checker = service.program.getTypeChecker();
+        /**
+         * Determines if the node has a boolean type.
+         */
+        function isBooleanType(node) {
+            const tsNode = service.esTreeNodeToTSNodeMap.get(node);
+            const type = util.getConstrainedTypeAtLocation(checker, tsNode);
+            return tsutils.isTypeFlagSet(type, typescript_1.default.TypeFlags.BooleanLike);
+        }
+        /**
+         * Asserts that a testable expression contains a boolean, reports otherwise.
+         * Filters all LogicalExpressions to prevent some duplicate reports.
+         */
+        function assertTestExpressionContainsBoolean(node) {
+            if (node.test !== null &&
+                node.test.type !== experimental_utils_1.AST_NODE_TYPES.LogicalExpression &&
+                !isBooleanType(node.test)) {
+                reportNode(node.test);
+            }
+        }
+        /**
+         * Asserts that a logical expression contains a boolean, reports otherwise.
+         */
+        function assertLocalExpressionContainsBoolean(node) {
+            if (!isBooleanType(node.left) || !isBooleanType(node.right)) {
+                reportNode(node);
+            }
+        }
+        /**
+         * Asserts that a unary expression contains a boolean, reports otherwise.
+         */
+        function assertUnaryExpressionContainsBoolean(node) {
+            if (!isBooleanType(node.argument)) {
+                reportNode(node.argument);
+            }
+        }
+        /**
+         * Reports an offending node in context.
+         */
+        function reportNode(node) {
+            context.report({ node, messageId: 'strictBooleanExpression' });
+        }
+        return {
+            ConditionalExpression: assertTestExpressionContainsBoolean,
+            DoWhileStatement: assertTestExpressionContainsBoolean,
+            ForStatement: assertTestExpressionContainsBoolean,
+            IfStatement: assertTestExpressionContainsBoolean,
+            WhileStatement: assertTestExpressionContainsBoolean,
+            LogicalExpression: assertLocalExpressionContainsBoolean,
+            'UnaryExpression[operator="!"]': assertUnaryExpressionContainsBoolean,
+        };
+    },
+});
+//# sourceMappingURL=strict-boolean-expressions.js.map

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/dist/rules/strict-boolean-expressions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"strict-boolean-expressions.js","sourceRoot":"","sources":["../../src/rules/strict-boolean-expressions.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,8EAG+C;AAC/C,4DAA4B;AAC5B,iDAAmC;AACnC,8CAAgC;AAShC,kBAAe,IAAI,CAAC,UAAU,CAAC;IAC7B,IAAI,EAAE,4BAA4B;IAClC,IAAI,EAAE;QACJ,IAAI,EAAE,YAAY;QAClB,IAAI,EAAE;YACJ,WAAW,EAAE,oDAAoD;YACjE,QAAQ,EAAE,gBAAgB;YAC1B,WAAW,EAAE,KAAK;SACnB;QACD,MAAM,EAAE,EAAE;QACV,QAAQ,EAAE;YACR,uBAAuB,EAAE,wCAAwC;SAClE;KACF;IACD,cAAc,EAAE,EAAE;IAClB,MAAM,CAAC,OAAO;QACZ,MAAM,OAAO,GAAG,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC;QAChD,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,cAAc,EAAE,CAAC;QAEjD;;WAEG;QACH,SAAS,aAAa,CAAC,IAAmB;YACxC,MAAM,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC,GAAG,CAC9C,IAAI,CACL,CAAC;YACF,MAAM,IAAI,GAAG,IAAI,CAAC,4BAA4B,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;YAChE,OAAO,OAAO,CAAC,aAAa,CAAC,IAAI,EAAE,oBAAE,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC;QAC/D,CAAC;QAED;;;WAGG;QACH,SAAS,mCAAmC,CAC1C,IAAwB;YAExB,IACE,IAAI,CAAC,IAAI,KAAK,IAAI;gBAClB,IAAI,CAAC,IAAI,CAAC,IAAI,KAAK,mCAAc,CAAC,iBAAiB;gBACnD,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,EACzB;gBACA,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aACvB;QACH,CAAC;QAED;;WAEG;QACH,SAAS,oCAAoC,CAC3C,IAAgC;YAEhC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;gBAC3D,UAAU,CAAC,IAAI,CAAC,CAAC;aAClB;QACH,CAAC;QAED;;WAEG;QACH,SAAS,oCAAoC,CAC3C,IAA8B;YAE9B,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE;gBACjC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;aAC3B;QACH,CAAC;QAED;;WAEG;QACH,SAAS,UAAU,CAAC,IAAmB;YACrC,OAAO,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,yBAAyB,EAAE,CAAC,CAAC;QACjE,CAAC;QAED,OAAO;YACL,qBAAqB,EAAE,mCAAmC;YAC1D,gBAAgB,EAAE,mCAAmC;YACrD,YAAY,EAAE,mCAAmC;YACjD,WAAW,EAAE,mCAAmC;YAChD,cAAc,EAAE,mCAAmC;YACnD,iBAAiB,EAAE,oCAAoC;YACvD,+BAA+B,EAAE,oCAAoC;SACtE,CAAC;IACJ,CAAC;CACF,CAAC,CAAC"}

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/dist/rules/triple-slash-reference.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"));
+exports.default = util.createRule({
+    name: 'triple-slash-reference',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Sets preference level for triple slash directives versus ES6-style import declarations',
+            category: 'Best Practices',
+            recommended: false,
+        },
+        messages: {
+            tripleSlashReference: 'Do not use a triple slash reference for {{module}}, use `import` style instead.',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    lib: {
+                        enum: ['always', 'never'],
+                    },
+                    path: {
+                        enum: ['always', 'never'],
+                    },
+                    types: {
+                        enum: ['always', 'never', 'prefer-import'],
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [
+        {
+            lib: 'always',
+            path: 'never',
+            types: 'prefer-import',
+        },
+    ],
+    create(context, [{ lib, path, types }]) {
+        let programNode;
+        const sourceCode = context.getSourceCode();
+        const references = [];
+        function hasMatchingReference(source) {
+            references.forEach(reference => {
+                if (reference.importName === source.value) {
+                    context.report({
+                        node: reference.comment,
+                        messageId: 'tripleSlashReference',
+                        data: {
+                            module: reference.importName,
+                        },
+                    });
+                }
+            });
+        }
+        return {
+            ImportDeclaration(node) {
+                if (programNode) {
+                    const source = node.source;
+                    hasMatchingReference(source);
+                }
+            },
+            TSImportEqualsDeclaration(node) {
+                if (programNode) {
+                    const source = node.moduleReference
+                        .expression;
+                    hasMatchingReference(source);
+                }
+            },
+            Program(node) {
+                if (lib === 'always' && path === 'always' && types == 'always') {
+                    return;
+                }
+                programNode = node;
+                const referenceRegExp = /^\/\s*<reference\s*(types|path|lib)\s*=\s*["|'](.*)["|']/;
+                const commentsBefore = sourceCode.getCommentsBefore(programNode);
+                commentsBefore.forEach(comment => {
+                    if (comment.type !== 'Line') {
+                        return;
+                    }
+                    const referenceResult = referenceRegExp.exec(comment.value);
+                    if (referenceResult) {
+                        if ((referenceResult[1] === 'types' && types === 'never') ||
+                            (referenceResult[1] === 'path' && path === 'never') ||
+                            (referenceResult[1] === 'lib' && lib === 'never')) {
+                            context.report({
+                                node: comment,
+                                messageId: 'tripleSlashReference',
+                                data: {
+                                    module: referenceResult[2],
+                                },
+                            });
+                            return;
+                        }
+                        if (referenceResult[1] === 'types' && types === 'prefer-import') {
+                            references.push({ comment, importName: referenceResult[2] });
+                        }
+                    }
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=triple-slash-reference.js.map

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/dist/rules/triple-slash-reference.js.map

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