create-packer 1.34.4 → 1.34.6

package/template/lib/react/node_modules/eslint/lib/rules/no-misleading-character-class.js

@@ -0,0 +1,300 @@
+/**
+ * @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/template/lib/react/node_modules/eslint/lib/rules/no-mixed-operators.js

@@ -0,0 +1,229 @@
+/**
+ * @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
+        };
+    }
+};