claude-flow-novice 2.2.0 → 2.2.1

package/dist/src/web/frontend/node_modules/.eslint-60wj8XRy/lib/rules/newline-before-return.js

@@ -1,217 +0,0 @@
-/**
- * @fileoverview Rule to require newlines before `return` statement
- * @author Kai Cataldo
- * @deprecated in ESLint v4.0.0
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "layout",
-
-        docs: {
-            description: "Require an empty line before `return` statements",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/newline-before-return"
-        },
-
-        fixable: "whitespace",
-        schema: [],
-        messages: {
-            expected: "Expected newline before return statement."
-        },
-
-        deprecated: true,
-        replacedBy: ["padding-line-between-statements"]
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        //--------------------------------------------------------------------------
-        // Helpers
-        //--------------------------------------------------------------------------
-
-        /**
-         * Tests whether node is preceded by supplied tokens
-         * @param {ASTNode} node node to check
-         * @param {Array} testTokens array of tokens to test against
-         * @returns {boolean} Whether or not the node is preceded by one of the supplied tokens
-         * @private
-         */
-        function isPrecededByTokens(node, testTokens) {
-            const tokenBefore = sourceCode.getTokenBefore(node);
-
-            return testTokens.includes(tokenBefore.value);
-        }
-
-        /**
-         * Checks whether node is the first node after statement or in block
-         * @param {ASTNode} node node to check
-         * @returns {boolean} Whether or not the node is the first node after statement or in block
-         * @private
-         */
-        function isFirstNode(node) {
-            const parentType = node.parent.type;
-
-            if (node.parent.body) {
-                return Array.isArray(node.parent.body)
-                    ? node.parent.body[0] === node
-                    : node.parent.body === node;
-            }
-
-            if (parentType === "IfStatement") {
-                return isPrecededByTokens(node, ["else", ")"]);
-            }
-            if (parentType === "DoWhileStatement") {
-                return isPrecededByTokens(node, ["do"]);
-            }
-            if (parentType === "SwitchCase") {
-                return isPrecededByTokens(node, [":"]);
-            }
-            return isPrecededByTokens(node, [")"]);
-
-        }
-
-        /**
-         * Returns the number of lines of comments that precede the node
-         * @param {ASTNode} node node to check for overlapping comments
-         * @param {number} lineNumTokenBefore line number of previous token, to check for overlapping comments
-         * @returns {number} Number of lines of comments that precede the node
-         * @private
-         */
-        function calcCommentLines(node, lineNumTokenBefore) {
-            const comments = sourceCode.getCommentsBefore(node);
-            let numLinesComments = 0;
-
-            if (!comments.length) {
-                return numLinesComments;
-            }
-
-            comments.forEach(comment => {
-                numLinesComments++;
-
-                if (comment.type === "Block") {
-                    numLinesComments += comment.loc.end.line - comment.loc.start.line;
-                }
-
-                // avoid counting lines with inline comments twice
-                if (comment.loc.start.line === lineNumTokenBefore) {
-                    numLinesComments--;
-                }
-
-                if (comment.loc.end.line === node.loc.start.line) {
-                    numLinesComments--;
-                }
-            });
-
-            return numLinesComments;
-        }
-
-        /**
-         * Returns the line number of the token before the node that is passed in as an argument
-         * @param {ASTNode} node The node to use as the start of the calculation
-         * @returns {number} Line number of the token before `node`
-         * @private
-         */
-        function getLineNumberOfTokenBefore(node) {
-            const tokenBefore = sourceCode.getTokenBefore(node);
-            let lineNumTokenBefore;
-
-            /**
-             * Global return (at the beginning of a script) is a special case.
-             * If there is no token before `return`, then we expect no line
-             * break before the return. Comments are allowed to occupy lines
-             * before the global return, just no blank lines.
-             * Setting lineNumTokenBefore to zero in that case results in the
-             * desired behavior.
-             */
-            if (tokenBefore) {
-                lineNumTokenBefore = tokenBefore.loc.end.line;
-            } else {
-                lineNumTokenBefore = 0; // global return at beginning of script
-            }
-
-            return lineNumTokenBefore;
-        }
-
-        /**
-         * Checks whether node is preceded by a newline
-         * @param {ASTNode} node node to check
-         * @returns {boolean} Whether or not the node is preceded by a newline
-         * @private
-         */
-        function hasNewlineBefore(node) {
-            const lineNumNode = node.loc.start.line;
-            const lineNumTokenBefore = getLineNumberOfTokenBefore(node);
-            const commentLines = calcCommentLines(node, lineNumTokenBefore);
-
-            return (lineNumNode - lineNumTokenBefore - commentLines) > 1;
-        }
-
-        /**
-         * Checks whether it is safe to apply a fix to a given return statement.
-         *
-         * The fix is not considered safe if the given return statement has leading comments,
-         * as we cannot safely determine if the newline should be added before or after the comments.
-         * For more information, see: https://github.com/eslint/eslint/issues/5958#issuecomment-222767211
-         * @param {ASTNode} node The return statement node to check.
-         * @returns {boolean} `true` if it can fix the node.
-         * @private
-         */
-        function canFix(node) {
-            const leadingComments = sourceCode.getCommentsBefore(node);
-            const lastLeadingComment = leadingComments[leadingComments.length - 1];
-            const tokenBefore = sourceCode.getTokenBefore(node);
-
-            if (leadingComments.length === 0) {
-                return true;
-            }
-
-            /*
-             * if the last leading comment ends in the same line as the previous token and
-             * does not share a line with the `return` node, we can consider it safe to fix.
-             * Example:
-             * function a() {
-             *     var b; //comment
-             *     return;
-             * }
-             */
-            if (lastLeadingComment.loc.end.line === tokenBefore.loc.end.line &&
-                lastLeadingComment.loc.end.line !== node.loc.start.line) {
-                return true;
-            }
-
-            return false;
-        }
-
-        //--------------------------------------------------------------------------
-        // Public
-        //--------------------------------------------------------------------------
-
-        return {
-            ReturnStatement(node) {
-                if (!isFirstNode(node) && !hasNewlineBefore(node)) {
-                    context.report({
-                        node,
-                        messageId: "expected",
-                        fix(fixer) {
-                            if (canFix(node)) {
-                                const tokenBefore = sourceCode.getTokenBefore(node);
-                                const newlines = node.loc.start.line === tokenBefore.loc.end.line ? "\n\n" : "\n";
-
-                                return fixer.insertTextBefore(node, newlines);
-                            }
-                            return null;
-                        }
-                    });
-                }
-            }
-        };
-    }
-};

package/dist/src/web/frontend/node_modules/.eslint-60wj8XRy/lib/rules/newline-per-chained-call.js

@@ -1,126 +0,0 @@
-/**
- * @fileoverview Rule to ensure newline per method call when chaining calls
- * @author Rajendra Patil
- * @author Burak Yigit Kaya
- * @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: "Require a newline after each call in a method chain",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/newline-per-chained-call"
-        },
-
-        fixable: "whitespace",
-
-        schema: [{
-            type: "object",
-            properties: {
-                ignoreChainWithDepth: {
-                    type: "integer",
-                    minimum: 1,
-                    maximum: 10,
-                    default: 2
-                }
-            },
-            additionalProperties: false
-        }],
-        messages: {
-            expected: "Expected line break before `{{callee}}`."
-        }
-    },
-
-    create(context) {
-
-        const options = context.options[0] || {},
-            ignoreChainWithDepth = options.ignoreChainWithDepth || 2;
-
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Get the prefix of a given MemberExpression node.
-         * If the MemberExpression node is a computed value it returns a
-         * left bracket. If not it returns a period.
-         * @param {ASTNode} node A MemberExpression node to get
-         * @returns {string} The prefix of the node.
-         */
-        function getPrefix(node) {
-            if (node.computed) {
-                if (node.optional) {
-                    return "?.[";
-                }
-                return "[";
-            }
-            if (node.optional) {
-                return "?.";
-            }
-            return ".";
-        }
-
-        /**
-         * Gets the property text of a given MemberExpression node.
-         * If the text is multiline, this returns only the first line.
-         * @param {ASTNode} node A MemberExpression node to get.
-         * @returns {string} The property text of the node.
-         */
-        function getPropertyText(node) {
-            const prefix = getPrefix(node);
-            const lines = sourceCode.getText(node.property).split(astUtils.LINEBREAK_MATCHER);
-            const suffix = node.computed && lines.length === 1 ? "]" : "";
-
-            return prefix + lines[0] + suffix;
-        }
-
-        return {
-            "CallExpression:exit"(node) {
-                const callee = astUtils.skipChainExpression(node.callee);
-
-                if (callee.type !== "MemberExpression") {
-                    return;
-                }
-
-                let parent = astUtils.skipChainExpression(callee.object);
-                let depth = 1;
-
-                while (parent && parent.callee) {
-                    depth += 1;
-                    parent = astUtils.skipChainExpression(astUtils.skipChainExpression(parent.callee).object);
-                }
-
-                if (depth > ignoreChainWithDepth && astUtils.isTokenOnSameLine(callee.object, callee.property)) {
-                    const firstTokenAfterObject = sourceCode.getTokenAfter(callee.object, astUtils.isNotClosingParenToken);
-
-                    context.report({
-                        node: callee.property,
-                        loc: {
-                            start: firstTokenAfterObject.loc.start,
-                            end: callee.loc.end
-                        },
-                        messageId: "expected",
-                        data: {
-                            callee: getPropertyText(callee)
-                        },
-                        fix(fixer) {
-                            return fixer.insertTextBefore(firstTokenAfterObject, "\n");
-                        }
-                    });
-                }
-            }
-        };
-    }
-};

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

@@ -1,138 +0,0 @@
-/**
- * @fileoverview Rule to flag use of alert, confirm, prompt
- * @author Nicholas C. Zakas
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const {
-    getStaticPropertyName: getPropertyName,
-    getVariableByName,
-    skipChainExpression
-} = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Checks if the given name is a prohibited identifier.
- * @param {string} name The name to check
- * @returns {boolean} Whether or not the name is prohibited.
- */
-function isProhibitedIdentifier(name) {
-    return /^(alert|confirm|prompt)$/u.test(name);
-}
-
-/**
- * Finds the eslint-scope reference in the given scope.
- * @param {Object} scope The scope to search.
- * @param {ASTNode} node The identifier node.
- * @returns {Reference|null} Returns the found reference or null if none were found.
- */
-function findReference(scope, node) {
-    const references = scope.references.filter(reference => reference.identifier.range[0] === node.range[0] &&
-            reference.identifier.range[1] === node.range[1]);
-
-    if (references.length === 1) {
-        return references[0];
-    }
-    return null;
-}
-
-/**
- * Checks if the given identifier node is shadowed in the given scope.
- * @param {Object} scope The current scope.
- * @param {string} node The identifier node to check
- * @returns {boolean} Whether or not the name is shadowed.
- */
-function isShadowed(scope, node) {
-    const reference = findReference(scope, node);
-
-    return reference && reference.resolved && reference.resolved.defs.length > 0;
-}
-
-/**
- * Checks if the given identifier node is a ThisExpression in the global scope or the global window property.
- * @param {Object} scope The current scope.
- * @param {string} node The identifier node to check
- * @returns {boolean} Whether or not the node is a reference to the global object.
- */
-function isGlobalThisReferenceOrGlobalWindow(scope, node) {
-    if (scope.type === "global" && node.type === "ThisExpression") {
-        return true;
-    }
-    if (
-        node.type === "Identifier" &&
-        (
-            node.name === "window" ||
-            (node.name === "globalThis" && getVariableByName(scope, "globalThis"))
-        )
-    ) {
-        return !isShadowed(scope, node);
-    }
-
-    return false;
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow the use of `alert`, `confirm`, and `prompt`",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-alert"
-        },
-
-        schema: [],
-
-        messages: {
-            unexpected: "Unexpected {{name}}."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        return {
-            CallExpression(node) {
-                const callee = skipChainExpression(node.callee),
-                    currentScope = sourceCode.getScope(node);
-
-                // without window.
-                if (callee.type === "Identifier") {
-                    const name = callee.name;
-
-                    if (!isShadowed(currentScope, callee) && isProhibitedIdentifier(callee.name)) {
-                        context.report({
-                            node,
-                            messageId: "unexpected",
-                            data: { name }
-                        });
-                    }
-
-                } else if (callee.type === "MemberExpression" && isGlobalThisReferenceOrGlobalWindow(currentScope, callee.object)) {
-                    const name = getPropertyName(callee);
-
-                    if (isProhibitedIdentifier(name)) {
-                        context.report({
-                            node,
-                            messageId: "unexpected",
-                            data: { name }
-                        });
-                    }
-                }
-            }
-        };
-
-    }
-};

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

@@ -1,133 +0,0 @@
-/**
- * @fileoverview Disallow construction of dense arrays using the Array constructor
- * @author Matt DuVall <http://www.mattduvall.com/>
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const {
-    getVariableByName,
-    isClosingParenToken,
-    isOpeningParenToken,
-    isStartOfExpressionStatement,
-    needsPrecedingSemicolon
-} = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow `Array` constructors",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-array-constructor"
-        },
-
-        hasSuggestions: true,
-
-        schema: [],
-
-        messages: {
-            preferLiteral: "The array literal notation [] is preferable.",
-            useLiteral: "Replace with an array literal.",
-            useLiteralAfterSemicolon: "Replace with an array literal, add preceding semicolon."
-        }
-    },
-
-    create(context) {
-
-        const sourceCode = context.sourceCode;
-
-        /**
-         * Gets the text between the calling parentheses of a CallExpression or NewExpression.
-         * @param {ASTNode} node A CallExpression or NewExpression node.
-         * @returns {string} The text between the calling parentheses, or an empty string if there are none.
-         */
-        function getArgumentsText(node) {
-            const lastToken = sourceCode.getLastToken(node);
-
-            if (!isClosingParenToken(lastToken)) {
-                return "";
-            }
-
-            let firstToken = node.callee;
-
-            do {
-                firstToken = sourceCode.getTokenAfter(firstToken);
-                if (!firstToken || firstToken === lastToken) {
-                    return "";
-                }
-            } while (!isOpeningParenToken(firstToken));
-
-            return sourceCode.text.slice(firstToken.range[1], lastToken.range[0]);
-        }
-
-        /**
-         * Disallow construction of dense arrays using the Array constructor
-         * @param {ASTNode} node node to evaluate
-         * @returns {void}
-         * @private
-         */
-        function check(node) {
-            if (
-                node.callee.type !== "Identifier" ||
-                node.callee.name !== "Array" ||
-                node.arguments.length === 1 &&
-                node.arguments[0].type !== "SpreadElement") {
-                return;
-            }
-
-            const variable = getVariableByName(sourceCode.getScope(node), "Array");
-
-            /*
-             * Check if `Array` is a predefined global variable: predefined globals have no declarations,
-             * meaning that the `identifiers` list of the variable object is empty.
-             */
-            if (variable && variable.identifiers.length === 0) {
-                const argsText = getArgumentsText(node);
-                let fixText;
-                let messageId;
-
-                /*
-                 * Check if the suggested change should include a preceding semicolon or not.
-                 * Due to JavaScript's ASI rules, a missing semicolon may be inserted automatically
-                 * before an expression like `Array()` or `new Array()`, but not when the expression
-                 * is changed into an array literal like `[]`.
-                 */
-                if (isStartOfExpressionStatement(node) && needsPrecedingSemicolon(sourceCode, node)) {
-                    fixText = `;[${argsText}]`;
-                    messageId = "useLiteralAfterSemicolon";
-                } else {
-                    fixText = `[${argsText}]`;
-                    messageId = "useLiteral";
-                }
-
-                context.report({
-                    node,
-                    messageId: "preferLiteral",
-                    suggest: [
-                        {
-                            messageId,
-                            fix: fixer => fixer.replaceText(node, fixText)
-                        }
-                    ]
-                });
-            }
-        }
-
-        return {
-            CallExpression: check,
-            NewExpression: check
-        };
-
-    }
-};

package/dist/src/web/frontend/node_modules/.eslint-60wj8XRy/lib/rules/no-async-promise-executor.js

@@ -1,39 +0,0 @@
-/**
- * @fileoverview disallow using an async function as a Promise executor
- * @author Teddy Katz
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Disallow using an async function as a Promise executor",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-async-promise-executor"
-        },
-
-        fixable: null,
-        schema: [],
-        messages: {
-            async: "Promise executor functions should not be async."
-        }
-    },
-
-    create(context) {
-        return {
-            "NewExpression[callee.name='Promise'][arguments.0.async=true]"(node) {
-                context.report({
-                    node: context.sourceCode.getFirstToken(node.arguments[0], token => token.value === "async"),
-                    messageId: "async"
-                });
-            }
-        };
-    }
-};