repoburg 1.0.31 → 1.0.33

package/backend/node_modules/eslint/lib/rules/switch-colon-spacing.js

@@ -1,132 +0,0 @@
-/**
- * @fileoverview Rule to enforce spacing around colons of switch statements.
- * @author Toru Nagashima
- * @deprecated in ESLint v8.53.0
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        deprecated: true,
-        replacedBy: [],
-        type: "layout",
-
-        docs: {
-            description: "Enforce spacing around colons of switch statements",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/switch-colon-spacing"
-        },
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    before: { type: "boolean", default: false },
-                    after: { type: "boolean", default: true }
-                },
-                additionalProperties: false
-            }
-        ],
-        fixable: "whitespace",
-        messages: {
-            expectedBefore: "Expected space(s) before this colon.",
-            expectedAfter: "Expected space(s) after this colon.",
-            unexpectedBefore: "Unexpected space(s) before this colon.",
-            unexpectedAfter: "Unexpected space(s) after this colon."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-        const options = context.options[0] || {};
-        const beforeSpacing = options.before === true; // false by default
-        const afterSpacing = options.after !== false; // true by default
-
-        /**
-         * Check whether the spacing between the given 2 tokens is valid or not.
-         * @param {Token} left The left token to check.
-         * @param {Token} right The right token to check.
-         * @param {boolean} expected The expected spacing to check. `true` if there should be a space.
-         * @returns {boolean} `true` if the spacing between the tokens is valid.
-         */
-        function isValidSpacing(left, right, expected) {
-            return (
-                astUtils.isClosingBraceToken(right) ||
-                !astUtils.isTokenOnSameLine(left, right) ||
-                sourceCode.isSpaceBetweenTokens(left, right) === expected
-            );
-        }
-
-        /**
-         * Check whether comments exist between the given 2 tokens.
-         * @param {Token} left The left token to check.
-         * @param {Token} right The right token to check.
-         * @returns {boolean} `true` if comments exist between the given 2 tokens.
-         */
-        function commentsExistBetween(left, right) {
-            return sourceCode.getFirstTokenBetween(
-                left,
-                right,
-                {
-                    includeComments: true,
-                    filter: astUtils.isCommentToken
-                }
-            ) !== null;
-        }
-
-        /**
-         * Fix the spacing between the given 2 tokens.
-         * @param {RuleFixer} fixer The fixer to fix.
-         * @param {Token} left The left token of fix range.
-         * @param {Token} right The right token of fix range.
-         * @param {boolean} spacing The spacing style. `true` if there should be a space.
-         * @returns {Fix|null} The fix object.
-         */
-        function fix(fixer, left, right, spacing) {
-            if (commentsExistBetween(left, right)) {
-                return null;
-            }
-            if (spacing) {
-                return fixer.insertTextAfter(left, " ");
-            }
-            return fixer.removeRange([left.range[1], right.range[0]]);
-        }
-
-        return {
-            SwitchCase(node) {
-                const colonToken = astUtils.getSwitchCaseColonToken(node, sourceCode);
-                const beforeToken = sourceCode.getTokenBefore(colonToken);
-                const afterToken = sourceCode.getTokenAfter(colonToken);
-
-                if (!isValidSpacing(beforeToken, colonToken, beforeSpacing)) {
-                    context.report({
-                        node,
-                        loc: colonToken.loc,
-                        messageId: beforeSpacing ? "expectedBefore" : "unexpectedBefore",
-                        fix: fixer => fix(fixer, beforeToken, colonToken, beforeSpacing)
-                    });
-                }
-                if (!isValidSpacing(colonToken, afterToken, afterSpacing)) {
-                    context.report({
-                        node,
-                        loc: colonToken.loc,
-                        messageId: afterSpacing ? "expectedAfter" : "unexpectedAfter",
-                        fix: fixer => fix(fixer, colonToken, afterToken, afterSpacing)
-                    });
-                }
-            }
-        };
-    }
-};

package/backend/node_modules/eslint/lib/rules/symbol-description.js

@@ -1,73 +0,0 @@
-/**
- * @fileoverview Rule to enforce description with the `Symbol` object
- * @author Jarek Rencz
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Require symbol descriptions",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/symbol-description"
-        },
-        fixable: null,
-        schema: [],
-        messages: {
-            expected: "Expected Symbol to have a description."
-        }
-    },
-
-    create(context) {
-
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Reports if node does not conform the rule in case rule is set to
-         * report missing description
-         * @param {ASTNode} node A CallExpression node to check.
-         * @returns {void}
-         */
-        function checkArgument(node) {
-            if (node.arguments.length === 0) {
-                context.report({
-                    node,
-                    messageId: "expected"
-                });
-            }
-        }
-
-        return {
-            "Program:exit"(node) {
-                const scope = sourceCode.getScope(node);
-                const variable = astUtils.getVariableByName(scope, "Symbol");
-
-                if (variable && variable.defs.length === 0) {
-                    variable.references.forEach(reference => {
-                        const idNode = reference.identifier;
-
-                        if (astUtils.isCallee(idNode)) {
-                            checkArgument(idNode.parent);
-                        }
-                    });
-                }
-            }
-        };
-
-    }
-};

package/backend/node_modules/eslint/lib/rules/template-curly-spacing.js

@@ -1,144 +0,0 @@
-/**
- * @fileoverview Rule to enforce spacing around embedded expressions of template strings
- * @author Toru Nagashima
- * @deprecated in ESLint v8.53.0
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        deprecated: true,
-        replacedBy: [],
-        type: "layout",
-
-        docs: {
-            description: "Require or disallow spacing around embedded expressions of template strings",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/template-curly-spacing"
-        },
-
-        fixable: "whitespace",
-
-        schema: [
-            { enum: ["always", "never"] }
-        ],
-        messages: {
-            expectedBefore: "Expected space(s) before '}'.",
-            expectedAfter: "Expected space(s) after '${'.",
-            unexpectedBefore: "Unexpected space(s) before '}'.",
-            unexpectedAfter: "Unexpected space(s) after '${'."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-        const always = context.options[0] === "always";
-
-        /**
-         * Checks spacing before `}` of a given token.
-         * @param {Token} token A token to check. This is a Template token.
-         * @returns {void}
-         */
-        function checkSpacingBefore(token) {
-            if (!token.value.startsWith("}")) {
-                return; // starts with a backtick, this is the first template element in the template literal
-            }
-
-            const prevToken = sourceCode.getTokenBefore(token, { includeComments: true }),
-                hasSpace = sourceCode.isSpaceBetween(prevToken, token);
-
-            if (!astUtils.isTokenOnSameLine(prevToken, token)) {
-                return;
-            }
-
-            if (always && !hasSpace) {
-                context.report({
-                    loc: {
-                        start: token.loc.start,
-                        end: {
-                            line: token.loc.start.line,
-                            column: token.loc.start.column + 1
-                        }
-                    },
-                    messageId: "expectedBefore",
-                    fix: fixer => fixer.insertTextBefore(token, " ")
-                });
-            }
-
-            if (!always && hasSpace) {
-                context.report({
-                    loc: {
-                        start: prevToken.loc.end,
-                        end: token.loc.start
-                    },
-                    messageId: "unexpectedBefore",
-                    fix: fixer => fixer.removeRange([prevToken.range[1], token.range[0]])
-                });
-            }
-        }
-
-        /**
-         * Checks spacing after `${` of a given token.
-         * @param {Token} token A token to check. This is a Template token.
-         * @returns {void}
-         */
-        function checkSpacingAfter(token) {
-            if (!token.value.endsWith("${")) {
-                return; // ends with a backtick, this is the last template element in the template literal
-            }
-
-            const nextToken = sourceCode.getTokenAfter(token, { includeComments: true }),
-                hasSpace = sourceCode.isSpaceBetween(token, nextToken);
-
-            if (!astUtils.isTokenOnSameLine(token, nextToken)) {
-                return;
-            }
-
-            if (always && !hasSpace) {
-                context.report({
-                    loc: {
-                        start: {
-                            line: token.loc.end.line,
-                            column: token.loc.end.column - 2
-                        },
-                        end: token.loc.end
-                    },
-                    messageId: "expectedAfter",
-                    fix: fixer => fixer.insertTextAfter(token, " ")
-                });
-            }
-
-            if (!always && hasSpace) {
-                context.report({
-                    loc: {
-                        start: token.loc.end,
-                        end: nextToken.loc.start
-                    },
-                    messageId: "unexpectedAfter",
-                    fix: fixer => fixer.removeRange([token.range[1], nextToken.range[0]])
-                });
-            }
-        }
-
-        return {
-            TemplateElement(node) {
-                const token = sourceCode.getFirstToken(node);
-
-                checkSpacingBefore(token);
-                checkSpacingAfter(token);
-            }
-        };
-    }
-};

package/backend/node_modules/eslint/lib/rules/template-tag-spacing.js

@@ -1,93 +0,0 @@
-/**
- * @fileoverview Rule to check spacing between template tags and their literals
- * @author Jonathan Wilsson
- * @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: "Require or disallow spacing between template tags and their literals",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/template-tag-spacing"
-        },
-
-        fixable: "whitespace",
-
-        schema: [
-            { enum: ["always", "never"] }
-        ],
-        messages: {
-            unexpected: "Unexpected space between template tag and template literal.",
-            missing: "Missing space between template tag and template literal."
-        }
-    },
-
-    create(context) {
-        const never = context.options[0] !== "always";
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Check if a space is present between a template tag and its literal
-         * @param {ASTNode} node node to evaluate
-         * @returns {void}
-         * @private
-         */
-        function checkSpacing(node) {
-            const tagToken = sourceCode.getTokenBefore(node.quasi);
-            const literalToken = sourceCode.getFirstToken(node.quasi);
-            const hasWhitespace = sourceCode.isSpaceBetweenTokens(tagToken, literalToken);
-
-            if (never && hasWhitespace) {
-                context.report({
-                    node,
-                    loc: {
-                        start: tagToken.loc.end,
-                        end: literalToken.loc.start
-                    },
-                    messageId: "unexpected",
-                    fix(fixer) {
-                        const comments = sourceCode.getCommentsBefore(node.quasi);
-
-                        // Don't fix anything if there's a single line comment after the template tag
-                        if (comments.some(comment => comment.type === "Line")) {
-                            return null;
-                        }
-
-                        return fixer.replaceTextRange(
-                            [tagToken.range[1], literalToken.range[0]],
-                            comments.reduce((text, comment) => text + sourceCode.getText(comment), "")
-                        );
-                    }
-                });
-            } else if (!never && !hasWhitespace) {
-                context.report({
-                    node,
-                    loc: {
-                        start: node.loc.start,
-                        end: literalToken.loc.start
-                    },
-                    messageId: "missing",
-                    fix(fixer) {
-                        return fixer.insertTextAfter(tagToken, " ");
-                    }
-                });
-            }
-        }
-
-        return {
-            TaggedTemplateExpression: checkSpacing
-        };
-    }
-};

package/backend/node_modules/eslint/lib/rules/unicode-bom.js

@@ -1,73 +0,0 @@
-/**
- * @fileoverview Require or disallow Unicode BOM
- * @author Andrew Johnston <https://github.com/ehjay>
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "layout",
-
-        docs: {
-            description: "Require or disallow Unicode byte order mark (BOM)",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/unicode-bom"
-        },
-
-        fixable: "whitespace",
-
-        schema: [
-            {
-                enum: ["always", "never"]
-            }
-        ],
-        messages: {
-            expected: "Expected Unicode BOM (Byte Order Mark).",
-            unexpected: "Unexpected Unicode BOM (Byte Order Mark)."
-        }
-    },
-
-    create(context) {
-
-        //--------------------------------------------------------------------------
-        // Public
-        //--------------------------------------------------------------------------
-
-        return {
-
-            Program: function checkUnicodeBOM(node) {
-
-                const sourceCode = context.sourceCode,
-                    location = { column: 0, line: 1 },
-                    requireBOM = context.options[0] || "never";
-
-                if (!sourceCode.hasBOM && (requireBOM === "always")) {
-                    context.report({
-                        node,
-                        loc: location,
-                        messageId: "expected",
-                        fix(fixer) {
-                            return fixer.insertTextBeforeRange([0, 1], "\uFEFF");
-                        }
-                    });
-                } else if (sourceCode.hasBOM && (requireBOM === "never")) {
-                    context.report({
-                        node,
-                        loc: location,
-                        messageId: "unexpected",
-                        fix(fixer) {
-                            return fixer.removeRange([-1, 0]);
-                        }
-                    });
-                }
-            }
-
-        };
-
-    }
-};

package/backend/node_modules/eslint/lib/rules/use-isnan.js

@@ -1,141 +0,0 @@
-/**
- * @fileoverview Rule to flag comparisons to the value NaN
- * @author James Allardice
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Determines if the given node is a NaN `Identifier` node.
- * @param {ASTNode|null} node The node to check.
- * @returns {boolean} `true` if the node is 'NaN' identifier.
- */
-function isNaNIdentifier(node) {
-    return Boolean(node) && (
-        astUtils.isSpecificId(node, "NaN") ||
-        astUtils.isSpecificMemberAccess(node, "Number", "NaN")
-    );
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Require calls to `isNaN()` when checking for `NaN`",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/use-isnan"
-        },
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    enforceForSwitchCase: {
-                        type: "boolean",
-                        default: true
-                    },
-                    enforceForIndexOf: {
-                        type: "boolean",
-                        default: false
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        messages: {
-            comparisonWithNaN: "Use the isNaN function to compare with NaN.",
-            switchNaN: "'switch(NaN)' can never match a case clause. Use Number.isNaN instead of the switch.",
-            caseNaN: "'case NaN' can never match. Use Number.isNaN before the switch.",
-            indexOfNaN: "Array prototype method '{{ methodName }}' cannot find NaN."
-        }
-    },
-
-    create(context) {
-
-        const enforceForSwitchCase = !context.options[0] || context.options[0].enforceForSwitchCase;
-        const enforceForIndexOf = context.options[0] && context.options[0].enforceForIndexOf;
-
-        /**
-         * Checks the given `BinaryExpression` node for `foo === NaN` and other comparisons.
-         * @param {ASTNode} node The node to check.
-         * @returns {void}
-         */
-        function checkBinaryExpression(node) {
-            if (
-                /^(?:[<>]|[!=]=)=?$/u.test(node.operator) &&
-                (isNaNIdentifier(node.left) || isNaNIdentifier(node.right))
-            ) {
-                context.report({ node, messageId: "comparisonWithNaN" });
-            }
-        }
-
-        /**
-         * Checks the discriminant and all case clauses of the given `SwitchStatement` node for `switch(NaN)` and `case NaN:`
-         * @param {ASTNode} node The node to check.
-         * @returns {void}
-         */
-        function checkSwitchStatement(node) {
-            if (isNaNIdentifier(node.discriminant)) {
-                context.report({ node, messageId: "switchNaN" });
-            }
-
-            for (const switchCase of node.cases) {
-                if (isNaNIdentifier(switchCase.test)) {
-                    context.report({ node: switchCase, messageId: "caseNaN" });
-                }
-            }
-        }
-
-        /**
-         * Checks the given `CallExpression` node for `.indexOf(NaN)` and `.lastIndexOf(NaN)`.
-         * @param {ASTNode} node The node to check.
-         * @returns {void}
-         */
-        function checkCallExpression(node) {
-            const callee = astUtils.skipChainExpression(node.callee);
-
-            if (callee.type === "MemberExpression") {
-                const methodName = astUtils.getStaticPropertyName(callee);
-
-                if (
-                    (methodName === "indexOf" || methodName === "lastIndexOf") &&
-                    node.arguments.length === 1 &&
-                    isNaNIdentifier(node.arguments[0])
-                ) {
-                    context.report({ node, messageId: "indexOfNaN", data: { methodName } });
-                }
-            }
-        }
-
-        const listeners = {
-            BinaryExpression: checkBinaryExpression
-        };
-
-        if (enforceForSwitchCase) {
-            listeners.SwitchStatement = checkSwitchStatement;
-        }
-
-        if (enforceForIndexOf) {
-            listeners.CallExpression = checkCallExpression;
-        }
-
-        return listeners;
-    }
-};