less 3.10.1 → 3.11.1

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/dist/rules/explicit-member-accessibility.js

@@ -0,0 +1,150 @@
+"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"));
+const accessibilityLevel = { enum: ['explicit', 'no-public', 'off'] };
+exports.default = util.createRule({
+    name: 'explicit-member-accessibility',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Require explicit accessibility modifiers on class properties and methods',
+            category: 'Best Practices',
+            recommended: 'error',
+        },
+        messages: {
+            missingAccessibility: 'Missing accessibility modifier on {{type}} {{name}}.',
+            unwantedPublicAccessibility: 'Public accessibility modifier on {{type}} {{name}}.',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    accessibility: accessibilityLevel,
+                    overrides: {
+                        type: 'object',
+                        properties: {
+                            accessors: accessibilityLevel,
+                            constructors: accessibilityLevel,
+                            methods: accessibilityLevel,
+                            properties: accessibilityLevel,
+                            parameterProperties: accessibilityLevel,
+                        },
+                        additionalProperties: false,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [{ accessibility: 'explicit' }],
+    create(context, [option]) {
+        const sourceCode = context.getSourceCode();
+        const baseCheck = option.accessibility || 'explicit';
+        const overrides = option.overrides || {};
+        const ctorCheck = overrides.constructors || baseCheck;
+        const accessorCheck = overrides.accessors || baseCheck;
+        const methodCheck = overrides.methods || baseCheck;
+        const propCheck = overrides.properties || baseCheck;
+        const paramPropCheck = overrides.parameterProperties || baseCheck;
+        /**
+         * Generates the report for rule violations
+         */
+        function reportIssue(messageId, nodeType, node, nodeName) {
+            context.report({
+                node: node,
+                messageId: messageId,
+                data: {
+                    type: nodeType,
+                    name: nodeName,
+                },
+            });
+        }
+        /**
+         * Checks if a method declaration has an accessibility modifier.
+         * @param methodDefinition The node representing a MethodDefinition.
+         */
+        function checkMethodAccessibilityModifier(methodDefinition) {
+            let nodeType = 'method definition';
+            let check = baseCheck;
+            switch (methodDefinition.kind) {
+                case 'method':
+                    check = methodCheck;
+                    break;
+                case 'constructor':
+                    check = ctorCheck;
+                    break;
+                case 'get':
+                case 'set':
+                    check = accessorCheck;
+                    nodeType = `${methodDefinition.kind} property accessor`;
+                    break;
+            }
+            if (check === 'off') {
+                return;
+            }
+            if (util.isTypeScriptFile(context.getFilename())) {
+                // const methodName = util.getNameFromPropertyName(methodDefinition.key);
+                const methodName = util.getNameFromClassMember(methodDefinition, sourceCode);
+                if (check === 'no-public' &&
+                    methodDefinition.accessibility === 'public') {
+                    reportIssue('unwantedPublicAccessibility', nodeType, methodDefinition, methodName);
+                }
+                else if (check === 'explicit' && !methodDefinition.accessibility) {
+                    reportIssue('missingAccessibility', nodeType, methodDefinition, methodName);
+                }
+            }
+        }
+        /**
+         * Checks if property has an accessibility modifier.
+         * @param classProperty The node representing a ClassProperty.
+         */
+        function checkPropertyAccessibilityModifier(classProperty) {
+            const nodeType = 'class property';
+            if (util.isTypeScriptFile(context.getFilename())) {
+                const propertyName = util.getNameFromPropertyName(classProperty.key);
+                if (propCheck === 'no-public' &&
+                    classProperty.accessibility === 'public') {
+                    reportIssue('unwantedPublicAccessibility', nodeType, classProperty, propertyName);
+                }
+                else if (propCheck === 'explicit' && !classProperty.accessibility) {
+                    reportIssue('missingAccessibility', nodeType, classProperty, propertyName);
+                }
+            }
+        }
+        /**
+         * Checks that the parameter property has the desired accessibility modifiers set.
+         * @param {TSESTree.TSParameterProperty} node The node representing a Parameter Property
+         */
+        function checkParameterPropertyAccessibilityModifier(node) {
+            const nodeType = 'parameter property';
+            if (util.isTypeScriptFile(context.getFilename())) {
+                // HAS to be an identifier or assignment or TSC will throw
+                if (node.parameter.type !== experimental_utils_1.AST_NODE_TYPES.Identifier &&
+                    node.parameter.type !== experimental_utils_1.AST_NODE_TYPES.AssignmentPattern) {
+                    return;
+                }
+                const nodeName = node.parameter.type === experimental_utils_1.AST_NODE_TYPES.Identifier
+                    ? node.parameter.name
+                    : // has to be an Identifier or TSC will throw an error
+                        node.parameter.left.name;
+                if (paramPropCheck === 'no-public' && node.accessibility === 'public') {
+                    reportIssue('unwantedPublicAccessibility', nodeType, node, nodeName);
+                }
+            }
+        }
+        return {
+            TSParameterProperty: checkParameterPropertyAccessibilityModifier,
+            ClassProperty: checkPropertyAccessibilityModifier,
+            MethodDefinition: checkMethodAccessibilityModifier,
+        };
+    },
+});
+//# sourceMappingURL=explicit-member-accessibility.js.map

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/dist/rules/explicit-member-accessibility.js.map

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

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/dist/rules/func-call-spacing.js

@@ -0,0 +1,135 @@
+"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 eslint_utils_1 = require("eslint-utils");
+const util = __importStar(require("../util"));
+exports.default = util.createRule({
+    name: 'func-call-spacing',
+    meta: {
+        type: 'layout',
+        docs: {
+            description: 'Require or disallow spacing between function identifiers and their invocations',
+            category: 'Stylistic Issues',
+            recommended: false,
+        },
+        fixable: 'whitespace',
+        schema: {
+            anyOf: [
+                {
+                    type: 'array',
+                    items: [
+                        {
+                            enum: ['never'],
+                        },
+                    ],
+                    minItems: 0,
+                    maxItems: 1,
+                },
+                {
+                    type: 'array',
+                    items: [
+                        {
+                            enum: ['always'],
+                        },
+                        {
+                            type: 'object',
+                            properties: {
+                                allowNewlines: {
+                                    type: 'boolean',
+                                },
+                            },
+                            additionalProperties: false,
+                        },
+                    ],
+                    minItems: 0,
+                    maxItems: 2,
+                },
+            ],
+        },
+        messages: {
+            unexpected: 'Unexpected space or newline between function name and paren.',
+            missing: 'Missing space between function name and paren.',
+        },
+    },
+    defaultOptions: ['never', {}],
+    create(context, [option, config]) {
+        const sourceCode = context.getSourceCode();
+        const text = sourceCode.getText();
+        /**
+         * Check if open space is present in a function name
+         * @param {ASTNode} node node to evaluate
+         * @returns {void}
+         * @private
+         */
+        function checkSpacing(node) {
+            const closingParenToken = sourceCode.getLastToken(node);
+            const lastCalleeTokenWithoutPossibleParens = sourceCode.getLastToken(node.typeParameters || node.callee);
+            const openingParenToken = sourceCode.getFirstTokenBetween(lastCalleeTokenWithoutPossibleParens, closingParenToken, eslint_utils_1.isOpeningParenToken);
+            if (!openingParenToken || openingParenToken.range[1] >= node.range[1]) {
+                // new expression with no parens...
+                return;
+            }
+            const lastCalleeToken = sourceCode.getTokenBefore(openingParenToken);
+            const textBetweenTokens = text
+                .slice(lastCalleeToken.range[1], openingParenToken.range[0])
+                .replace(/\/\*.*?\*\//gu, '');
+            const hasWhitespace = /\s/u.test(textBetweenTokens);
+            const hasNewline = hasWhitespace && util.LINEBREAK_MATCHER.test(textBetweenTokens);
+            if (option === 'never') {
+                if (hasWhitespace) {
+                    return context.report({
+                        node,
+                        loc: lastCalleeToken.loc.start,
+                        messageId: 'unexpected',
+                        fix(fixer) {
+                            /*
+                             * Only autofix if there is no newline
+                             * https://github.com/eslint/eslint/issues/7787
+                             */
+                            if (!hasNewline) {
+                                return fixer.removeRange([
+                                    lastCalleeToken.range[1],
+                                    openingParenToken.range[0],
+                                ]);
+                            }
+                            return null;
+                        },
+                    });
+                }
+            }
+            else {
+                if (!hasWhitespace) {
+                    context.report({
+                        node,
+                        loc: lastCalleeToken.loc.start,
+                        messageId: 'missing',
+                        fix(fixer) {
+                            return fixer.insertTextBefore(openingParenToken, ' ');
+                        },
+                    });
+                }
+                else if (!config.allowNewlines && hasNewline) {
+                    context.report({
+                        node,
+                        loc: lastCalleeToken.loc.start,
+                        messageId: 'unexpected',
+                        fix(fixer) {
+                            return fixer.replaceTextRange([lastCalleeToken.range[1], openingParenToken.range[0]], ' ');
+                        },
+                    });
+                }
+            }
+        }
+        return {
+            CallExpression: checkSpacing,
+            NewExpression: checkSpacing,
+        };
+    },
+});
+//# sourceMappingURL=func-call-spacing.js.map

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/dist/rules/func-call-spacing.js.map

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

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/dist/rules/generic-type-naming.js

@@ -0,0 +1,52 @@
+"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: 'generic-type-naming',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforces naming of generic type variables',
+            category: 'Stylistic Issues',
+            recommended: false,
+        },
+        messages: {
+            paramNotMatchRule: 'Type parameter {{name}} does not match rule {{rule}}.',
+        },
+        schema: [
+            {
+                type: 'string',
+            },
+        ],
+    },
+    defaultOptions: [
+        // Matches: T , TA , TAbc , TA1Bca , T1 , T2
+        '^T([A-Z0-9][a-zA-Z0-9]*){0,1}$',
+    ],
+    create(context, [rule]) {
+        const regex = new RegExp(rule);
+        return {
+            TSTypeParameter(node) {
+                const name = node.name.name;
+                if (name && !regex.test(name)) {
+                    context.report({
+                        node,
+                        messageId: 'paramNotMatchRule',
+                        data: {
+                            name,
+                            rule,
+                        },
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=generic-type-naming.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generic-type-naming.js","sourceRoot":"","sources":["../../src/rules/generic-type-naming.ts"],"names":[],"mappings":";;;;;;;;;AAAA,8CAAgC;AAKhC,kBAAe,IAAI,CAAC,UAAU,CAAsB;IAClD,IAAI,EAAE,qBAAqB;IAC3B,IAAI,EAAE;QACJ,IAAI,EAAE,YAAY;QAClB,IAAI,EAAE;YACJ,WAAW,EAAE,2CAA2C;YACxD,QAAQ,EAAE,kBAAkB;YAC5B,WAAW,EAAE,KAAK;SACnB;QACD,QAAQ,EAAE;YACR,iBAAiB,EACf,uDAAuD;SAC1D;QACD,MAAM,EAAE;YACN;gBACE,IAAI,EAAE,QAAQ;aACf;SACF;KACF;IACD,cAAc,EAAE;QACd,4CAA4C;QAC5C,gCAAgC;KACjC;IACD,MAAM,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC;QACpB,MAAM,KAAK,GAAG,IAAI,MAAM,CAAC,IAAK,CAAC,CAAC;QAEhC,OAAO;YACL,eAAe,CAAC,IAAI;gBAClB,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC;gBAE5B,IAAI,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;oBAC7B,OAAO,CAAC,MAAM,CAAC;wBACb,IAAI;wBACJ,SAAS,EAAE,mBAAmB;wBAC9B,IAAI,EAAE;4BACJ,IAAI;4BACJ,IAAI;yBACL;qBACF,CAAC,CAAC;iBACJ;YACH,CAAC;SACF,CAAC;IACJ,CAAC;CACF,CAAC,CAAC"}

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/dist/rules/indent-new-do-not-use/BinarySearchTree.js

@@ -0,0 +1,54 @@
+"use strict";
+// The following code is adapted from the the code in eslint.
+// License: https://github.com/eslint/eslint/blob/48700fc8408f394887cdedd071b22b757700fdcb/LICENSE
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const functional_red_black_tree_1 = __importDefault(require("functional-red-black-tree"));
+/**
+ * A mutable balanced binary search tree that stores (key, value) pairs. The keys are numeric, and must be unique.
+ * This is intended to be a generic wrapper around a balanced binary search tree library, so that the underlying implementation
+ * can easily be swapped out.
+ */
+class BinarySearchTree {
+    constructor() {
+        this.rbTree = functional_red_black_tree_1.default();
+    }
+    /**
+     * Inserts an entry into the tree.
+     */
+    insert(key, value) {
+        const iterator = this.rbTree.find(key);
+        if (iterator.valid) {
+            this.rbTree = iterator.update(value);
+        }
+        else {
+            this.rbTree = this.rbTree.insert(key, value);
+        }
+    }
+    /**
+     * Finds the entry with the largest key less than or equal to the provided key
+     * @returns The found entry, or null if no such entry exists.
+     */
+    findLe(key) {
+        const iterator = this.rbTree.le(key);
+        return { key: iterator.key, value: iterator.value };
+    }
+    /**
+     * Deletes all of the keys in the interval [start, end)
+     */
+    deleteRange(start, end) {
+        // Exit without traversing the tree if the range has zero size.
+        if (start === end) {
+            return;
+        }
+        const iterator = this.rbTree.ge(start);
+        while (iterator.valid && iterator.key < end) {
+            this.rbTree = this.rbTree.remove(iterator.key);
+            iterator.next();
+        }
+    }
+}
+exports.BinarySearchTree = BinarySearchTree;
+//# sourceMappingURL=BinarySearchTree.js.map

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/dist/rules/indent-new-do-not-use/BinarySearchTree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"BinarySearchTree.js","sourceRoot":"","sources":["../../../src/rules/indent-new-do-not-use/BinarySearchTree.ts"],"names":[],"mappings":";AAAA,6DAA6D;AAC7D,kGAAkG;;;;;AAGlG,0FAAmD;AASnD;;;;GAIG;AACH,MAAa,gBAAgB;IAA7B;QACU,WAAM,GAAG,mCAAU,EAAqB,CAAC;IAwCnD,CAAC;IAtCC;;OAEG;IACI,MAAM,CAAC,GAAW,EAAE,KAAgB;QACzC,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAEvC,IAAI,QAAQ,CAAC,KAAK,EAAE;YAClB,IAAI,CAAC,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;SACtC;aAAM;YACL,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;SAC9C;IACH,CAAC;IAED;;;OAGG;IACI,MAAM,CAAC,GAAW;QACvB,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;QAErC,OAAO,EAAE,GAAG,EAAE,QAAQ,CAAC,GAAG,EAAE,KAAK,EAAE,QAAQ,CAAC,KAAK,EAAE,CAAC;IACtD,CAAC;IAED;;OAEG;IACI,WAAW,CAAC,KAAa,EAAE,GAAW;QAC3C,+DAA+D;QAC/D,IAAI,KAAK,KAAK,GAAG,EAAE;YACjB,OAAO;SACR;QACD,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;QAEvC,OAAO,QAAQ,CAAC,KAAK,IAAI,QAAQ,CAAC,GAAG,GAAG,GAAG,EAAE;YAC3C,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;YAC/C,QAAQ,CAAC,IAAI,EAAE,CAAC;SACjB;IACH,CAAC;CACF;AAzCD,4CAyCC"}

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/dist/rules/indent-new-do-not-use/OffsetStorage.js

@@ -0,0 +1,220 @@
+"use strict";
+// The following code is adapted from the the code in eslint.
+// License: https://github.com/eslint/eslint/blob/48700fc8408f394887cdedd071b22b757700fdcb/LICENSE
+Object.defineProperty(exports, "__esModule", { value: true });
+const BinarySearchTree_1 = require("./BinarySearchTree");
+/**
+ * A class to store information on desired offsets of tokens from each other
+ */
+class OffsetStorage {
+    /**
+     * @param tokenInfo a TokenInfo instance
+     * @param indentSize The desired size of each indentation level
+     * @param indentType The indentation character
+     */
+    constructor(tokenInfo, indentSize, indentType) {
+        this.tokenInfo = tokenInfo;
+        this.indentSize = indentSize;
+        this.indentType = indentType;
+        this.tree = new BinarySearchTree_1.BinarySearchTree();
+        this.tree.insert(0, { offset: 0, from: null, force: false });
+        this.lockedFirstTokens = new WeakMap();
+        this.desiredIndentCache = new WeakMap();
+        this.ignoredTokens = new WeakSet();
+    }
+    getOffsetDescriptor(token) {
+        return this.tree.findLe(token.range[0]).value;
+    }
+    /**
+     * Sets the offset column of token B to match the offset column of token A.
+     * **WARNING**: This matches a *column*, even if baseToken is not the first token on its line. In
+     * most cases, `setDesiredOffset` should be used instead.
+     * @param baseToken The first token
+     * @param offsetToken The second token, whose offset should be matched to the first token
+     */
+    matchOffsetOf(baseToken, offsetToken) {
+        /*
+         * lockedFirstTokens is a map from a token whose indentation is controlled by the "first" option to
+         * the token that it depends on. For example, with the `ArrayExpression: first` option, the first
+         * token of each element in the array after the first will be mapped to the first token of the first
+         * element. The desired indentation of each of these tokens is computed based on the desired indentation
+         * of the "first" element, rather than through the normal offset mechanism.
+         */
+        this.lockedFirstTokens.set(offsetToken, baseToken);
+    }
+    /**
+     * Sets the desired offset of a token.
+     *
+     * This uses a line-based offset collapsing behavior to handle tokens on the same line.
+     * For example, consider the following two cases:
+     *
+     * (
+     *     [
+     *         bar
+     *     ]
+     * )
+     *
+     * ([
+     *     bar
+     * ])
+     *
+     * Based on the first case, it's clear that the `bar` token needs to have an offset of 1 indent level (4 spaces) from
+     * the `[` token, and the `[` token has to have an offset of 1 indent level from the `(` token. Since the `(` token is
+     * the first on its line (with an indent of 0 spaces), the `bar` token needs to be offset by 2 indent levels (8 spaces)
+     * from the start of its line.
+     *
+     * However, in the second case `bar` should only be indented by 4 spaces. This is because the offset of 1 indent level
+     * between the `(` and the `[` tokens gets "collapsed" because the two tokens are on the same line. As a result, the
+     * `(` token is mapped to the `[` token with an offset of 0, and the rule correctly decides that `bar` should be indented
+     * by 1 indent level from the start of the line.
+     *
+     * This is useful because rule listeners can usually just call `setDesiredOffset` for all the tokens in the node,
+     * without needing to check which lines those tokens are on.
+     *
+     * Note that since collapsing only occurs when two tokens are on the same line, there are a few cases where non-intuitive
+     * behavior can occur. For example, consider the following cases:
+     *
+     * foo(
+     * ).
+     *     bar(
+     *         baz
+     *     )
+     *
+     * foo(
+     * ).bar(
+     *     baz
+     * )
+     *
+     * Based on the first example, it would seem that `bar` should be offset by 1 indent level from `foo`, and `baz`
+     * should be offset by 1 indent level from `bar`. However, this is not correct, because it would result in `baz`
+     * being indented by 2 indent levels in the second case (since `foo`, `bar`, and `baz` are all on separate lines, no
+     * collapsing would occur).
+     *
+     * Instead, the correct way would be to offset `baz` by 1 level from `bar`, offset `bar` by 1 level from the `)`, and
+     * offset the `)` by 0 levels from `foo`. This ensures that the offset between `bar` and the `)` are correctly collapsed
+     * in the second case.
+     *
+     * @param token The token
+     * @param fromToken The token that `token` should be offset from
+     * @param offset The desired indent level
+     */
+    setDesiredOffset(token, fromToken, offset) {
+        this.setDesiredOffsets(token.range, fromToken, offset);
+    }
+    /**
+     * Sets the desired offset of all tokens in a range
+     * It's common for node listeners in this file to need to apply the same offset to a large, contiguous range of tokens.
+     * Moreover, the offset of any given token is usually updated multiple times (roughly once for each node that contains
+     * it). This means that the offset of each token is updated O(AST depth) times.
+     * It would not be performant to store and update the offsets for each token independently, because the rule would end
+     * up having a time complexity of O(number of tokens * AST depth), which is quite slow for large files.
+     *
+     * Instead, the offset tree is represented as a collection of contiguous offset ranges in a file. For example, the following
+     * list could represent the state of the offset tree at a given point:
+     *
+     * * Tokens starting in the interval [0, 15) are aligned with the beginning of the file
+     * * Tokens starting in the interval [15, 30) are offset by 1 indent level from the `bar` token
+     * * Tokens starting in the interval [30, 43) are offset by 1 indent level from the `foo` token
+     * * Tokens starting in the interval [43, 820) are offset by 2 indent levels from the `bar` token
+     * * Tokens starting in the interval [820, ∞) are offset by 1 indent level from the `baz` token
+     *
+     * The `setDesiredOffsets` methods inserts ranges like the ones above. The third line above would be inserted by using:
+     * `setDesiredOffsets([30, 43], fooToken, 1);`
+     *
+     * @param range A [start, end] pair. All tokens with range[0] <= token.start < range[1] will have the offset applied.
+     * @param fromToken The token that this is offset from
+     * @param offset The desired indent level
+     * @param force `true` if this offset should not use the normal collapsing behavior. This should almost always be false.
+     */
+    setDesiredOffsets(range, fromToken, offset = 0, force = false) {
+        /*
+         * Offset ranges are stored as a collection of nodes, where each node maps a numeric key to an offset
+         * descriptor. The tree for the example above would have the following nodes:
+         *
+         * * key: 0, value: { offset: 0, from: null }
+         * * key: 15, value: { offset: 1, from: barToken }
+         * * key: 30, value: { offset: 1, from: fooToken }
+         * * key: 43, value: { offset: 2, from: barToken }
+         * * key: 820, value: { offset: 1, from: bazToken }
+         *
+         * To find the offset descriptor for any given token, one needs to find the node with the largest key
+         * which is <= token.start. To make this operation fast, the nodes are stored in a balanced binary
+         * search tree indexed by key.
+         */
+        const descriptorToInsert = { offset, from: fromToken, force };
+        const descriptorAfterRange = this.tree.findLe(range[1]).value;
+        const fromTokenIsInRange = fromToken &&
+            fromToken.range[0] >= range[0] &&
+            fromToken.range[1] <= range[1];
+        // this has to be before the delete + insert below or else you'll get into a cycle
+        const fromTokenDescriptor = fromTokenIsInRange
+            ? this.getOffsetDescriptor(fromToken)
+            : null;
+        // First, remove any existing nodes in the range from the tree.
+        this.tree.deleteRange(range[0] + 1, range[1]);
+        // Insert a new node into the tree for this range
+        this.tree.insert(range[0], descriptorToInsert);
+        /*
+         * To avoid circular offset dependencies, keep the `fromToken` token mapped to whatever it was mapped to previously,
+         * even if it's in the current range.
+         */
+        if (fromTokenIsInRange) {
+            this.tree.insert(fromToken.range[0], fromTokenDescriptor);
+            this.tree.insert(fromToken.range[1], descriptorToInsert);
+        }
+        /*
+         * To avoid modifying the offset of tokens after the range, insert another node to keep the offset of the following
+         * tokens the same as it was before.
+         */
+        this.tree.insert(range[1], descriptorAfterRange);
+    }
+    /**
+     * Gets the desired indent of a token
+     * @returns The desired indent of the token
+     */
+    getDesiredIndent(token) {
+        if (!this.desiredIndentCache.has(token)) {
+            if (this.ignoredTokens.has(token)) {
+                /*
+                 * If the token is ignored, use the actual indent of the token as the desired indent.
+                 * This ensures that no errors are reported for this token.
+                 */
+                this.desiredIndentCache.set(token, this.tokenInfo.getTokenIndent(token));
+            }
+            else if (this.lockedFirstTokens.has(token)) {
+                const firstToken = this.lockedFirstTokens.get(token);
+                this.desiredIndentCache.set(token, 
+                // (indentation for the first element's line)
+                this.getDesiredIndent(this.tokenInfo.getFirstTokenOfLine(firstToken)) +
+                    // (space between the start of the first element's line and the first element)
+                    this.indentType.repeat(firstToken.loc.start.column -
+                        this.tokenInfo.getFirstTokenOfLine(firstToken).loc.start.column));
+            }
+            else {
+                const offsetInfo = this.getOffsetDescriptor(token);
+                const offset = offsetInfo.from &&
+                    offsetInfo.from.loc.start.line === token.loc.start.line &&
+                    !/^\s*?\n/u.test(token.value) &&
+                    !offsetInfo.force
+                    ? 0
+                    : offsetInfo.offset * this.indentSize;
+                this.desiredIndentCache.set(token, (offsetInfo.from ? this.getDesiredIndent(offsetInfo.from) : '') +
+                    this.indentType.repeat(offset));
+            }
+        }
+        return this.desiredIndentCache.get(token);
+    }
+    /**
+     * Ignores a token, preventing it from being reported.
+     */
+    ignoreToken(token) {
+        if (this.tokenInfo.isFirstTokenOfLine(token)) {
+            this.ignoredTokens.add(token);
+        }
+    }
+    getFirstDependency(token) {
+        return this.getOffsetDescriptor(token).from;
+    }
+}
+exports.OffsetStorage = OffsetStorage;
+//# sourceMappingURL=OffsetStorage.js.map

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/dist/rules/indent-new-do-not-use/OffsetStorage.js.map

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