claude-flow-novice 2.2.0 → 2.2.1

package/dist/src/web/frontend/node_modules/.eslint-60wj8XRy/lib/rules/no-use-before-define.js

@@ -1,348 +0,0 @@
-/**
- * @fileoverview Rule to flag use of variables before they are defined
- * @author Ilya Volodin
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const SENTINEL_TYPE = /^(?:(?:Function|Class)(?:Declaration|Expression)|ArrowFunctionExpression|CatchClause|ImportDeclaration|ExportNamedDeclaration)$/u;
-const FOR_IN_OF_TYPE = /^For(?:In|Of)Statement$/u;
-
-/**
- * Parses a given value as options.
- * @param {any} options A value to parse.
- * @returns {Object} The parsed options.
- */
-function parseOptions(options) {
-    let functions = true;
-    let classes = true;
-    let variables = true;
-    let allowNamedExports = false;
-
-    if (typeof options === "string") {
-        functions = (options !== "nofunc");
-    } else if (typeof options === "object" && options !== null) {
-        functions = options.functions !== false;
-        classes = options.classes !== false;
-        variables = options.variables !== false;
-        allowNamedExports = !!options.allowNamedExports;
-    }
-
-    return { functions, classes, variables, allowNamedExports };
-}
-
-/**
- * Checks whether or not a given location is inside of the range of a given node.
- * @param {ASTNode} node An node to check.
- * @param {number} location A location to check.
- * @returns {boolean} `true` if the location is inside of the range of the node.
- */
-function isInRange(node, location) {
-    return node && node.range[0] <= location && location <= node.range[1];
-}
-
-/**
- * Checks whether or not a given location is inside of the range of a class static initializer.
- * Static initializers are static blocks and initializers of static fields.
- * @param {ASTNode} node `ClassBody` node to check static initializers.
- * @param {number} location A location to check.
- * @returns {boolean} `true` if the location is inside of a class static initializer.
- */
-function isInClassStaticInitializerRange(node, location) {
-    return node.body.some(classMember => (
-        (
-            classMember.type === "StaticBlock" &&
-            isInRange(classMember, location)
-        ) ||
-        (
-            classMember.type === "PropertyDefinition" &&
-            classMember.static &&
-            classMember.value &&
-            isInRange(classMember.value, location)
-        )
-    ));
-}
-
-/**
- * Checks whether a given scope is the scope of a class static initializer.
- * Static initializers are static blocks and initializers of static fields.
- * @param {eslint-scope.Scope} scope A scope to check.
- * @returns {boolean} `true` if the scope is a class static initializer scope.
- */
-function isClassStaticInitializerScope(scope) {
-    if (scope.type === "class-static-block") {
-        return true;
-    }
-
-    if (scope.type === "class-field-initializer") {
-
-        // `scope.block` is PropertyDefinition#value node
-        const propertyDefinition = scope.block.parent;
-
-        return propertyDefinition.static;
-    }
-
-    return false;
-}
-
-/**
- * Checks whether a given reference is evaluated in an execution context
- * that isn't the one where the variable it refers to is defined.
- * Execution contexts are:
- * - top-level
- * - functions
- * - class field initializers (implicit functions)
- * - class static blocks (implicit functions)
- * Static class field initializers and class static blocks are automatically run during the class definition evaluation,
- * and therefore we'll consider them as a part of the parent execution context.
- * Example:
- *
- *   const x = 1;
- *
- *   x; // returns `false`
- *   () => x; // returns `true`
- *
- *   class C {
- *       field = x; // returns `true`
- *       static field = x; // returns `false`
- *
- *       method() {
- *           x; // returns `true`
- *       }
- *
- *       static method() {
- *           x; // returns `true`
- *       }
- *
- *       static {
- *           x; // returns `false`
- *       }
- *   }
- * @param {eslint-scope.Reference} reference A reference to check.
- * @returns {boolean} `true` if the reference is from a separate execution context.
- */
-function isFromSeparateExecutionContext(reference) {
-    const variable = reference.resolved;
-    let scope = reference.from;
-
-    // Scope#variableScope represents execution context
-    while (variable.scope.variableScope !== scope.variableScope) {
-        if (isClassStaticInitializerScope(scope.variableScope)) {
-            scope = scope.variableScope.upper;
-        } else {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-/**
- * Checks whether or not a given reference is evaluated during the initialization of its variable.
- *
- * This returns `true` in the following cases:
- *
- *     var a = a
- *     var [a = a] = list
- *     var {a = a} = obj
- *     for (var a in a) {}
- *     for (var a of a) {}
- *     var C = class { [C]; };
- *     var C = class { static foo = C; };
- *     var C = class { static { foo = C; } };
- *     class C extends C {}
- *     class C extends (class { static foo = C; }) {}
- *     class C { [C]; }
- * @param {Reference} reference A reference to check.
- * @returns {boolean} `true` if the reference is evaluated during the initialization.
- */
-function isEvaluatedDuringInitialization(reference) {
-    if (isFromSeparateExecutionContext(reference)) {
-
-        /*
-         * Even if the reference appears in the initializer, it isn't evaluated during the initialization.
-         * For example, `const x = () => x;` is valid.
-         */
-        return false;
-    }
-
-    const location = reference.identifier.range[1];
-    const definition = reference.resolved.defs[0];
-
-    if (definition.type === "ClassName") {
-
-        // `ClassDeclaration` or `ClassExpression`
-        const classDefinition = definition.node;
-
-        return (
-            isInRange(classDefinition, location) &&
-
-            /*
-             * Class binding is initialized before running static initializers.
-             * For example, `class C { static foo = C; static { bar = C; } }` is valid.
-             */
-            !isInClassStaticInitializerRange(classDefinition.body, location)
-        );
-    }
-
-    let node = definition.name.parent;
-
-    while (node) {
-        if (node.type === "VariableDeclarator") {
-            if (isInRange(node.init, location)) {
-                return true;
-            }
-            if (FOR_IN_OF_TYPE.test(node.parent.parent.type) &&
-                isInRange(node.parent.parent.right, location)
-            ) {
-                return true;
-            }
-            break;
-        } else if (node.type === "AssignmentPattern") {
-            if (isInRange(node.right, location)) {
-                return true;
-            }
-        } else if (SENTINEL_TYPE.test(node.type)) {
-            break;
-        }
-
-        node = node.parent;
-    }
-
-    return false;
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Disallow the use of variables before they are defined",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-use-before-define"
-        },
-
-        schema: [
-            {
-                oneOf: [
-                    {
-                        enum: ["nofunc"]
-                    },
-                    {
-                        type: "object",
-                        properties: {
-                            functions: { type: "boolean" },
-                            classes: { type: "boolean" },
-                            variables: { type: "boolean" },
-                            allowNamedExports: { type: "boolean" }
-                        },
-                        additionalProperties: false
-                    }
-                ]
-            }
-        ],
-
-        messages: {
-            usedBeforeDefined: "'{{name}}' was used before it was defined."
-        }
-    },
-
-    create(context) {
-        const options = parseOptions(context.options[0]);
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Determines whether a given reference should be checked.
-         *
-         * Returns `false` if the reference is:
-         * - initialization's (e.g., `let a = 1`).
-         * - referring to an undefined variable (i.e., if it's an unresolved reference).
-         * - referring to a variable that is defined, but not in the given source code
-         *   (e.g., global environment variable or `arguments` in functions).
-         * - allowed by options.
-         * @param {eslint-scope.Reference} reference The reference
-         * @returns {boolean} `true` if the reference should be checked
-         */
-        function shouldCheck(reference) {
-            if (reference.init) {
-                return false;
-            }
-
-            const { identifier } = reference;
-
-            if (
-                options.allowNamedExports &&
-                identifier.parent.type === "ExportSpecifier" &&
-                identifier.parent.local === identifier
-            ) {
-                return false;
-            }
-
-            const variable = reference.resolved;
-
-            if (!variable || variable.defs.length === 0) {
-                return false;
-            }
-
-            const definitionType = variable.defs[0].type;
-
-            if (!options.functions && definitionType === "FunctionName") {
-                return false;
-            }
-
-            if (
-                (
-                    !options.variables && definitionType === "Variable" ||
-                    !options.classes && definitionType === "ClassName"
-                ) &&
-
-                // don't skip checking the reference if it's in the same execution context, because of TDZ
-                isFromSeparateExecutionContext(reference)
-            ) {
-                return false;
-            }
-
-            return true;
-        }
-
-        /**
-         * Finds and validates all references in a given scope and its child scopes.
-         * @param {eslint-scope.Scope} scope The scope object.
-         * @returns {void}
-         */
-        function checkReferencesInScope(scope) {
-            scope.references.filter(shouldCheck).forEach(reference => {
-                const variable = reference.resolved;
-                const definitionIdentifier = variable.defs[0].name;
-
-                if (
-                    reference.identifier.range[1] < definitionIdentifier.range[1] ||
-                    isEvaluatedDuringInitialization(reference)
-                ) {
-                    context.report({
-                        node: reference.identifier,
-                        messageId: "usedBeforeDefined",
-                        data: reference.identifier
-                    });
-                }
-            });
-
-            scope.childScopes.forEach(checkReferencesInScope);
-        }
-
-        return {
-            Program(node) {
-                checkReferencesInScope(sourceCode.getScope(node));
-            }
-        };
-    }
-};

package/dist/src/web/frontend/node_modules/.eslint-60wj8XRy/lib/rules/no-useless-backreference.js

@@ -1,194 +0,0 @@
-/**
- * @fileoverview Rule to disallow useless backreferences in regular expressions
- * @author Milos Djermanovic
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const { CALL, CONSTRUCT, ReferenceTracker, getStringIfConstant } = require("@eslint-community/eslint-utils");
-const { RegExpParser, visitRegExpAST } = require("@eslint-community/regexpp");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const parser = new RegExpParser();
-
-/**
- * Finds the path from the given `regexpp` AST node to the root node.
- * @param {regexpp.Node} node Node.
- * @returns {regexpp.Node[]} Array that starts with the given node and ends with the root node.
- */
-function getPathToRoot(node) {
-    const path = [];
-    let current = node;
-
-    do {
-        path.push(current);
-        current = current.parent;
-    } while (current);
-
-    return path;
-}
-
-/**
- * Determines whether the given `regexpp` AST node is a lookaround node.
- * @param {regexpp.Node} node Node.
- * @returns {boolean} `true` if it is a lookaround node.
- */
-function isLookaround(node) {
-    return node.type === "Assertion" &&
-        (node.kind === "lookahead" || node.kind === "lookbehind");
-}
-
-/**
- * Determines whether the given `regexpp` AST node is a negative lookaround node.
- * @param {regexpp.Node} node Node.
- * @returns {boolean} `true` if it is a negative lookaround node.
- */
-function isNegativeLookaround(node) {
-    return isLookaround(node) && node.negate;
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Disallow useless backreferences in regular expressions",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-useless-backreference"
-        },
-
-        schema: [],
-
-        messages: {
-            nested: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}' from within that group.",
-            forward: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}' which appears later in the pattern.",
-            backward: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}' which appears before in the same lookbehind.",
-            disjunctive: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}' which is in another alternative.",
-            intoNegativeLookaround: "Backreference '{{ bref }}' will be ignored. It references group '{{ group }}' which is in a negative lookaround."
-        }
-    },
-
-    create(context) {
-
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Checks and reports useless backreferences in the given regular expression.
-         * @param {ASTNode} node Node that represents regular expression. A regex literal or RegExp constructor call.
-         * @param {string} pattern Regular expression pattern.
-         * @param {string} flags Regular expression flags.
-         * @returns {void}
-         */
-        function checkRegex(node, pattern, flags) {
-            let regExpAST;
-
-            try {
-                regExpAST = parser.parsePattern(pattern, 0, pattern.length, { unicode: flags.includes("u"), unicodeSets: flags.includes("v") });
-            } catch {
-
-                // Ignore regular expressions with syntax errors
-                return;
-            }
-
-            visitRegExpAST(regExpAST, {
-                onBackreferenceEnter(bref) {
-                    const group = bref.resolved,
-                        brefPath = getPathToRoot(bref),
-                        groupPath = getPathToRoot(group);
-                    let messageId = null;
-
-                    if (brefPath.includes(group)) {
-
-                        // group is bref's ancestor => bref is nested ('nested reference') => group hasn't matched yet when bref starts to match.
-                        messageId = "nested";
-                    } else {
-
-                        // Start from the root to find the lowest common ancestor.
-                        let i = brefPath.length - 1,
-                            j = groupPath.length - 1;
-
-                        do {
-                            i--;
-                            j--;
-                        } while (brefPath[i] === groupPath[j]);
-
-                        const indexOfLowestCommonAncestor = j + 1,
-                            groupCut = groupPath.slice(0, indexOfLowestCommonAncestor),
-                            commonPath = groupPath.slice(indexOfLowestCommonAncestor),
-                            lowestCommonLookaround = commonPath.find(isLookaround),
-                            isMatchingBackward = lowestCommonLookaround && lowestCommonLookaround.kind === "lookbehind";
-
-                        if (!isMatchingBackward && bref.end <= group.start) {
-
-                            // bref is left, group is right ('forward reference') => group hasn't matched yet when bref starts to match.
-                            messageId = "forward";
-                        } else if (isMatchingBackward && group.end <= bref.start) {
-
-                            // the opposite of the previous when the regex is matching backward in a lookbehind context.
-                            messageId = "backward";
-                        } else if (groupCut[groupCut.length - 1].type === "Alternative") {
-
-                            // group's and bref's ancestor nodes below the lowest common ancestor are sibling alternatives => they're disjunctive.
-                            messageId = "disjunctive";
-                        } else if (groupCut.some(isNegativeLookaround)) {
-
-                            // group is in a negative lookaround which isn't bref's ancestor => group has already failed when bref starts to match.
-                            messageId = "intoNegativeLookaround";
-                        }
-                    }
-
-                    if (messageId) {
-                        context.report({
-                            node,
-                            messageId,
-                            data: {
-                                bref: bref.raw,
-                                group: group.raw
-                            }
-                        });
-                    }
-                }
-            });
-        }
-
-        return {
-            "Literal[regex]"(node) {
-                const { pattern, flags } = node.regex;
-
-                checkRegex(node, pattern, flags);
-            },
-            Program(node) {
-                const scope = sourceCode.getScope(node),
-                    tracker = new ReferenceTracker(scope),
-                    traceMap = {
-                        RegExp: {
-                            [CALL]: true,
-                            [CONSTRUCT]: true
-                        }
-                    };
-
-                for (const { node: refNode } of tracker.iterateGlobalReferences(traceMap)) {
-                    const [patternNode, flagsNode] = refNode.arguments,
-                        pattern = getStringIfConstant(patternNode, scope),
-                        flags = getStringIfConstant(flagsNode, scope);
-
-                    if (typeof pattern === "string") {
-                        checkRegex(refNode, pattern, flags || "");
-                    }
-                }
-            }
-        };
-    }
-};

package/dist/src/web/frontend/node_modules/.eslint-60wj8XRy/lib/rules/no-useless-call.js

@@ -1,90 +0,0 @@
-/**
- * @fileoverview A rule to disallow unnecessary `.call()` and `.apply()`.
- * @author Toru Nagashima
- */
-
-"use strict";
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Checks whether or not a node is a `.call()`/`.apply()`.
- * @param {ASTNode} node A CallExpression node to check.
- * @returns {boolean} Whether or not the node is a `.call()`/`.apply()`.
- */
-function isCallOrNonVariadicApply(node) {
-    const callee = astUtils.skipChainExpression(node.callee);
-
-    return (
-        callee.type === "MemberExpression" &&
-        callee.property.type === "Identifier" &&
-        callee.computed === false &&
-        (
-            (callee.property.name === "call" && node.arguments.length >= 1) ||
-            (callee.property.name === "apply" && node.arguments.length === 2 && node.arguments[1].type === "ArrayExpression")
-        )
-    );
-}
-
-
-/**
- * Checks whether or not `thisArg` is not changed by `.call()`/`.apply()`.
- * @param {ASTNode|null} expectedThis The node that is the owner of the applied function.
- * @param {ASTNode} thisArg The node that is given to the first argument of the `.call()`/`.apply()`.
- * @param {SourceCode} sourceCode The ESLint source code object.
- * @returns {boolean} Whether or not `thisArg` is not changed by `.call()`/`.apply()`.
- */
-function isValidThisArg(expectedThis, thisArg, sourceCode) {
-    if (!expectedThis) {
-        return astUtils.isNullOrUndefined(thisArg);
-    }
-    return astUtils.equalTokens(expectedThis, thisArg, sourceCode);
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow unnecessary calls to `.call()` and `.apply()`",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-useless-call"
-        },
-
-        schema: [],
-
-        messages: {
-            unnecessaryCall: "Unnecessary '.{{name}}()'."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        return {
-            CallExpression(node) {
-                if (!isCallOrNonVariadicApply(node)) {
-                    return;
-                }
-
-                const callee = astUtils.skipChainExpression(node.callee);
-                const applied = astUtils.skipChainExpression(callee.object);
-                const expectedThis = (applied.type === "MemberExpression") ? applied.object : null;
-                const thisArg = node.arguments[0];
-
-                if (isValidThisArg(expectedThis, thisArg, sourceCode)) {
-                    context.report({ node, messageId: "unnecessaryCall", data: { name: callee.property.name } });
-                }
-            }
-        };
-    }
-};

package/dist/src/web/frontend/node_modules/.eslint-60wj8XRy/lib/rules/no-useless-catch.js

@@ -1,57 +0,0 @@
-/**
- * @fileoverview Reports useless `catch` clauses that just rethrow their error.
- * @author Teddy Katz
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow unnecessary `catch` clauses",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-useless-catch"
-        },
-
-        schema: [],
-
-        messages: {
-            unnecessaryCatchClause: "Unnecessary catch clause.",
-            unnecessaryCatch: "Unnecessary try/catch wrapper."
-        }
-    },
-
-    create(context) {
-        return {
-            CatchClause(node) {
-                if (
-                    node.param &&
-                    node.param.type === "Identifier" &&
-                    node.body.body.length &&
-                    node.body.body[0].type === "ThrowStatement" &&
-                    node.body.body[0].argument.type === "Identifier" &&
-                    node.body.body[0].argument.name === node.param.name
-                ) {
-                    if (node.parent.finalizer) {
-                        context.report({
-                            node,
-                            messageId: "unnecessaryCatchClause"
-                        });
-                    } else {
-                        context.report({
-                            node: node.parent,
-                            messageId: "unnecessaryCatch"
-                        });
-                    }
-                }
-            }
-        };
-    }
-};