@blumintinc/eslint-plugin-blumint 0.1.23 → 1.0.2

package/lib/utils/ASTHelpers.js

@@ -1,336 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ASTHelpers = void 0;
-class ASTHelpers {
-    static blockIncludesIdentifier(block) {
-        for (const statement of block.body) {
-            if (ASTHelpers.declarationIncludesIdentifier(statement)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    static declarationIncludesIdentifier(node) {
-        if (!node) {
-            return false;
-        }
-        switch (node.type) {
-            case 'TSNonNullExpression':
-                return this.declarationIncludesIdentifier(node.expression);
-            case 'ArrayPattern':
-                return node.elements.some((element) => ASTHelpers.declarationIncludesIdentifier(element));
-            case 'ObjectPattern':
-                return node.properties.some((property) => this.declarationIncludesIdentifier(property.value || null));
-            case 'AssignmentPattern':
-                return this.declarationIncludesIdentifier(node.left);
-            case 'RestElement':
-                return this.declarationIncludesIdentifier(node.argument);
-            case 'AwaitExpression':
-                return this.declarationIncludesIdentifier(node.argument);
-            case 'AssignmentExpression':
-                return (this.declarationIncludesIdentifier(node.left) ||
-                    this.declarationIncludesIdentifier(node.right));
-            case 'BlockStatement':
-                return node.body.some((statement) => statement.type === 'BlockStatement' &&
-                    ASTHelpers.blockIncludesIdentifier(statement));
-            case 'IfStatement':
-                return (this.declarationIncludesIdentifier(node.test) ||
-                    this.declarationIncludesIdentifier(node.consequent) ||
-                    this.declarationIncludesIdentifier(node.alternate));
-            case 'TSTypeAssertion':
-                return this.declarationIncludesIdentifier(node.expression);
-            case 'Identifier':
-                return true;
-            case 'SpreadElement':
-                return ASTHelpers.declarationIncludesIdentifier(node.argument);
-            case 'ChainExpression':
-                return ASTHelpers.declarationIncludesIdentifier(node.expression);
-            case 'ArrayExpression':
-                return node.elements.some((element) => element &&
-                    (element.type === 'SpreadElement'
-                        ? ASTHelpers.declarationIncludesIdentifier(element.argument)
-                        : ASTHelpers.declarationIncludesIdentifier(element)));
-            case 'ObjectExpression':
-                return node.properties.some((property) => {
-                    if (property.type === 'Property') {
-                        return ASTHelpers.declarationIncludesIdentifier(property.value);
-                    }
-                    else if (property.type === 'SpreadElement') {
-                        return ASTHelpers.declarationIncludesIdentifier(property.argument);
-                    }
-                    return false;
-                });
-            case 'Property':
-                return this.declarationIncludesIdentifier(node.value);
-            case 'BinaryExpression':
-            case 'LogicalExpression':
-                return (this.declarationIncludesIdentifier(node.left) ||
-                    this.declarationIncludesIdentifier(node.right));
-            case 'UnaryExpression':
-            case 'UpdateExpression':
-                return this.declarationIncludesIdentifier(node.argument);
-            case 'MemberExpression':
-                if (node.object.type === 'ThisExpression') {
-                    return true;
-                }
-                return (this.declarationIncludesIdentifier(node.object) ||
-                    this.declarationIncludesIdentifier(node.property));
-            case 'CallExpression':
-            case 'NewExpression':
-                // For function and constructor calls, we care about both the callee and the arguments.
-                return (this.declarationIncludesIdentifier(node.callee) ||
-                    node.arguments.some((arg) => this.declarationIncludesIdentifier(arg)));
-            case 'ConditionalExpression':
-                return (this.declarationIncludesIdentifier(node.test) ||
-                    this.declarationIncludesIdentifier(node.consequent) ||
-                    this.declarationIncludesIdentifier(node.alternate));
-            case 'TSAsExpression':
-                return this.declarationIncludesIdentifier(node.expression);
-            default:
-                return false;
-        }
-    }
-    static classMethodDependenciesOf(node, graph, className) {
-        const dependencies = [];
-        if (!node) {
-            return dependencies;
-        }
-        switch (node.type) {
-            case 'MethodDefinition':
-                const functionBody = node.value.body;
-                return (functionBody?.body || [])
-                    .map((statement) => ASTHelpers.classMethodDependenciesOf(statement, graph, className))
-                    .flat();
-            case 'Identifier':
-                dependencies.push(node.name);
-                break;
-            case 'ExpressionStatement':
-                return ASTHelpers.classMethodDependenciesOf(node.expression, graph, className);
-            case 'MemberExpression':
-                if ((node.object.type === 'ThisExpression' &&
-                    node.property.type === 'Identifier') ||
-                    (node.object.type === 'Identifier' &&
-                        node.object.name === className &&
-                        node.property.type === 'Identifier')) {
-                    dependencies.push(node.property.name);
-                }
-                else {
-                    return [
-                        ...ASTHelpers.classMethodDependenciesOf(node.object, graph, className),
-                        ...ASTHelpers.classMethodDependenciesOf(node.property, graph, className),
-                    ];
-                }
-                break;
-            case 'TSNonNullExpression':
-                return ASTHelpers.classMethodDependenciesOf(node.expression, graph, className);
-            case 'ArrayPattern':
-                return node.elements
-                    .map((element) => ASTHelpers.classMethodDependenciesOf(element, graph, className))
-                    .flat();
-            case 'ObjectPattern':
-                return node.properties
-                    .map((property) => ASTHelpers.classMethodDependenciesOf(property.value || null, graph, className))
-                    .flat();
-            case 'AssignmentPattern':
-                return ASTHelpers.classMethodDependenciesOf(node.left, graph, className);
-            case 'RestElement':
-                return ASTHelpers.classMethodDependenciesOf(node.argument, graph, className);
-            case 'AwaitExpression':
-                return ASTHelpers.classMethodDependenciesOf(node.argument, graph, className);
-            case 'AssignmentExpression':
-                return [
-                    ...ASTHelpers.classMethodDependenciesOf(node.left, graph, className),
-                    ...ASTHelpers.classMethodDependenciesOf(node.right, graph, className),
-                ];
-            case 'BlockStatement':
-                return node.body
-                    .map((statement) => ASTHelpers.classMethodDependenciesOf(statement, graph, className))
-                    .flat()
-                    .filter(Boolean);
-            case 'IfStatement':
-                return [
-                    ...ASTHelpers.classMethodDependenciesOf(node.test, graph, className),
-                    ...ASTHelpers.classMethodDependenciesOf(node.consequent, graph, className),
-                    ...ASTHelpers.classMethodDependenciesOf(node.alternate, graph, className),
-                ];
-            case 'TSTypeAssertion':
-                return ASTHelpers.classMethodDependenciesOf(node.expression, graph, className);
-            case 'Identifier':
-                return dependencies;
-            case 'SpreadElement':
-                return ASTHelpers.classMethodDependenciesOf(node.argument, graph, className);
-            case 'ChainExpression':
-                return ASTHelpers.classMethodDependenciesOf(node.expression, graph, className);
-            case 'ArrayExpression':
-                return node.elements
-                    .map((element) => element &&
-                    (element.type === 'SpreadElement'
-                        ? ASTHelpers.classMethodDependenciesOf(element.argument, graph, className)
-                        : ASTHelpers.classMethodDependenciesOf(element, graph, className)))
-                    .flat()
-                    .filter(Boolean);
-            case 'ObjectExpression':
-                return node.properties
-                    .map((property) => {
-                    if (property.type === 'Property') {
-                        return ASTHelpers.classMethodDependenciesOf(property.value, graph, className);
-                    }
-                    else if (property.type === 'SpreadElement') {
-                        return ASTHelpers.classMethodDependenciesOf(property.argument, graph, className);
-                    }
-                    return false;
-                })
-                    .flat()
-                    .filter(Boolean);
-            case 'Property':
-                return ASTHelpers.classMethodDependenciesOf(node.value, graph, className);
-            case 'BinaryExpression':
-            case 'LogicalExpression':
-                return [
-                    ...ASTHelpers.classMethodDependenciesOf(node.left, graph, className),
-                    ...ASTHelpers.classMethodDependenciesOf(node.right, graph, className),
-                ];
-            case 'UnaryExpression':
-            case 'UpdateExpression':
-                return ASTHelpers.classMethodDependenciesOf(node.argument, graph, className);
-            case 'CallExpression':
-            case 'NewExpression':
-                // For function and constructor calls, we care about both the callee and the arguments.
-                return [
-                    ...ASTHelpers.classMethodDependenciesOf(node.callee, graph, className),
-                    ...node.arguments
-                        .map((arg) => ASTHelpers.classMethodDependenciesOf(arg, graph, className))
-                        .flat(),
-                ];
-            case 'ConditionalExpression':
-                return [
-                    ...ASTHelpers.classMethodDependenciesOf(node.test, graph, className),
-                    ...ASTHelpers.classMethodDependenciesOf(node.consequent, graph, className),
-                    ...ASTHelpers.classMethodDependenciesOf(node.alternate, graph, className),
-                ];
-            case 'TSAsExpression':
-                return ASTHelpers.classMethodDependenciesOf(node.expression, graph, className);
-            case 'VariableDeclaration':
-                return node.declarations
-                    .map((declaration) => ASTHelpers.classMethodDependenciesOf(declaration, graph, className))
-                    .flat()
-                    .filter(Boolean);
-            case 'VariableDeclarator':
-                return ASTHelpers.classMethodDependenciesOf(node.init, graph, className);
-            case 'ForOfStatement':
-                return [
-                    ...ASTHelpers.classMethodDependenciesOf(node.left, graph, className),
-                    ...ASTHelpers.classMethodDependenciesOf(node.body, graph, className),
-                    ...ASTHelpers.classMethodDependenciesOf(node.right, graph, className),
-                ];
-            case 'ForStatement':
-                return [node.body, node.init, node.test, node.update]
-                    .map((node) => ASTHelpers.classMethodDependenciesOf(node, graph, className))
-                    .flat();
-            case 'ThrowStatement':
-                return ASTHelpers.classMethodDependenciesOf(node.argument, graph, className);
-            case 'TemplateLiteral':
-                return node.expressions
-                    .map((expression) => ASTHelpers.classMethodDependenciesOf(expression, graph, className))
-                    .flat();
-            case 'ReturnStatement':
-                return ASTHelpers.classMethodDependenciesOf(node.argument, graph, className);
-            case 'ArrowFunctionExpression':
-                return [
-                    ...node.params.flatMap((param) => ASTHelpers.classMethodDependenciesOf(param, graph, className)),
-                    ...ASTHelpers.classMethodDependenciesOf(node.body, graph, className),
-                ];
-            default:
-                break;
-        }
-        // Removing duplicates
-        return [
-            ...new Set(dependencies.filter((dep) => graph?.[dep]?.type !== 'property')),
-        ];
-    }
-    static isNode(value) {
-        return typeof value === 'object' && value !== null && 'type' in value;
-    }
-    static hasReturnStatement(node) {
-        if (node.type === 'ReturnStatement') {
-            return true;
-        }
-        if (node.type === 'IfStatement') {
-            const consequentHasReturn = ASTHelpers.hasReturnStatement(node.consequent);
-            const alternateHasReturn = !!node.alternate && ASTHelpers.hasReturnStatement(node.alternate);
-            return consequentHasReturn && alternateHasReturn;
-        }
-        if (node.type === 'BlockStatement') {
-            for (const statement of node.body) {
-                if (ASTHelpers.hasReturnStatement(statement)) {
-                    return true;
-                }
-            }
-        }
-        for (const key in node) {
-            if (key === 'parent') {
-                continue; // Ignore the parent property
-            }
-            const value = node[key];
-            if (ASTHelpers.isNode(value)) {
-                if (ASTHelpers.hasReturnStatement(value)) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-    static isNodeExported(node) {
-        // Checking if the node is exported as a named export.
-        if (node.parent && node.parent.type === 'ExportNamedDeclaration') {
-            return true;
-        }
-        // Checking if the node is exported as default.
-        if (node.parent &&
-            node.parent.parent &&
-            node.parent.parent.type === 'ExportDefaultDeclaration') {
-            return true;
-        }
-        // Checking if the node is exported in a list of exports.
-        if (node.parent &&
-            node.parent.parent &&
-            node.parent.parent.type === 'ExportSpecifier' &&
-            node.parent.parent.exported.name === node.name) {
-            return true;
-        }
-        return false;
-    }
-    static returnsJSX(node) {
-        if (node.type === 'JSXElement' || node.type === 'JSXFragment') {
-            return true;
-        }
-        if (node.type === 'BlockStatement') {
-            for (const statement of node.body) {
-                if (statement.type === 'ReturnStatement' &&
-                    (statement.argument?.type === 'JSXElement' ||
-                        statement.argument?.type === 'JSXFragment')) {
-                    return true;
-                }
-                // Handle conditional returns
-                if (statement.type === 'ReturnStatement' &&
-                    statement.argument?.type === 'ConditionalExpression') {
-                    const conditionalExpr = statement.argument;
-                    if (ASTHelpers.returnsJSX(conditionalExpr.consequent) ||
-                        ASTHelpers.returnsJSX(conditionalExpr.alternate)) {
-                        return true;
-                    }
-                }
-            }
-        }
-        if (node.type === 'ConditionalExpression') {
-            return (ASTHelpers.returnsJSX(node.consequent) ||
-                ASTHelpers.returnsJSX(node.alternate));
-        }
-        return false;
-    }
-    static hasParameters(node) {
-        return node.params && node.params.length > 0;
-    }
-}
-exports.ASTHelpers = ASTHelpers;
-//# sourceMappingURL=ASTHelpers.js.map

package/lib/utils/ClassGraphBuilder.js

@@ -1,80 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClassGraphBuilder = void 0;
-/* eslint-disable security/detect-object-injection */
-const utils_1 = require("@typescript-eslint/utils");
-const ClassGraphSorter_1 = require("./ClassGraphSorter");
-const ASTHelpers_1 = require("./ASTHelpers");
-/**
- * Builds a graph of class methods and properties with their dependencies from a class declaration.
- * A dependency in this case is the name of another class method.
- */
-class ClassGraphBuilder {
-    constructor(className, classBody) {
-        this.className = className;
-        this.classBody = classBody;
-        this.graph = {};
-        this.buildGraph();
-        // Note: extension requires injection of other sorters
-        this.sorter = new ClassGraphSorter_1.ClassGraphSorterReadability(this.graph);
-    }
-    buildGraph() {
-        // NOTE: these need to be run sequentially for each member,
-        // since we need to know the class members before we can search
-        // methods for dependencies
-        this.classBody.body.forEach((member) => {
-            if (ClassGraphBuilder.isClassMember(member)) {
-                this.addMemberToGraph(member);
-            }
-        });
-        this.classBody.body.forEach((member) => {
-            if (ClassGraphBuilder.isNamedClassMethod(member)) {
-                const { key } = member;
-                if (utils_1.ASTUtils.isIdentifier(key)) {
-                    this.addDependencies(member, key.name);
-                }
-            }
-        });
-    }
-    static isClassMember(node) {
-        return (node.type === 'MethodDefinition' || node.type === 'PropertyDefinition');
-    }
-    addMemberToGraph(member) {
-        const name = member.key.name;
-        const type = ClassGraphBuilder.nodeTypeOf(member);
-        const node = ClassGraphBuilder.createGraphNode(name, type, member.accessibility, member.static);
-        this.graph[name] = node;
-    }
-    static nodeTypeOf(member) {
-        if (member.type === 'MethodDefinition') {
-            return member.kind === 'constructor' ? 'constructor' : 'method';
-        }
-        return 'property';
-    }
-    static createGraphNode(name, type, accessibility, isStatic = false) {
-        return {
-            name,
-            type,
-            accessibility,
-            isStatic,
-            dependencies: [],
-        };
-    }
-    static isNamedClassMethod(node) {
-        return node.type === 'MethodDefinition';
-    }
-    addDependencies(node, methodName) {
-        const newDependencies = ASTHelpers_1.ASTHelpers.classMethodDependenciesOf(node, this.graph, this.className).filter((name) => !!this.graph[name] && name !== methodName);
-        if (this.graph[methodName]) {
-            this.graph[methodName].dependencies.push(...newDependencies);
-        }
-    }
-    get graphSorted() {
-        return this.sorter.nodesSorted;
-    }
-    get memberNamesSorted() {
-        return this.sorter.nodeNamesSorted;
-    }
-}
-exports.ClassGraphBuilder = ClassGraphBuilder;
-//# sourceMappingURL=ClassGraphBuilder.js.map

package/lib/utils/ClassGraphSorter.js

@@ -1,99 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClassGraphSorterReadability = exports.ClassGraphSorter = void 0;
-class ClassGraphSorter {
-    constructor(graph) {
-        this.graph = graph;
-    }
-}
-exports.ClassGraphSorter = ClassGraphSorter;
-class ClassGraphSorterReadability extends ClassGraphSorter {
-    constructor(graph) {
-        super(graph);
-        this.graph = graph;
-    }
-    get nodeNamesSorted() {
-        return this.nodesSorted.map((node) => node.name);
-    }
-    get nodesSorted() {
-        return this.sortNodes();
-    }
-    sortNodes() {
-        const { methods, properties, classConstructor } = this.groupNodesByType();
-        const [propertiesSorted, methodsSorted] = [properties, methods].map((nodeGroup) => nodeGroup.sort(ClassGraphSorterReadability.sortMembersForReadability));
-        const searchNodeCandidates = [classConstructor, ...methodsSorted].filter((node) => !!node);
-        const searchNodeCandidatesValidated = searchNodeCandidates.filter((method, _index, arr) => ClassGraphSorterReadability.SEARCH_NODE_PRIORITY_FUNCTIONS.some((fn) => !!fn(method, arr)));
-        const searchNodesSorted = searchNodeCandidatesValidated.sort((a, b) => {
-            const getPriority = (method) => {
-                const priority = ClassGraphSorterReadability.SEARCH_NODE_PRIORITY_FUNCTIONS.findIndex((fn) => !!fn(method, methodsSorted));
-                return priority === -1
-                    ? ClassGraphSorterReadability.SEARCH_NODE_PRIORITY_FUNCTIONS.length
-                    : priority;
-            };
-            return getPriority(a) - getPriority(b);
-        });
-        const dfsSortedNodes = this.dependencyDfs(searchNodesSorted);
-        return [...propertiesSorted, ...dfsSortedNodes];
-    }
-    groupNodesByType() {
-        const nodes = Object.values(this.graph);
-        return nodes.reduce((acc, node) => {
-            switch (node.type) {
-                case 'property':
-                    acc.properties.push(node);
-                    break;
-                case 'constructor':
-                    acc.classConstructor = node;
-                    break;
-                case 'method':
-                    acc.methods.push(node);
-                    break;
-            }
-            return acc;
-        }, {
-            properties: [],
-            methods: [],
-            classConstructor: null,
-        });
-    }
-    static sortMembersForReadability(a, b) {
-        // NOTE: the ordering from Object.entries is safe here since it is readonly
-        for (const [key, priorities] of Object.entries(ClassGraphSorterReadability.MODIFIER_PRIORITY_MAP)) {
-            const indexA = priorities.indexOf(a[key]);
-            const indexB = priorities.indexOf(b[key]);
-            if (indexA !== indexB) {
-                return indexA - indexB;
-            }
-        }
-        return 0;
-    }
-    dependencyDfs(searchNodes) {
-        const visited = new Set();
-        const dfsSortedNodes = [];
-        const dfs = (node) => {
-            if (visited.has(node.name) || !node) {
-                return;
-            }
-            visited.add(node.name);
-            dfsSortedNodes.push(node);
-            for (const dep of node.dependencies) {
-                dfs(this.graph[String(dep)]);
-            }
-        };
-        searchNodes.forEach((node) => dfs(node));
-        return dfsSortedNodes;
-    }
-}
-exports.ClassGraphSorterReadability = ClassGraphSorterReadability;
-ClassGraphSorterReadability.MODIFIER_PRIORITY_MAP = {
-    isStatic: [true, false],
-    accessibility: ['public', undefined, 'private'],
-};
-ClassGraphSorterReadability.SEARCH_NODE_PRIORITY_FUNCTIONS = [
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    (method, _methods) => method.type === 'constructor',
-    (method, _methods) => !_methods.some((node) => node.dependencies.includes(method.name)),
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    (method, _methods) => method.dependencies.length === 0,
-];
-//# sourceMappingURL=ClassGraphSorter.js.map

package/lib/utils/createRule.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createRule = void 0;
-const utils_1 = require("@typescript-eslint/utils");
-exports.createRule = utils_1.ESLintUtils.RuleCreator((name) => `https://github.com/BluMintInc/eslint-custom-rules/plugin/docs/rules/${name}.md`);
-//# sourceMappingURL=createRule.js.map

package/lib/utils/graph/ClassGraphBuilder.js

@@ -1,80 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClassGraphBuilder = void 0;
-/* eslint-disable security/detect-object-injection */
-const utils_1 = require("@typescript-eslint/utils");
-const ClassGraphSorterReadability_1 = require("./ClassGraphSorterReadability");
-const ASTHelpers_1 = require("../ASTHelpers");
-/**
- * Builds a graph of class methods and properties with their dependencies from a class declaration.
- * A dependency in this case is the name of another class method.
- */
-class ClassGraphBuilder {
-    constructor(className, classBody) {
-        this.className = className;
-        this.classBody = classBody;
-        this.graph = {};
-        this.buildGraph();
-        // Note: extension requires injection of other sorters
-        this.sorter = new ClassGraphSorterReadability_1.ClassGraphSorterReadability(this.graph);
-    }
-    buildGraph() {
-        // NOTE: these need to be run sequentially for each member,
-        // since we need to know the class members before we can search
-        // methods for dependencies
-        this.classBody.body.forEach((member) => {
-            if (ClassGraphBuilder.isClassMember(member)) {
-                this.addMemberToGraph(member);
-            }
-        });
-        this.classBody.body.forEach((member) => {
-            if (ClassGraphBuilder.isNamedClassMethod(member)) {
-                const { key } = member;
-                if (utils_1.ASTUtils.isIdentifier(key)) {
-                    this.addDependencies(member, key.name);
-                }
-            }
-        });
-    }
-    static isClassMember(node) {
-        return (node.type === 'MethodDefinition' || node.type === 'PropertyDefinition');
-    }
-    addMemberToGraph(member) {
-        const name = member.key.name;
-        const type = ClassGraphBuilder.nodeTypeOf(member);
-        const node = ClassGraphBuilder.createGraphNode(name, type, member.accessibility, member.static);
-        this.graph[name] = node;
-    }
-    static nodeTypeOf(member) {
-        if (member.type === 'MethodDefinition') {
-            return member.kind === 'constructor' ? 'constructor' : 'method';
-        }
-        return 'property';
-    }
-    static createGraphNode(name, type, accessibility, isStatic = false) {
-        return {
-            name,
-            type,
-            accessibility,
-            isStatic,
-            dependencies: [],
-        };
-    }
-    static isNamedClassMethod(node) {
-        return node.type === 'MethodDefinition';
-    }
-    addDependencies(node, methodName) {
-        const newDependencies = ASTHelpers_1.ASTHelpers.classMethodDependenciesOf(node, this.graph, this.className).filter((name) => !!this.graph[name] && name !== methodName);
-        if (this.graph[methodName]) {
-            this.graph[methodName].dependencies.push(...newDependencies);
-        }
-    }
-    get graphSorted() {
-        return this.sorter.nodesSorted;
-    }
-    get memberNamesSorted() {
-        return this.sorter.nodeNamesSorted;
-    }
-}
-exports.ClassGraphBuilder = ClassGraphBuilder;
-//# sourceMappingURL=ClassGraphBuilder.js.map

package/lib/utils/graph/ClassGraphSorter.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ClassGraphSorter = void 0;
-class ClassGraphSorter {
-    constructor(graph) {
-        this.graph = graph;
-    }
-}
-exports.ClassGraphSorter = ClassGraphSorter;
-//# sourceMappingURL=ClassGraphSorter.js.map