repoburg 1.0.31 → 1.0.33

package/backend/node_modules/eslint/lib/rules/no-constructor-return.js

@@ -1,62 +0,0 @@
-/**
- * @fileoverview Rule to disallow returning value from constructor.
- * @author Pig Fang <https://github.com/g-plane>
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Disallow returning value from constructor",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-constructor-return"
-        },
-
-        schema: {},
-
-        fixable: null,
-
-        messages: {
-            unexpected: "Unexpected return statement in constructor."
-        }
-    },
-
-    create(context) {
-        const stack = [];
-
-        return {
-            onCodePathStart(_, node) {
-                stack.push(node);
-            },
-            onCodePathEnd() {
-                stack.pop();
-            },
-            ReturnStatement(node) {
-                const last = stack[stack.length - 1];
-
-                if (!last.parent) {
-                    return;
-                }
-
-                if (
-                    last.parent.type === "MethodDefinition" &&
-                    last.parent.kind === "constructor" &&
-                    (node.parent.parent === last || node.argument)
-                ) {
-                    context.report({
-                        node,
-                        messageId: "unexpected"
-                    });
-                }
-            }
-        };
-    }
-};

package/backend/node_modules/eslint/lib/rules/no-continue.js

@@ -1,39 +0,0 @@
-/**
- * @fileoverview Rule to flag use of continue statement
- * @author Borislav Zhivkov
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow `continue` statements",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-continue"
-        },
-
-        schema: [],
-
-        messages: {
-            unexpected: "Unexpected use of continue statement."
-        }
-    },
-
-    create(context) {
-
-        return {
-            ContinueStatement(node) {
-                context.report({ node, messageId: "unexpected" });
-            }
-        };
-
-    }
-};

package/backend/node_modules/eslint/lib/rules/no-control-regex.js

@@ -1,138 +0,0 @@
-/**
- * @fileoverview Rule to forbid control characters from regular expressions.
- * @author Nicholas C. Zakas
- */
-
-"use strict";
-
-const RegExpValidator = require("@eslint-community/regexpp").RegExpValidator;
-const collector = new (class {
-    constructor() {
-        this._source = "";
-        this._controlChars = [];
-        this._validator = new RegExpValidator(this);
-    }
-
-    onPatternEnter() {
-
-        /*
-         * `RegExpValidator` may parse the pattern twice in one `validatePattern`.
-         * So `this._controlChars` should be cleared here as well.
-         *
-         * For example, the `/(?<a>\x1f)/` regex will parse the pattern twice.
-         * This is based on the content described in Annex B.
-         * If the regex contains a `GroupName` and the `u` flag is not used, `ParseText` will be called twice.
-         * See https://tc39.es/ecma262/2023/multipage/additional-ecmascript-features-for-web-browsers.html#sec-parsepattern-annexb
-         */
-        this._controlChars = [];
-    }
-
-    onCharacter(start, end, cp) {
-        if (cp >= 0x00 &&
-            cp <= 0x1F &&
-            (
-                this._source.codePointAt(start) === cp ||
-                this._source.slice(start, end).startsWith("\\x") ||
-                this._source.slice(start, end).startsWith("\\u")
-            )
-        ) {
-            this._controlChars.push(`\\x${`0${cp.toString(16)}`.slice(-2)}`);
-        }
-    }
-
-    collectControlChars(regexpStr, flags) {
-        const uFlag = typeof flags === "string" && flags.includes("u");
-        const vFlag = typeof flags === "string" && flags.includes("v");
-
-        this._controlChars = [];
-        this._source = regexpStr;
-
-        try {
-            this._validator.validatePattern(regexpStr, void 0, void 0, { unicode: uFlag, unicodeSets: vFlag }); // Call onCharacter hook
-        } catch {
-
-            // Ignore syntax errors in RegExp.
-        }
-        return this._controlChars;
-    }
-})();
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Disallow control characters in regular expressions",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-control-regex"
-        },
-
-        schema: [],
-
-        messages: {
-            unexpected: "Unexpected control character(s) in regular expression: {{controlChars}}."
-        }
-    },
-
-    create(context) {
-
-        /**
-         * Get the regex expression
-         * @param {ASTNode} node `Literal` node to evaluate
-         * @returns {{ pattern: string, flags: string | null } | null} Regex if found (the given node is either a regex literal
-         * or a string literal that is the pattern argument of a RegExp constructor call). Otherwise `null`. If flags cannot be determined,
-         * the `flags` property will be `null`.
-         * @private
-         */
-        function getRegExp(node) {
-            if (node.regex) {
-                return node.regex;
-            }
-            if (typeof node.value === "string" &&
-                (node.parent.type === "NewExpression" || node.parent.type === "CallExpression") &&
-                node.parent.callee.type === "Identifier" &&
-                node.parent.callee.name === "RegExp" &&
-                node.parent.arguments[0] === node
-            ) {
-                const pattern = node.value;
-                const flags =
-                    node.parent.arguments.length > 1 &&
-                    node.parent.arguments[1].type === "Literal" &&
-                    typeof node.parent.arguments[1].value === "string"
-                        ? node.parent.arguments[1].value
-                        : null;
-
-                return { pattern, flags };
-            }
-
-            return null;
-        }
-
-        return {
-            Literal(node) {
-                const regExp = getRegExp(node);
-
-                if (regExp) {
-                    const { pattern, flags } = regExp;
-                    const controlCharacters = collector.collectControlChars(pattern, flags);
-
-                    if (controlCharacters.length > 0) {
-                        context.report({
-                            node,
-                            messageId: "unexpected",
-                            data: {
-                                controlChars: controlCharacters.join(", ")
-                            }
-                        });
-                    }
-                }
-            }
-        };
-
-    }
-};

package/backend/node_modules/eslint/lib/rules/no-debugger.js

@@ -1,43 +0,0 @@
-/**
- * @fileoverview Rule to flag use of a debugger statement
- * @author Nicholas C. Zakas
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Disallow the use of `debugger`",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-debugger"
-        },
-
-        fixable: null,
-        schema: [],
-
-        messages: {
-            unexpected: "Unexpected 'debugger' statement."
-        }
-    },
-
-    create(context) {
-
-        return {
-            DebuggerStatement(node) {
-                context.report({
-                    node,
-                    messageId: "unexpected"
-                });
-            }
-        };
-
-    }
-};

package/backend/node_modules/eslint/lib/rules/no-delete-var.js

@@ -1,42 +0,0 @@
-/**
- * @fileoverview Rule to flag when deleting variables
- * @author Ilya Volodin
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow deleting variables",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-delete-var"
-        },
-
-        schema: [],
-
-        messages: {
-            unexpected: "Variables should not be deleted."
-        }
-    },
-
-    create(context) {
-
-        return {
-
-            UnaryExpression(node) {
-                if (node.operator === "delete" && node.argument.type === "Identifier") {
-                    context.report({ node, messageId: "unexpected" });
-                }
-            }
-        };
-
-    }
-};

package/backend/node_modules/eslint/lib/rules/no-div-regex.js

@@ -1,53 +0,0 @@
-/**
- * @fileoverview Rule to check for ambiguous div operator in regexes
- * @author Matt DuVall <http://www.mattduvall.com>
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow equal signs explicitly at the beginning of regular expressions",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-div-regex"
-        },
-
-        fixable: "code",
-
-        schema: [],
-
-        messages: {
-            unexpected: "A regular expression literal can be confused with '/='."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        return {
-
-            Literal(node) {
-                const token = sourceCode.getFirstToken(node);
-
-                if (token.type === "RegularExpression" && token.value[1] === "=") {
-                    context.report({
-                        node,
-                        messageId: "unexpected",
-                        fix(fixer) {
-                            return fixer.replaceTextRange([token.range[0] + 1, token.range[0] + 2], "[=]");
-                        }
-                    });
-                }
-            }
-        };
-
-    }
-};

package/backend/node_modules/eslint/lib/rules/no-dupe-args.js

@@ -1,82 +0,0 @@
-/**
- * @fileoverview Rule to flag duplicate arguments
- * @author Jamund Ferguson
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Disallow duplicate arguments in `function` definitions",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-dupe-args"
-        },
-
-        schema: [],
-
-        messages: {
-            unexpected: "Duplicate param '{{name}}'."
-        }
-    },
-
-    create(context) {
-
-        const sourceCode = context.sourceCode;
-
-        //--------------------------------------------------------------------------
-        // Helpers
-        //--------------------------------------------------------------------------
-
-        /**
-         * Checks whether or not a given definition is a parameter's.
-         * @param {eslint-scope.DefEntry} def A definition to check.
-         * @returns {boolean} `true` if the definition is a parameter's.
-         */
-        function isParameter(def) {
-            return def.type === "Parameter";
-        }
-
-        /**
-         * Determines if a given node has duplicate parameters.
-         * @param {ASTNode} node The node to check.
-         * @returns {void}
-         * @private
-         */
-        function checkParams(node) {
-            const variables = sourceCode.getDeclaredVariables(node);
-
-            for (let i = 0; i < variables.length; ++i) {
-                const variable = variables[i];
-
-                // Checks and reports duplications.
-                const defs = variable.defs.filter(isParameter);
-
-                if (defs.length >= 2) {
-                    context.report({
-                        node,
-                        messageId: "unexpected",
-                        data: { name: variable.name }
-                    });
-                }
-            }
-        }
-
-        //--------------------------------------------------------------------------
-        // Public API
-        //--------------------------------------------------------------------------
-
-        return {
-            FunctionDeclaration: checkParams,
-            FunctionExpression: checkParams
-        };
-
-    }
-};

package/backend/node_modules/eslint/lib/rules/no-dupe-class-members.js

@@ -1,104 +0,0 @@
-/**
- * @fileoverview A rule to disallow duplicate name in class members.
- * @author Toru Nagashima
- */
-
-"use strict";
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Disallow duplicate class members",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-dupe-class-members"
-        },
-
-        schema: [],
-
-        messages: {
-            unexpected: "Duplicate name '{{name}}'."
-        }
-    },
-
-    create(context) {
-        let stack = [];
-
-        /**
-         * Gets state of a given member name.
-         * @param {string} name A name of a member.
-         * @param {boolean} isStatic A flag which specifies that is a static member.
-         * @returns {Object} A state of a given member name.
-         *   - retv.init {boolean} A flag which shows the name is declared as normal member.
-         *   - retv.get {boolean} A flag which shows the name is declared as getter.
-         *   - retv.set {boolean} A flag which shows the name is declared as setter.
-         */
-        function getState(name, isStatic) {
-            const stateMap = stack[stack.length - 1];
-            const key = `$${name}`; // to avoid "__proto__".
-
-            if (!stateMap[key]) {
-                stateMap[key] = {
-                    nonStatic: { init: false, get: false, set: false },
-                    static: { init: false, get: false, set: false }
-                };
-            }
-
-            return stateMap[key][isStatic ? "static" : "nonStatic"];
-        }
-
-        return {
-
-            // Initializes the stack of state of member declarations.
-            Program() {
-                stack = [];
-            },
-
-            // Initializes state of member declarations for the class.
-            ClassBody() {
-                stack.push(Object.create(null));
-            },
-
-            // Disposes the state for the class.
-            "ClassBody:exit"() {
-                stack.pop();
-            },
-
-            // Reports the node if its name has been declared already.
-            "MethodDefinition, PropertyDefinition"(node) {
-                const name = astUtils.getStaticPropertyName(node);
-                const kind = node.type === "MethodDefinition" ? node.kind : "field";
-
-                if (name === null || kind === "constructor") {
-                    return;
-                }
-
-                const state = getState(name, node.static);
-                let isDuplicate = false;
-
-                if (kind === "get") {
-                    isDuplicate = (state.init || state.get);
-                    state.get = true;
-                } else if (kind === "set") {
-                    isDuplicate = (state.init || state.set);
-                    state.set = true;
-                } else {
-                    isDuplicate = (state.init || state.get || state.set);
-                    state.init = true;
-                }
-
-                if (isDuplicate) {
-                    context.report({ node, messageId: "unexpected", data: { name } });
-                }
-            }
-        };
-    }
-};

package/backend/node_modules/eslint/lib/rules/no-dupe-else-if.js

@@ -1,122 +0,0 @@
-/**
- * @fileoverview Rule to disallow duplicate conditions in if-else-if chains
- * @author Milos Djermanovic
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Determines whether the first given array is a subset of the second given array.
- * @param {Function} comparator A function to compare two elements, should return `true` if they are equal.
- * @param {Array} arrA The array to compare from.
- * @param {Array} arrB The array to compare against.
- * @returns {boolean} `true` if the array `arrA` is a subset of the array `arrB`.
- */
-function isSubsetByComparator(comparator, arrA, arrB) {
-    return arrA.every(a => arrB.some(b => comparator(a, b)));
-}
-
-/**
- * Splits the given node by the given logical operator.
- * @param {string} operator Logical operator `||` or `&&`.
- * @param {ASTNode} node The node to split.
- * @returns {ASTNode[]} Array of conditions that makes the node when joined by the operator.
- */
-function splitByLogicalOperator(operator, node) {
-    if (node.type === "LogicalExpression" && node.operator === operator) {
-        return [...splitByLogicalOperator(operator, node.left), ...splitByLogicalOperator(operator, node.right)];
-    }
-    return [node];
-}
-
-const splitByOr = splitByLogicalOperator.bind(null, "||");
-const splitByAnd = splitByLogicalOperator.bind(null, "&&");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Disallow duplicate conditions in if-else-if chains",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-dupe-else-if"
-        },
-
-        schema: [],
-
-        messages: {
-            unexpected: "This branch can never execute. Its condition is a duplicate or covered by previous conditions in the if-else-if chain."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Determines whether the two given nodes are considered to be equal. In particular, given that the nodes
-         * represent expressions in a boolean context, `||` and `&&` can be considered as commutative operators.
-         * @param {ASTNode} a First node.
-         * @param {ASTNode} b Second node.
-         * @returns {boolean} `true` if the nodes are considered to be equal.
-         */
-        function equal(a, b) {
-            if (a.type !== b.type) {
-                return false;
-            }
-
-            if (
-                a.type === "LogicalExpression" &&
-                (a.operator === "||" || a.operator === "&&") &&
-                a.operator === b.operator
-            ) {
-                return equal(a.left, b.left) && equal(a.right, b.right) ||
-                    equal(a.left, b.right) && equal(a.right, b.left);
-            }
-
-            return astUtils.equalTokens(a, b, sourceCode);
-        }
-
-        const isSubset = isSubsetByComparator.bind(null, equal);
-
-        return {
-            IfStatement(node) {
-                const test = node.test,
-                    conditionsToCheck = test.type === "LogicalExpression" && test.operator === "&&"
-                        ? [test, ...splitByAnd(test)]
-                        : [test];
-                let current = node,
-                    listToCheck = conditionsToCheck.map(c => splitByOr(c).map(splitByAnd));
-
-                while (current.parent && current.parent.type === "IfStatement" && current.parent.alternate === current) {
-                    current = current.parent;
-
-                    const currentOrOperands = splitByOr(current.test).map(splitByAnd);
-
-                    listToCheck = listToCheck.map(orOperands => orOperands.filter(
-                        orOperand => !currentOrOperands.some(currentOrOperand => isSubset(currentOrOperand, orOperand))
-                    ));
-
-                    if (listToCheck.some(orOperands => orOperands.length === 0)) {
-                        context.report({ node: test, messageId: "unexpected" });
-                        break;
-                    }
-                }
-            }
-        };
-    }
-};