repoburg 1.0.31 → 1.0.33

package/backend/node_modules/eslint/lib/rules/no-mixed-requires.js

@@ -1,238 +0,0 @@
-/**
- * @fileoverview Rule to enforce grouped require statements for Node.JS
- * @author Raphael Pigulla
- * @deprecated in ESLint v7.0.0
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        deprecated: true,
-
-        replacedBy: [],
-
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow `require` calls to be mixed with regular variable declarations",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-mixed-requires"
-        },
-
-        schema: [
-            {
-                oneOf: [
-                    {
-                        type: "boolean"
-                    },
-                    {
-                        type: "object",
-                        properties: {
-                            grouping: {
-                                type: "boolean"
-                            },
-                            allowCall: {
-                                type: "boolean"
-                            }
-                        },
-                        additionalProperties: false
-                    }
-                ]
-            }
-        ],
-
-        messages: {
-            noMixRequire: "Do not mix 'require' and other declarations.",
-            noMixCoreModuleFileComputed: "Do not mix core, module, file and computed requires."
-        }
-    },
-
-    create(context) {
-
-        const options = context.options[0];
-        let grouping = false,
-            allowCall = false;
-
-        if (typeof options === "object") {
-            grouping = options.grouping;
-            allowCall = options.allowCall;
-        } else {
-            grouping = !!options;
-        }
-
-        /**
-         * Returns the list of built-in modules.
-         * @returns {string[]} An array of built-in Node.js modules.
-         */
-        function getBuiltinModules() {
-
-            /*
-             * This list is generated using:
-             * `require("repl")._builtinLibs.concat('repl').sort()`
-             * This particular list is as per nodejs v0.12.2 and iojs v0.7.1
-             */
-            return [
-                "assert", "buffer", "child_process", "cluster", "crypto",
-                "dgram", "dns", "domain", "events", "fs", "http", "https",
-                "net", "os", "path", "punycode", "querystring", "readline",
-                "repl", "smalloc", "stream", "string_decoder", "tls", "tty",
-                "url", "util", "v8", "vm", "zlib"
-            ];
-        }
-
-        const BUILTIN_MODULES = getBuiltinModules();
-
-        const DECL_REQUIRE = "require",
-            DECL_UNINITIALIZED = "uninitialized",
-            DECL_OTHER = "other";
-
-        const REQ_CORE = "core",
-            REQ_FILE = "file",
-            REQ_MODULE = "module",
-            REQ_COMPUTED = "computed";
-
-        /**
-         * Determines the type of a declaration statement.
-         * @param {ASTNode} initExpression The init node of the VariableDeclarator.
-         * @returns {string} The type of declaration represented by the expression.
-         */
-        function getDeclarationType(initExpression) {
-            if (!initExpression) {
-
-                // "var x;"
-                return DECL_UNINITIALIZED;
-            }
-
-            if (initExpression.type === "CallExpression" &&
-                initExpression.callee.type === "Identifier" &&
-                initExpression.callee.name === "require"
-            ) {
-
-                // "var x = require('util');"
-                return DECL_REQUIRE;
-            }
-            if (allowCall &&
-                initExpression.type === "CallExpression" &&
-                initExpression.callee.type === "CallExpression"
-            ) {
-
-                // "var x = require('diagnose')('sub-module');"
-                return getDeclarationType(initExpression.callee);
-            }
-            if (initExpression.type === "MemberExpression") {
-
-                // "var x = require('glob').Glob;"
-                return getDeclarationType(initExpression.object);
-            }
-
-            // "var x = 42;"
-            return DECL_OTHER;
-        }
-
-        /**
-         * Determines the type of module that is loaded via require.
-         * @param {ASTNode} initExpression The init node of the VariableDeclarator.
-         * @returns {string} The module type.
-         */
-        function inferModuleType(initExpression) {
-            if (initExpression.type === "MemberExpression") {
-
-                // "var x = require('glob').Glob;"
-                return inferModuleType(initExpression.object);
-            }
-            if (initExpression.arguments.length === 0) {
-
-                // "var x = require();"
-                return REQ_COMPUTED;
-            }
-
-            const arg = initExpression.arguments[0];
-
-            if (arg.type !== "Literal" || typeof arg.value !== "string") {
-
-                // "var x = require(42);"
-                return REQ_COMPUTED;
-            }
-
-            if (BUILTIN_MODULES.includes(arg.value)) {
-
-                // "var fs = require('fs');"
-                return REQ_CORE;
-            }
-            if (/^\.{0,2}\//u.test(arg.value)) {
-
-                // "var utils = require('./utils');"
-                return REQ_FILE;
-            }
-
-            // "var async = require('async');"
-            return REQ_MODULE;
-
-        }
-
-        /**
-         * Check if the list of variable declarations is mixed, i.e. whether it
-         * contains both require and other declarations.
-         * @param {ASTNode} declarations The list of VariableDeclarators.
-         * @returns {boolean} True if the declarations are mixed, false if not.
-         */
-        function isMixed(declarations) {
-            const contains = {};
-
-            declarations.forEach(declaration => {
-                const type = getDeclarationType(declaration.init);
-
-                contains[type] = true;
-            });
-
-            return !!(
-                contains[DECL_REQUIRE] &&
-                (contains[DECL_UNINITIALIZED] || contains[DECL_OTHER])
-            );
-        }
-
-        /**
-         * Check if all require declarations in the given list are of the same
-         * type.
-         * @param {ASTNode} declarations The list of VariableDeclarators.
-         * @returns {boolean} True if the declarations are grouped, false if not.
-         */
-        function isGrouped(declarations) {
-            const found = {};
-
-            declarations.forEach(declaration => {
-                if (getDeclarationType(declaration.init) === DECL_REQUIRE) {
-                    found[inferModuleType(declaration.init)] = true;
-                }
-            });
-
-            return Object.keys(found).length <= 1;
-        }
-
-
-        return {
-
-            VariableDeclaration(node) {
-
-                if (isMixed(node.declarations)) {
-                    context.report({
-                        node,
-                        messageId: "noMixRequire"
-                    });
-                } else if (grouping && !isGrouped(node.declarations)) {
-                    context.report({
-                        node,
-                        messageId: "noMixCoreModuleFileComputed"
-                    });
-                }
-            }
-        };
-
-    }
-};

package/backend/node_modules/eslint/lib/rules/no-mixed-spaces-and-tabs.js

@@ -1,116 +0,0 @@
-/**
- * @fileoverview Disallow mixed spaces and tabs for indentation
- * @author Jary Niebur
- * @deprecated in ESLint v8.53.0
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        deprecated: true,
-        replacedBy: [],
-        type: "layout",
-
-        docs: {
-            description: "Disallow mixed spaces and tabs for indentation",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-mixed-spaces-and-tabs"
-        },
-
-        schema: [
-            {
-                enum: ["smart-tabs", true, false]
-            }
-        ],
-
-        messages: {
-            mixedSpacesAndTabs: "Mixed spaces and tabs."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        let smartTabs;
-
-        switch (context.options[0]) {
-            case true: // Support old syntax, maybe add deprecation warning here
-            case "smart-tabs":
-                smartTabs = true;
-                break;
-            default:
-                smartTabs = false;
-        }
-
-        //--------------------------------------------------------------------------
-        // Public
-        //--------------------------------------------------------------------------
-
-        return {
-
-            "Program:exit"(node) {
-                const lines = sourceCode.lines,
-                    comments = sourceCode.getAllComments(),
-                    ignoredCommentLines = new Set();
-
-                // Add all lines except the first ones.
-                comments.forEach(comment => {
-                    for (let i = comment.loc.start.line + 1; i <= comment.loc.end.line; i++) {
-                        ignoredCommentLines.add(i);
-                    }
-                });
-
-                /*
-                 * At least one space followed by a tab
-                 * or the reverse before non-tab/-space
-                 * characters begin.
-                 */
-                let regex = /^(?=( +|\t+))\1(?:\t| )/u;
-
-                if (smartTabs) {
-
-                    /*
-                     * At least one space followed by a tab
-                     * before non-tab/-space characters begin.
-                     */
-                    regex = /^(?=(\t*))\1(?=( +))\2\t/u;
-                }
-
-                lines.forEach((line, i) => {
-                    const match = regex.exec(line);
-
-                    if (match) {
-                        const lineNumber = i + 1;
-                        const loc = {
-                            start: {
-                                line: lineNumber,
-                                column: match[0].length - 2
-                            },
-                            end: {
-                                line: lineNumber,
-                                column: match[0].length
-                            }
-                        };
-
-                        if (!ignoredCommentLines.has(lineNumber)) {
-                            const containingNode = sourceCode.getNodeByRangeIndex(sourceCode.getIndexFromLoc(loc.start));
-
-                            if (!(containingNode && ["Literal", "TemplateElement"].includes(containingNode.type))) {
-                                context.report({
-                                    node,
-                                    loc,
-                                    messageId: "mixedSpacesAndTabs"
-                                });
-                            }
-                        }
-                    }
-                });
-            }
-        };
-    }
-};

package/backend/node_modules/eslint/lib/rules/no-multi-assign.js

@@ -1,67 +0,0 @@
-/**
- * @fileoverview Rule to check use of chained assignment expressions
- * @author Stewart Rand
- */
-
-"use strict";
-
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow use of chained assignment expressions",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-multi-assign"
-        },
-
-        schema: [{
-            type: "object",
-            properties: {
-                ignoreNonDeclaration: {
-                    type: "boolean",
-                    default: false
-                }
-            },
-            additionalProperties: false
-        }],
-
-        messages: {
-            unexpectedChain: "Unexpected chained assignment."
-        }
-    },
-
-    create(context) {
-
-        //--------------------------------------------------------------------------
-        // Public
-        //--------------------------------------------------------------------------
-        const options = context.options[0] || {
-            ignoreNonDeclaration: false
-        };
-        const selectors = [
-            "VariableDeclarator > AssignmentExpression.init",
-            "PropertyDefinition > AssignmentExpression.value"
-        ];
-
-        if (!options.ignoreNonDeclaration) {
-            selectors.push("AssignmentExpression > AssignmentExpression.right");
-        }
-
-        return {
-            [selectors](node) {
-                context.report({
-                    node,
-                    messageId: "unexpectedChain"
-                });
-            }
-        };
-
-    }
-};

package/backend/node_modules/eslint/lib/rules/no-multi-spaces.js

@@ -1,141 +0,0 @@
-/**
- * @fileoverview Disallow use of multiple spaces.
- * @author Nicholas C. Zakas
- * @deprecated in ESLint v8.53.0
- */
-
-"use strict";
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        deprecated: true,
-        replacedBy: [],
-        type: "layout",
-
-        docs: {
-            description: "Disallow multiple spaces",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-multi-spaces"
-        },
-
-        fixable: "whitespace",
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    exceptions: {
-                        type: "object",
-                        patternProperties: {
-                            "^([A-Z][a-z]*)+$": {
-                                type: "boolean"
-                            }
-                        },
-                        additionalProperties: false
-                    },
-                    ignoreEOLComments: {
-                        type: "boolean",
-                        default: false
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        messages: {
-            multipleSpaces: "Multiple spaces found before '{{displayValue}}'."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-        const options = context.options[0] || {};
-        const ignoreEOLComments = options.ignoreEOLComments;
-        const exceptions = Object.assign({ Property: true }, options.exceptions);
-        const hasExceptions = Object.keys(exceptions).some(key => exceptions[key]);
-
-        /**
-         * Formats value of given comment token for error message by truncating its length.
-         * @param {Token} token comment token
-         * @returns {string} formatted value
-         * @private
-         */
-        function formatReportedCommentValue(token) {
-            const valueLines = token.value.split("\n");
-            const value = valueLines[0];
-            const formattedValue = `${value.slice(0, 12)}...`;
-
-            return valueLines.length === 1 && value.length <= 12 ? value : formattedValue;
-        }
-
-        //--------------------------------------------------------------------------
-        // Public
-        //--------------------------------------------------------------------------
-
-        return {
-            Program() {
-                sourceCode.tokensAndComments.forEach((leftToken, leftIndex, tokensAndComments) => {
-                    if (leftIndex === tokensAndComments.length - 1) {
-                        return;
-                    }
-                    const rightToken = tokensAndComments[leftIndex + 1];
-
-                    // Ignore tokens that don't have 2 spaces between them or are on different lines
-                    if (
-                        !sourceCode.text.slice(leftToken.range[1], rightToken.range[0]).includes("  ") ||
-                        leftToken.loc.end.line < rightToken.loc.start.line
-                    ) {
-                        return;
-                    }
-
-                    // Ignore comments that are the last token on their line if `ignoreEOLComments` is active.
-                    if (
-                        ignoreEOLComments &&
-                        astUtils.isCommentToken(rightToken) &&
-                        (
-                            leftIndex === tokensAndComments.length - 2 ||
-                            rightToken.loc.end.line < tokensAndComments[leftIndex + 2].loc.start.line
-                        )
-                    ) {
-                        return;
-                    }
-
-                    // Ignore tokens that are in a node in the "exceptions" object
-                    if (hasExceptions) {
-                        const parentNode = sourceCode.getNodeByRangeIndex(rightToken.range[0] - 1);
-
-                        if (parentNode && exceptions[parentNode.type]) {
-                            return;
-                        }
-                    }
-
-                    let displayValue;
-
-                    if (rightToken.type === "Block") {
-                        displayValue = `/*${formatReportedCommentValue(rightToken)}*/`;
-                    } else if (rightToken.type === "Line") {
-                        displayValue = `//${formatReportedCommentValue(rightToken)}`;
-                    } else {
-                        displayValue = rightToken.value;
-                    }
-
-                    context.report({
-                        node: rightToken,
-                        loc: { start: leftToken.loc.end, end: rightToken.loc.start },
-                        messageId: "multipleSpaces",
-                        data: { displayValue },
-                        fix: fixer => fixer.replaceTextRange([leftToken.range[1], rightToken.range[0]], " ")
-                    });
-                });
-            }
-        };
-
-    }
-};

package/backend/node_modules/eslint/lib/rules/no-multi-str.js

@@ -1,65 +0,0 @@
-/**
- * @fileoverview Rule to flag when using multiline strings
- * @author Ilya Volodin
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow multiline strings",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-multi-str"
-        },
-
-        schema: [],
-
-        messages: {
-            multilineString: "Multiline support is limited to browsers supporting ES5 only."
-        }
-    },
-
-    create(context) {
-
-        /**
-         * Determines if a given node is part of JSX syntax.
-         * @param {ASTNode} node The node to check.
-         * @returns {boolean} True if the node is a JSX node, false if not.
-         * @private
-         */
-        function isJSXElement(node) {
-            return node.type.indexOf("JSX") === 0;
-        }
-
-        //--------------------------------------------------------------------------
-        // Public API
-        //--------------------------------------------------------------------------
-
-        return {
-
-            Literal(node) {
-                if (astUtils.LINEBREAK_MATCHER.test(node.raw) && !isJSXElement(node.parent)) {
-                    context.report({
-                        node,
-                        messageId: "multilineString"
-                    });
-                }
-            }
-        };
-
-    }
-};