claude-flow-novice 2.2.0 → 2.2.1

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

@@ -1,300 +0,0 @@
-/**
- * @author Toru Nagashima <https://github.com/mysticatea>
- */
-"use strict";
-
-const { CALL, CONSTRUCT, ReferenceTracker, getStringIfConstant } = require("@eslint-community/eslint-utils");
-const { RegExpParser, visitRegExpAST } = require("@eslint-community/regexpp");
-const { isCombiningCharacter, isEmojiModifier, isRegionalIndicatorSymbol, isSurrogatePair } = require("./utils/unicode");
-const astUtils = require("./utils/ast-utils.js");
-const { isValidWithUnicodeFlag } = require("./utils/regular-expressions");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * @typedef {import('@eslint-community/regexpp').AST.Character} Character
- * @typedef {import('@eslint-community/regexpp').AST.CharacterClassElement} CharacterClassElement
- */
-
-/**
- * Iterate character sequences of a given nodes.
- *
- * CharacterClassRange syntax can steal a part of character sequence,
- * so this function reverts CharacterClassRange syntax and restore the sequence.
- * @param {CharacterClassElement[]} nodes The node list to iterate character sequences.
- * @returns {IterableIterator<Character[]>} The list of character sequences.
- */
-function *iterateCharacterSequence(nodes) {
-
-    /** @type {Character[]} */
-    let seq = [];
-
-    for (const node of nodes) {
-        switch (node.type) {
-            case "Character":
-                seq.push(node);
-                break;
-
-            case "CharacterClassRange":
-                seq.push(node.min);
-                yield seq;
-                seq = [node.max];
-                break;
-
-            case "CharacterSet":
-            case "CharacterClass": // [[]] nesting character class
-            case "ClassStringDisjunction": // \q{...}
-            case "ExpressionCharacterClass": // [A--B]
-                if (seq.length > 0) {
-                    yield seq;
-                    seq = [];
-                }
-                break;
-
-            // no default
-        }
-    }
-
-    if (seq.length > 0) {
-        yield seq;
-    }
-}
-
-
-/**
- * Checks whether the given character node is a Unicode code point escape or not.
- * @param {Character} char the character node to check.
- * @returns {boolean} `true` if the character node is a Unicode code point escape.
- */
-function isUnicodeCodePointEscape(char) {
-    return /^\\u\{[\da-f]+\}$/iu.test(char.raw);
-}
-
-/**
- * Each function returns `true` if it detects that kind of problem.
- * @type {Record<string, (chars: Character[]) => boolean>}
- */
-const hasCharacterSequence = {
-    surrogatePairWithoutUFlag(chars) {
-        return chars.some((c, i) => {
-            if (i === 0) {
-                return false;
-            }
-            const c1 = chars[i - 1];
-
-            return (
-                isSurrogatePair(c1.value, c.value) &&
-                !isUnicodeCodePointEscape(c1) &&
-                !isUnicodeCodePointEscape(c)
-            );
-        });
-    },
-
-    surrogatePair(chars) {
-        return chars.some((c, i) => {
-            if (i === 0) {
-                return false;
-            }
-            const c1 = chars[i - 1];
-
-            return (
-                isSurrogatePair(c1.value, c.value) &&
-                (
-                    isUnicodeCodePointEscape(c1) ||
-                    isUnicodeCodePointEscape(c)
-                )
-            );
-        });
-    },
-
-    combiningClass(chars) {
-        return chars.some((c, i) => (
-            i !== 0 &&
-            isCombiningCharacter(c.value) &&
-            !isCombiningCharacter(chars[i - 1].value)
-        ));
-    },
-
-    emojiModifier(chars) {
-        return chars.some((c, i) => (
-            i !== 0 &&
-            isEmojiModifier(c.value) &&
-            !isEmojiModifier(chars[i - 1].value)
-        ));
-    },
-
-    regionalIndicatorSymbol(chars) {
-        return chars.some((c, i) => (
-            i !== 0 &&
-            isRegionalIndicatorSymbol(c.value) &&
-            isRegionalIndicatorSymbol(chars[i - 1].value)
-        ));
-    },
-
-    zwj(chars) {
-        const lastIndex = chars.length - 1;
-
-        return chars.some((c, i) => (
-            i !== 0 &&
-            i !== lastIndex &&
-            c.value === 0x200d &&
-            chars[i - 1].value !== 0x200d &&
-            chars[i + 1].value !== 0x200d
-        ));
-    }
-};
-
-const kinds = Object.keys(hasCharacterSequence);
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Disallow characters which are made with multiple code points in character class syntax",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-misleading-character-class"
-        },
-
-        hasSuggestions: true,
-
-        schema: [],
-
-        messages: {
-            surrogatePairWithoutUFlag: "Unexpected surrogate pair in character class. Use 'u' flag.",
-            surrogatePair: "Unexpected surrogate pair in character class.",
-            combiningClass: "Unexpected combined character in character class.",
-            emojiModifier: "Unexpected modified Emoji in character class.",
-            regionalIndicatorSymbol: "Unexpected national flag in character class.",
-            zwj: "Unexpected joined character sequence in character class.",
-            suggestUnicodeFlag: "Add unicode 'u' flag to regex."
-        }
-    },
-    create(context) {
-        const sourceCode = context.sourceCode;
-        const parser = new RegExpParser();
-
-        /**
-         * Verify a given regular expression.
-         * @param {Node} node The node to report.
-         * @param {string} pattern The regular expression pattern to verify.
-         * @param {string} flags The flags of the regular expression.
-         * @param {Function} unicodeFixer Fixer for missing "u" flag.
-         * @returns {void}
-         */
-        function verify(node, pattern, flags, unicodeFixer) {
-            let patternNode;
-
-            try {
-                patternNode = parser.parsePattern(
-                    pattern,
-                    0,
-                    pattern.length,
-                    {
-                        unicode: flags.includes("u"),
-                        unicodeSets: flags.includes("v")
-                    }
-                );
-            } catch {
-
-                // Ignore regular expressions with syntax errors
-                return;
-            }
-
-            const foundKinds = new Set();
-
-            visitRegExpAST(patternNode, {
-                onCharacterClassEnter(ccNode) {
-                    for (const chars of iterateCharacterSequence(ccNode.elements)) {
-                        for (const kind of kinds) {
-                            if (hasCharacterSequence[kind](chars)) {
-                                foundKinds.add(kind);
-                            }
-                        }
-                    }
-                }
-            });
-
-            for (const kind of foundKinds) {
-                let suggest;
-
-                if (kind === "surrogatePairWithoutUFlag") {
-                    suggest = [{
-                        messageId: "suggestUnicodeFlag",
-                        fix: unicodeFixer
-                    }];
-                }
-
-                context.report({
-                    node,
-                    messageId: kind,
-                    suggest
-                });
-            }
-        }
-
-        return {
-            "Literal[regex]"(node) {
-                verify(node, node.regex.pattern, node.regex.flags, fixer => {
-                    if (!isValidWithUnicodeFlag(context.languageOptions.ecmaVersion, node.regex.pattern)) {
-                        return null;
-                    }
-
-                    return fixer.insertTextAfter(node, "u");
-                });
-            },
-            "Program"(node) {
-                const scope = sourceCode.getScope(node);
-                const tracker = new ReferenceTracker(scope);
-
-                /*
-                 * Iterate calls of RegExp.
-                 * E.g., `new RegExp()`, `RegExp()`, `new window.RegExp()`,
-                 *       `const {RegExp: a} = window; new a()`, etc...
-                 */
-                for (const { node: refNode } of tracker.iterateGlobalReferences({
-                    RegExp: { [CALL]: true, [CONSTRUCT]: true }
-                })) {
-                    const [patternNode, flagsNode] = refNode.arguments;
-                    const pattern = getStringIfConstant(patternNode, scope);
-                    const flags = getStringIfConstant(flagsNode, scope);
-
-                    if (typeof pattern === "string") {
-                        verify(refNode, pattern, flags || "", fixer => {
-
-                            if (!isValidWithUnicodeFlag(context.languageOptions.ecmaVersion, pattern)) {
-                                return null;
-                            }
-
-                            if (refNode.arguments.length === 1) {
-                                const penultimateToken = sourceCode.getLastToken(refNode, { skip: 1 }); // skip closing parenthesis
-
-                                return fixer.insertTextAfter(
-                                    penultimateToken,
-                                    astUtils.isCommaToken(penultimateToken)
-                                        ? ' "u",'
-                                        : ', "u"'
-                                );
-                            }
-
-                            if ((flagsNode.type === "Literal" && typeof flagsNode.value === "string") || flagsNode.type === "TemplateLiteral") {
-                                const range = [flagsNode.range[0], flagsNode.range[1] - 1];
-
-                                return fixer.insertTextAfterRange(range, "u");
-                            }
-
-                            return null;
-                        });
-                    }
-                }
-            }
-        };
-    }
-};

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

@@ -1,229 +0,0 @@
-/**
- * @fileoverview Rule to disallow mixed binary operators.
- * @author Toru Nagashima
- * @deprecated in ESLint v8.53.0
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils.js");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const ARITHMETIC_OPERATORS = ["+", "-", "*", "/", "%", "**"];
-const BITWISE_OPERATORS = ["&", "|", "^", "~", "<<", ">>", ">>>"];
-const COMPARISON_OPERATORS = ["==", "!=", "===", "!==", ">", ">=", "<", "<="];
-const LOGICAL_OPERATORS = ["&&", "||"];
-const RELATIONAL_OPERATORS = ["in", "instanceof"];
-const TERNARY_OPERATOR = ["?:"];
-const COALESCE_OPERATOR = ["??"];
-const ALL_OPERATORS = [].concat(
-    ARITHMETIC_OPERATORS,
-    BITWISE_OPERATORS,
-    COMPARISON_OPERATORS,
-    LOGICAL_OPERATORS,
-    RELATIONAL_OPERATORS,
-    TERNARY_OPERATOR,
-    COALESCE_OPERATOR
-);
-const DEFAULT_GROUPS = [
-    ARITHMETIC_OPERATORS,
-    BITWISE_OPERATORS,
-    COMPARISON_OPERATORS,
-    LOGICAL_OPERATORS,
-    RELATIONAL_OPERATORS
-];
-const TARGET_NODE_TYPE = /^(?:Binary|Logical|Conditional)Expression$/u;
-
-/**
- * Normalizes options.
- * @param {Object|undefined} options A options object to normalize.
- * @returns {Object} Normalized option object.
- */
-function normalizeOptions(options = {}) {
-    const hasGroups = options.groups && options.groups.length > 0;
-    const groups = hasGroups ? options.groups : DEFAULT_GROUPS;
-    const allowSamePrecedence = options.allowSamePrecedence !== false;
-
-    return {
-        groups,
-        allowSamePrecedence
-    };
-}
-
-/**
- * Checks whether any group which includes both given operator exists or not.
- * @param {Array<string[]>} groups A list of groups to check.
- * @param {string} left An operator.
- * @param {string} right Another operator.
- * @returns {boolean} `true` if such group existed.
- */
-function includesBothInAGroup(groups, left, right) {
-    return groups.some(group => group.includes(left) && group.includes(right));
-}
-
-/**
- * Checks whether the given node is a conditional expression and returns the test node else the left node.
- * @param {ASTNode} node A node which can be a BinaryExpression or a LogicalExpression node.
- * This parent node can be BinaryExpression, LogicalExpression
- *      , or a ConditionalExpression node
- * @returns {ASTNode} node the appropriate node(left or test).
- */
-function getChildNode(node) {
-    return node.type === "ConditionalExpression" ? node.test : node.left;
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../shared/types').Rule} */
-module.exports = {
-    meta: {
-        deprecated: true,
-        replacedBy: [],
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow mixed binary operators",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-mixed-operators"
-        },
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    groups: {
-                        type: "array",
-                        items: {
-                            type: "array",
-                            items: { enum: ALL_OPERATORS },
-                            minItems: 2,
-                            uniqueItems: true
-                        },
-                        uniqueItems: true
-                    },
-                    allowSamePrecedence: {
-                        type: "boolean",
-                        default: true
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        messages: {
-            unexpectedMixedOperator: "Unexpected mix of '{{leftOperator}}' and '{{rightOperator}}'. Use parentheses to clarify the intended order of operations."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-        const options = normalizeOptions(context.options[0]);
-
-        /**
-         * Checks whether a given node should be ignored by options or not.
-         * @param {ASTNode} node A node to check. This is a BinaryExpression
-         *      node or a LogicalExpression node. This parent node is one of
-         *      them, too.
-         * @returns {boolean} `true` if the node should be ignored.
-         */
-        function shouldIgnore(node) {
-            const a = node;
-            const b = node.parent;
-
-            return (
-                !includesBothInAGroup(options.groups, a.operator, b.type === "ConditionalExpression" ? "?:" : b.operator) ||
-                (
-                    options.allowSamePrecedence &&
-                    astUtils.getPrecedence(a) === astUtils.getPrecedence(b)
-                )
-            );
-        }
-
-        /**
-         * Checks whether the operator of a given node is mixed with parent
-         * node's operator or not.
-         * @param {ASTNode} node A node to check. This is a BinaryExpression
-         *      node or a LogicalExpression node. This parent node is one of
-         *      them, too.
-         * @returns {boolean} `true` if the node was mixed.
-         */
-        function isMixedWithParent(node) {
-
-            return (
-                node.operator !== node.parent.operator &&
-                !astUtils.isParenthesised(sourceCode, node)
-            );
-        }
-
-        /**
-         * Gets the operator token of a given node.
-         * @param {ASTNode} node A node to check. This is a BinaryExpression
-         *      node or a LogicalExpression node.
-         * @returns {Token} The operator token of the node.
-         */
-        function getOperatorToken(node) {
-            return sourceCode.getTokenAfter(getChildNode(node), astUtils.isNotClosingParenToken);
-        }
-
-        /**
-         * Reports both the operator of a given node and the operator of the
-         * parent node.
-         * @param {ASTNode} node A node to check. This is a BinaryExpression
-         *      node or a LogicalExpression node. This parent node is one of
-         *      them, too.
-         * @returns {void}
-         */
-        function reportBothOperators(node) {
-            const parent = node.parent;
-            const left = (getChildNode(parent) === node) ? node : parent;
-            const right = (getChildNode(parent) !== node) ? node : parent;
-            const data = {
-                leftOperator: left.operator || "?:",
-                rightOperator: right.operator || "?:"
-            };
-
-            context.report({
-                node: left,
-                loc: getOperatorToken(left).loc,
-                messageId: "unexpectedMixedOperator",
-                data
-            });
-            context.report({
-                node: right,
-                loc: getOperatorToken(right).loc,
-                messageId: "unexpectedMixedOperator",
-                data
-            });
-        }
-
-        /**
-         * Checks between the operator of this node and the operator of the
-         * parent node.
-         * @param {ASTNode} node A node to check.
-         * @returns {void}
-         */
-        function check(node) {
-            if (
-                TARGET_NODE_TYPE.test(node.parent.type) &&
-                isMixedWithParent(node) &&
-                !shouldIgnore(node)
-            ) {
-                reportBothOperators(node);
-            }
-        }
-
-        return {
-            BinaryExpression: check,
-            LogicalExpression: check
-        };
-    }
-};