less 3.10.1 → 3.11.1

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/dist/rules/interface-name-prefix.js

@@ -0,0 +1,65 @@
+"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: 'interface-name-prefix',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Require that interface names be prefixed with `I`',
+            category: 'Stylistic Issues',
+            recommended: 'error',
+        },
+        messages: {
+            noPrefix: 'Interface name must not be prefixed with "I".',
+            alwaysPrefix: 'Interface name must be prefixed with "I".',
+        },
+        schema: [
+            {
+                enum: ['never', 'always'],
+            },
+        ],
+    },
+    defaultOptions: ['never'],
+    create(context, [option]) {
+        const never = option !== 'always';
+        /**
+         * Checks if a string is prefixed with "I".
+         * @param name The string to check
+         */
+        function isPrefixedWithI(name) {
+            if (typeof name !== 'string') {
+                return false;
+            }
+            return /^I[A-Z]/.test(name);
+        }
+        return {
+            TSInterfaceDeclaration(node) {
+                if (never) {
+                    if (isPrefixedWithI(node.id.name)) {
+                        context.report({
+                            node: node.id,
+                            messageId: 'noPrefix',
+                        });
+                    }
+                }
+                else {
+                    if (!isPrefixedWithI(node.id.name)) {
+                        context.report({
+                            node: node.id,
+                            messageId: 'alwaysPrefix',
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=interface-name-prefix.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"interface-name-prefix.js","sourceRoot":"","sources":["../../src/rules/interface-name-prefix.ts"],"names":[],"mappings":";;;;;;;;;AAAA,8CAAgC;AAKhC,kBAAe,IAAI,CAAC,UAAU,CAAsB;IAClD,IAAI,EAAE,uBAAuB;IAC7B,IAAI,EAAE;QACJ,IAAI,EAAE,YAAY;QAClB,IAAI,EAAE;YACJ,WAAW,EAAE,mDAAmD;YAChE,QAAQ,EAAE,kBAAkB;YAC5B,WAAW,EAAE,OAAO;SACrB;QACD,QAAQ,EAAE;YACR,QAAQ,EAAE,+CAA+C;YACzD,YAAY,EAAE,2CAA2C;SAC1D;QACD,MAAM,EAAE;YACN;gBACE,IAAI,EAAE,CAAC,OAAO,EAAE,QAAQ,CAAC;aAC1B;SACF;KACF;IACD,cAAc,EAAE,CAAC,OAAO,CAAC;IACzB,MAAM,CAAC,OAAO,EAAE,CAAC,MAAM,CAAC;QACtB,MAAM,KAAK,GAAG,MAAM,KAAK,QAAQ,CAAC;QAElC;;;WAGG;QACH,SAAS,eAAe,CAAC,IAAY;YACnC,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE;gBAC5B,OAAO,KAAK,CAAC;aACd;YAED,OAAO,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAC9B,CAAC;QAED,OAAO;YACL,sBAAsB,CAAC,IAAI;gBACzB,IAAI,KAAK,EAAE;oBACT,IAAI,eAAe,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE;wBACjC,OAAO,CAAC,MAAM,CAAC;4BACb,IAAI,EAAE,IAAI,CAAC,EAAE;4BACb,SAAS,EAAE,UAAU;yBACtB,CAAC,CAAC;qBACJ;iBACF;qBAAM;oBACL,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE;wBAClC,OAAO,CAAC,MAAM,CAAC;4BACb,IAAI,EAAE,IAAI,CAAC,EAAE;4BACb,SAAS,EAAE,cAAc;yBAC1B,CAAC,CAAC;qBACJ;iBACF;YACH,CAAC;SACF,CAAC;IACJ,CAAC;CACF,CAAC,CAAC"}

package/packages/less/node_modules/@typescript-eslint/eslint-plugin/dist/rules/member-delimiter-style.js

@@ -0,0 +1,195 @@
+"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 definition = {
+    type: 'object',
+    properties: {
+        multiline: {
+            type: 'object',
+            properties: {
+                delimiter: { enum: ['none', 'semi', 'comma'] },
+                requireLast: { type: 'boolean' },
+            },
+            additionalProperties: false,
+        },
+        singleline: {
+            type: 'object',
+            properties: {
+                // note can't have "none" for single line delimiter as it's invlaid syntax
+                delimiter: { enum: ['semi', 'comma'] },
+                requireLast: { type: 'boolean' },
+            },
+            additionalProperties: false,
+        },
+    },
+    additionalProperties: false,
+};
+exports.default = util.createRule({
+    name: 'member-delimiter-style',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Require a specific member delimiter style for interfaces and type literals',
+            category: 'Stylistic Issues',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        messages: {
+            unexpectedComma: 'Unexpected separator (,).',
+            unexpectedSemi: 'Unexpected separator (;).',
+            expectedComma: 'Expected a comma.',
+            expectedSemi: 'Expected a semicolon.',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: Object.assign({}, definition.properties, {
+                    overrides: {
+                        type: 'object',
+                        properties: {
+                            interface: definition,
+                            typeLiteral: definition,
+                        },
+                        additionalProperties: false,
+                    },
+                }),
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [
+        {
+            multiline: {
+                delimiter: 'semi',
+                requireLast: true,
+            },
+            singleline: {
+                delimiter: 'semi',
+                requireLast: false,
+            },
+        },
+    ],
+    create(context, [options]) {
+        const sourceCode = context.getSourceCode();
+        // use the base options as the defaults for the cases
+        const baseOptions = options;
+        const overrides = baseOptions.overrides || {};
+        const interfaceOptions = util.deepMerge(baseOptions, overrides.interface);
+        const typeLiteralOptions = util.deepMerge(baseOptions, overrides.typeLiteral);
+        /**
+         * Check the last token in the given member.
+         * @param member the member to be evaluated.
+         * @param opts the options to be validated.
+         * @param isLast a flag indicating `member` is the last in the interface or type literal.
+         */
+        function checkLastToken(member, opts, isLast) {
+            /**
+             * Resolves the boolean value for the given setting enum value
+             * @param type the option name
+             */
+            function getOption(type) {
+                if (isLast && !opts.requireLast) {
+                    // only turn the option on if its expecting no delimiter for the last member
+                    return type === 'none';
+                }
+                return opts.delimiter === type;
+            }
+            let messageId = null;
+            let missingDelimiter = false;
+            const lastToken = sourceCode.getLastToken(member, {
+                includeComments: false,
+            });
+            if (!lastToken) {
+                return;
+            }
+            const optsSemi = getOption('semi');
+            const optsComma = getOption('comma');
+            const optsNone = getOption('none');
+            if (lastToken.value === ';') {
+                if (optsComma) {
+                    messageId = 'expectedComma';
+                }
+                else if (optsNone) {
+                    missingDelimiter = true;
+                    messageId = 'unexpectedSemi';
+                }
+            }
+            else if (lastToken.value === ',') {
+                if (optsSemi) {
+                    messageId = 'expectedSemi';
+                }
+                else if (optsNone) {
+                    missingDelimiter = true;
+                    messageId = 'unexpectedComma';
+                }
+            }
+            else {
+                if (optsSemi) {
+                    missingDelimiter = true;
+                    messageId = 'expectedSemi';
+                }
+                else if (optsComma) {
+                    missingDelimiter = true;
+                    messageId = 'expectedComma';
+                }
+            }
+            if (messageId) {
+                context.report({
+                    node: lastToken,
+                    loc: {
+                        start: {
+                            line: lastToken.loc.end.line,
+                            column: lastToken.loc.end.column,
+                        },
+                        end: {
+                            line: lastToken.loc.end.line,
+                            column: lastToken.loc.end.column,
+                        },
+                    },
+                    messageId,
+                    fix(fixer) {
+                        if (optsNone) {
+                            // remove the unneeded token
+                            return fixer.remove(lastToken);
+                        }
+                        const token = optsSemi ? ';' : ',';
+                        if (missingDelimiter) {
+                            // add the missing delimiter
+                            return fixer.insertTextAfter(lastToken, token);
+                        }
+                        // correct the current delimiter
+                        return fixer.replaceText(lastToken, token);
+                    },
+                });
+            }
+        }
+        /**
+         * Check the member separator being used matches the delimiter.
+         * @param {ASTNode} node the node to be evaluated.
+         */
+        function checkMemberSeparatorStyle(node) {
+            const isSingleLine = node.loc.start.line === node.loc.end.line;
+            const members = node.type === experimental_utils_1.AST_NODE_TYPES.TSInterfaceBody ? node.body : node.members;
+            const typeOpts = node.type === experimental_utils_1.AST_NODE_TYPES.TSInterfaceBody
+                ? interfaceOptions
+                : typeLiteralOptions;
+            const opts = isSingleLine ? typeOpts.singleline : typeOpts.multiline;
+            members.forEach((member, index) => {
+                checkLastToken(member, opts || {}, index === members.length - 1);
+            });
+        }
+        return {
+            TSInterfaceBody: checkMemberSeparatorStyle,
+            TSTypeLiteral: checkMemberSeparatorStyle,
+        };
+    },
+});
+//# sourceMappingURL=member-delimiter-style.js.map

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

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

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

@@ -0,0 +1,85 @@
+"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: 'member-naming',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforces naming conventions for class members by visibility',
+            category: 'Stylistic Issues',
+            recommended: false,
+        },
+        messages: {
+            incorrectName: '{{accessibility}} property {{name}} should match {{convention}}.',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    public: {
+                        type: 'string',
+                        minLength: 1,
+                        format: 'regex',
+                    },
+                    protected: {
+                        type: 'string',
+                        minLength: 1,
+                        format: 'regex',
+                    },
+                    private: {
+                        type: 'string',
+                        minLength: 1,
+                        format: 'regex',
+                    },
+                },
+                additionalProperties: false,
+                minProperties: 1,
+            },
+        ],
+    },
+    defaultOptions: [{}],
+    create(context, [config]) {
+        const sourceCode = context.getSourceCode();
+        const conventions = Object.keys(config).reduce((acc, accessibility) => {
+            acc[accessibility] = new RegExp(config[accessibility]);
+            return acc;
+        }, {});
+        /**
+         * Check that the property name matches the convention for its
+         * accessibility.
+         * @param {ASTNode} node the named node to evaluate.
+         * @returns {void}
+         * @private
+         */
+        function validateName(node) {
+            const name = util.getNameFromClassMember(node, sourceCode);
+            const accessibility = node.accessibility || 'public';
+            const convention = conventions[accessibility];
+            const method = node;
+            if (method.kind === 'constructor') {
+                return;
+            }
+            if (!convention || convention.test(name)) {
+                return;
+            }
+            context.report({
+                node: node.key,
+                messageId: 'incorrectName',
+                data: { accessibility, name, convention },
+            });
+        }
+        return {
+            MethodDefinition: validateName,
+            ClassProperty: validateName,
+        };
+    },
+});
+//# sourceMappingURL=member-naming.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"member-naming.js","sourceRoot":"","sources":["../../src/rules/member-naming.ts"],"names":[],"mappings":";;;;;;;;;AACA,8CAAgC;AAWhC,kBAAe,IAAI,CAAC,UAAU,CAAsB;IAClD,IAAI,EAAE,eAAe;IACrB,IAAI,EAAE;QACJ,IAAI,EAAE,YAAY;QAClB,IAAI,EAAE;YACJ,WAAW,EACT,6DAA6D;YAC/D,QAAQ,EAAE,kBAAkB;YAC5B,WAAW,EAAE,KAAK;SACnB;QACD,QAAQ,EAAE;YACR,aAAa,EACX,kEAAkE;SACrE;QACD,MAAM,EAAE;YACN;gBACE,IAAI,EAAE,QAAQ;gBACd,UAAU,EAAE;oBACV,MAAM,EAAE;wBACN,IAAI,EAAE,QAAQ;wBACd,SAAS,EAAE,CAAC;wBACZ,MAAM,EAAE,OAAO;qBAChB;oBACD,SAAS,EAAE;wBACT,IAAI,EAAE,QAAQ;wBACd,SAAS,EAAE,CAAC;wBACZ,MAAM,EAAE,OAAO;qBAChB;oBACD,OAAO,EAAE;wBACP,IAAI,EAAE,QAAQ;wBACd,SAAS,EAAE,CAAC;wBACZ,MAAM,EAAE,OAAO;qBAChB;iBACF;gBACD,oBAAoB,EAAE,KAAK;gBAC3B,aAAa,EAAE,CAAC;aACjB;SACF;KACF;IACD,cAAc,EAAE,CAAC,EAAE,CAAC;IACpB,MAAM,CAAC,OAAO,EAAE,CAAC,MAAM,CAAC;QACtB,MAAM,UAAU,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC;QAE3C,MAAM,WAAW,GAAI,MAAM,CAAC,IAAI,CAAC,MAAM,CAAiB,CAAC,MAAM,CAE7D,CAAC,GAAG,EAAE,aAAa,EAAE,EAAE;YACvB,GAAG,CAAC,aAAa,CAAC,GAAG,IAAI,MAAM,CAAC,MAAM,CAAC,aAAa,CAAE,CAAC,CAAC;YAExD,OAAO,GAAG,CAAC;QACb,CAAC,EAAE,EAAE,CAAC,CAAC;QAEP;;;;;;WAMG;QACH,SAAS,YAAY,CACnB,IAAwD;YAExD,MAAM,IAAI,GAAG,IAAI,CAAC,sBAAsB,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;YAC3D,MAAM,aAAa,GAAc,IAAI,CAAC,aAAa,IAAI,QAAQ,CAAC;YAChE,MAAM,UAAU,GAAG,WAAW,CAAC,aAAa,CAAC,CAAC;YAE9C,MAAM,MAAM,GAAG,IAAiC,CAAC;YACjD,IAAI,MAAM,CAAC,IAAI,KAAK,aAAa,EAAE;gBACjC,OAAO;aACR;YAED,IAAI,CAAC,UAAU,IAAI,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;gBACxC,OAAO;aACR;YAED,OAAO,CAAC,MAAM,CAAC;gBACb,IAAI,EAAE,IAAI,CAAC,GAAG;gBACd,SAAS,EAAE,eAAe;gBAC1B,IAAI,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,UAAU,EAAE;aAC1C,CAAC,CAAC;QACL,CAAC;QAED,OAAO;YACL,gBAAgB,EAAE,YAAY;YAC9B,aAAa,EAAE,YAAY;SAC5B,CAAC;IACJ,CAAC;CACF,CAAC,CAAC"}

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

@@ -0,0 +1,320 @@
+"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 allMemberTypes = ['field', 'method', 'constructor'].reduce((all, type) => {
+    all.push(type);
+    ['public', 'protected', 'private'].forEach(accessibility => {
+        all.push(`${accessibility}-${type}`); // e.g. `public-field`
+        if (type !== 'constructor') {
+            // There is no `static-constructor` or `instance-constructor
+            ['static', 'instance'].forEach(scope => {
+                if (all.indexOf(`${scope}-${type}`) === -1) {
+                    all.push(`${scope}-${type}`);
+                }
+                all.push(`${accessibility}-${scope}-${type}`);
+            });
+        }
+    });
+    return all;
+}, []);
+exports.default = util.createRule({
+    name: 'member-ordering',
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Require a consistent member declaration order',
+            category: 'Stylistic Issues',
+            recommended: false,
+        },
+        messages: {
+            incorrectOrder: 'Member {{name}} should be declared before all {{rank}} definitions.',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    default: {
+                        oneOf: [
+                            {
+                                enum: ['never'],
+                            },
+                            {
+                                type: 'array',
+                                items: {
+                                    enum: allMemberTypes,
+                                },
+                            },
+                        ],
+                    },
+                    classes: {
+                        oneOf: [
+                            {
+                                enum: ['never'],
+                            },
+                            {
+                                type: 'array',
+                                items: {
+                                    enum: allMemberTypes,
+                                },
+                            },
+                        ],
+                    },
+                    classExpressions: {
+                        oneOf: [
+                            {
+                                enum: ['never'],
+                            },
+                            {
+                                type: 'array',
+                                items: {
+                                    enum: allMemberTypes,
+                                },
+                            },
+                        ],
+                    },
+                    interfaces: {
+                        oneOf: [
+                            {
+                                enum: ['never'],
+                            },
+                            {
+                                type: 'array',
+                                items: {
+                                    enum: ['field', 'method', 'constructor'],
+                                },
+                            },
+                        ],
+                    },
+                    typeLiterals: {
+                        oneOf: [
+                            {
+                                enum: ['never'],
+                            },
+                            {
+                                type: 'array',
+                                items: {
+                                    enum: ['field', 'method', 'constructor'],
+                                },
+                            },
+                        ],
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    defaultOptions: [
+        {
+            default: [
+                'public-static-field',
+                'protected-static-field',
+                'private-static-field',
+                'public-instance-field',
+                'protected-instance-field',
+                'private-instance-field',
+                'public-field',
+                'protected-field',
+                'private-field',
+                'static-field',
+                'instance-field',
+                'field',
+                'constructor',
+                'public-static-method',
+                'protected-static-method',
+                'private-static-method',
+                'public-instance-method',
+                'protected-instance-method',
+                'private-instance-method',
+                'public-method',
+                'protected-method',
+                'private-method',
+                'static-method',
+                'instance-method',
+                'method',
+            ],
+        },
+    ],
+    create(context, [options]) {
+        const sourceCode = context.getSourceCode();
+        const functionExpressions = [
+            experimental_utils_1.AST_NODE_TYPES.FunctionExpression,
+            experimental_utils_1.AST_NODE_TYPES.ArrowFunctionExpression,
+        ];
+        /**
+         * Gets the node type.
+         * @param node the node to be evaluated.
+         */
+        function getNodeType(node) {
+            // TODO: add missing TSCallSignatureDeclaration
+            // TODO: add missing TSIndexSignature
+            // TODO: add missing TSAbstractClassProperty
+            // TODO: add missing TSAbstractMethodDefinition
+            switch (node.type) {
+                case experimental_utils_1.AST_NODE_TYPES.MethodDefinition:
+                    return node.kind;
+                case experimental_utils_1.AST_NODE_TYPES.TSMethodSignature:
+                    return 'method';
+                case experimental_utils_1.AST_NODE_TYPES.TSConstructSignatureDeclaration:
+                    return 'constructor';
+                case experimental_utils_1.AST_NODE_TYPES.ClassProperty:
+                    return node.value && functionExpressions.indexOf(node.value.type) > -1
+                        ? 'method'
+                        : 'field';
+                case experimental_utils_1.AST_NODE_TYPES.TSPropertySignature:
+                    return 'field';
+                default:
+                    return null;
+            }
+        }
+        /**
+         * Gets the member name based on the member type.
+         * @param node the node to be evaluated.
+         */
+        function getMemberName(node) {
+            switch (node.type) {
+                case experimental_utils_1.AST_NODE_TYPES.TSPropertySignature:
+                case experimental_utils_1.AST_NODE_TYPES.TSMethodSignature:
+                case experimental_utils_1.AST_NODE_TYPES.ClassProperty:
+                    return util.getNameFromPropertyName(node.key);
+                case experimental_utils_1.AST_NODE_TYPES.MethodDefinition:
+                    return node.kind === 'constructor'
+                        ? 'constructor'
+                        : util.getNameFromClassMember(node, sourceCode);
+                case experimental_utils_1.AST_NODE_TYPES.TSConstructSignatureDeclaration:
+                    return 'new';
+                default:
+                    return null;
+            }
+        }
+        /**
+         * Gets the calculated rank using the provided method definition.
+         * The algorithm is as follows:
+         * - Get the rank based on the accessibility-scope-type name, e.g. public-instance-field
+         * - If there is no order for accessibility-scope-type, then strip out the accessibility.
+         * - If there is no order for scope-type, then strip out the scope.
+         * - If there is no order for type, then return -1
+         * @param memberTypes the valid names to be validated.
+         * @param order the current order to be validated.
+         *
+         * @return Index of the matching member type in the order configuration.
+         */
+        function getRankOrder(memberTypes, order) {
+            let rank = -1;
+            const stack = memberTypes.slice(); // Get a copy of the member types
+            while (stack.length > 0 && rank === -1) {
+                rank = order.indexOf(stack.shift());
+            }
+            return rank;
+        }
+        /**
+         * Gets the rank of the node given the order.
+         * @param node the node to be evaluated.
+         * @param order the current order to be validated.
+         * @param supportsModifiers a flag indicating whether the type supports modifiers (scope or accessibility) or not.
+         */
+        function getRank(node, order, supportsModifiers) {
+            const type = getNodeType(node);
+            if (type === null) {
+                // shouldn't happen but just in case, put it on the end
+                return order.length - 1;
+            }
+            const scope = 'static' in node && node.static ? 'static' : 'instance';
+            const accessibility = 'accessibility' in node && node.accessibility
+                ? node.accessibility
+                : 'public';
+            const memberTypes = [];
+            if (supportsModifiers) {
+                if (type !== 'constructor') {
+                    // Constructors have no scope
+                    memberTypes.push(`${accessibility}-${scope}-${type}`);
+                    memberTypes.push(`${scope}-${type}`);
+                }
+                memberTypes.push(`${accessibility}-${type}`);
+            }
+            memberTypes.push(type);
+            return getRankOrder(memberTypes, order);
+        }
+        /**
+         * Gets the lowest possible rank higher than target.
+         * e.g. given the following order:
+         *   ...
+         *   public-static-method
+         *   protected-static-method
+         *   private-static-method
+         *   public-instance-method
+         *   protected-instance-method
+         *   private-instance-method
+         *   ...
+         * and considering that a public-instance-method has already been declared, so ranks contains
+         * public-instance-method, then the lowest possible rank for public-static-method is
+         * public-instance-method.
+         * @param ranks the existing ranks in the object.
+         * @param target the target rank.
+         * @param order the current order to be validated.
+         * @returns the name of the lowest possible rank without dashes (-).
+         */
+        function getLowestRank(ranks, target, order) {
+            let lowest = ranks[ranks.length - 1];
+            ranks.forEach(rank => {
+                if (rank > target) {
+                    lowest = Math.min(lowest, rank);
+                }
+            });
+            return order[lowest].replace(/-/g, ' ');
+        }
+        /**
+         * Validates if all members are correctly sorted.
+         *
+         * @param members Members to be validated.
+         * @param order Current order to be validated.
+         * @param supportsModifiers A flag indicating whether the type supports modifiers (scope or accessibility) or not.
+         */
+        function validateMembersOrder(members, order, supportsModifiers) {
+            if (members && order !== 'never') {
+                const previousRanks = [];
+                // Find first member which isn't correctly sorted
+                members.forEach(member => {
+                    const rank = getRank(member, order, supportsModifiers);
+                    if (rank !== -1) {
+                        if (rank < previousRanks[previousRanks.length - 1]) {
+                            context.report({
+                                node: member,
+                                messageId: 'incorrectOrder',
+                                data: {
+                                    name: getMemberName(member),
+                                    rank: getLowestRank(previousRanks, rank, order),
+                                },
+                            });
+                        }
+                        else {
+                            previousRanks.push(rank);
+                        }
+                    }
+                });
+            }
+        }
+        return {
+            ClassDeclaration(node) {
+                validateMembersOrder(node.body.body, options.classes || options.default, true);
+            },
+            ClassExpression(node) {
+                validateMembersOrder(node.body.body, options.classExpressions || options.default, true);
+            },
+            TSInterfaceDeclaration(node) {
+                validateMembersOrder(node.body.body, options.interfaces || options.default, false);
+            },
+            TSTypeLiteral(node) {
+                validateMembersOrder(node.members, options.typeLiterals || options.default, false);
+            },
+        };
+    },
+});
+//# sourceMappingURL=member-ordering.js.map