The implementation of the upstream rule is difficult to implement.

At first, it looks for a numeric value, this part can be migrated to rust. But terminating if one or two suggestions should be disabled, is depending on the static (resolved) value.

https://github.com/eslint-community/eslint-utils/blob/main/src/get-static-value.mjs

Instead, we just provide both suggestions and mark both as dangerous.

<details>
<summary>`isNumber` migrated rust code, which is not used anymore</summary>

```rust

const MATH_METHODS: &[&str] = &[
    "abs",
    "acos",
    "acosh",
    "asin",
    "asinh",
    "atan",
    "atan2",
    "atanh",
    "cbrt",
    "ceil",
    "clz32",
    "cos",
    "cosh",
    "exp",
    "expm1",
    "floor",
    "f16round",
    "fround",
    "hypot",
    "imul",
    "log",
    "log10",
    "log1p",
    "log2",
    "max",
    "min",
    "pow",
    "random",
    "round",
    "sign",
    "sin",
    "sinh",
    "sqrt",
    "sumPrecise",
    "tan",
    "tanh",
    "trunc",
];

const NUMBER_PROPERTIES: &[&str] = &[
    "EPSILON",
    "MAX_SAFE_INTEGER",
    "MAX_VALUE",
    "MIN_SAFE_INTEGER",
    "MIN_VALUE",
    "NaN",
    "NEGATIVE_INFINITY",
    "POSITIVE_INFINITY",
];

const MATH_PROPERTIES: &[&str] = &["E", "LN10", "LN2", "LOG10E", "LOG2E", "PI", "SQRT1_2", "SQRT2"];

fn is_number_expression(expression: &Expression, ctx: &LintContext) -> bool {
    if is_known_number_property(expression) {
        return true;
    }
    if is_known_number_return_value(expression) {
        return true;
    }
    if is_length_property(expression) {
        return true;
    }
    match expression {
        Expression::NumericLiteral(_) | Expression::UpdateExpression(_) => true,
        // Expression::UpdateExpression(update) => is_number_expression(&update.argument),
        Expression::UnaryExpression(unary) => {
            // `+` can't use on `BigInt`
            // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#operators
            if matches!(unary.operator, UnaryOperator::UnaryPlus) {
                return true;
            }

            if !matches!(unary.operator, UnaryOperator::UnaryNegation | UnaryOperator::BitwiseNot) {
                return false;
            }

            is_number_expression(&unary.argument, ctx)
        }
        Expression::AssignmentExpression(assign) => {
            if assign.operator == AssignmentOperator::Assign {
                return is_number_expression(&assign.right, ctx);
            }

            // `>>>=` (zero-fill right shift) can't use on `BigInt`
            if assign.operator == AssignmentOperator::ShiftRightZeroFill {
                return true;
            }

            if assign.operator == AssignmentOperator::Addition {
                let Some(left) = assign.left.get_expression() else {
                    return false;
                };
                // `+=` can be used for both string concatenation and numeric addition, so we need
                return is_number_expression(&assign.right, ctx) && is_number_expression(left, ctx);
            }

            // `a * b` can be `BigInt`, we need make sure at least one side is number
            if !matches!(
                assign.operator,
                AssignmentOperator::Subtraction
                    | AssignmentOperator::Multiplication
                    | AssignmentOperator::Division
                    | AssignmentOperator::Remainder
                    | AssignmentOperator::Exponential
                    | AssignmentOperator::ShiftLeft
                    | AssignmentOperator::ShiftRight
                    | AssignmentOperator::BitwiseOR
                    | AssignmentOperator::BitwiseXOR
                    | AssignmentOperator::BitwiseAnd
            ) {
                return false;
            }

            if is_number_expression(&assign.right, ctx) {
                return true;
            }
            let Some(left) = assign.left.get_expression() else {
                return false;
            };
            is_number_expression(left, ctx)
        }
        Expression::BinaryExpression(binary) => {
            // `>>>` (zero-fill right shift) can't use on `BigInt`
            if binary.operator == BinaryOperator::ShiftRightZeroFill {
                return true;
            }

            if binary.operator == BinaryOperator::Addition {
                // `+` can be used for both string concatenation and numeric addition, so we need to check the operands
                return is_number_expression(&binary.left, ctx)
                    && is_number_expression(&binary.right, ctx);
            }

            // `a * b` can be `BigInt`, we need make sure at least one side is number
            matches!(
                binary.operator,
                BinaryOperator::Subtraction
                    | BinaryOperator::Multiplication
                    | BinaryOperator::Division
                    | BinaryOperator::Remainder
                    | BinaryOperator::Exponential
                    | BinaryOperator::ShiftLeft
                    | BinaryOperator::ShiftRight
                    | BinaryOperator::BitwiseOR
                    | BinaryOperator::BitwiseXOR
                    | BinaryOperator::BitwiseAnd
            ) && (is_number_expression(&binary.left, ctx)
                || is_number_expression(&binary.right, ctx))
        }
        Expression::ConditionalExpression(conditional) => {
            is_number_expression(&conditional.consequent, ctx)
                && is_number_expression(&conditional.alternate, ctx)
        }
        // the last expression of a sequence expression is the one that determines the value of the whole expression
        // example: `new Array((2, (window, 3, 4, 6)))` is evaluated to `Array.from({ length: 6})`
        Expression::SequenceExpression(sequence) => {
            if let Some(last_expr) = sequence.expressions.last() {
                is_number_expression(last_expr, ctx)
            } else {
                false
            }
        }
        Expression::Identifier(ident) => {
            if ident.name == "NaN" {
                return true;
            }
            let Some(reference_id) = ident.reference_id.get() else {
                return false;
            };
            let reference = ctx.scoping().get_reference(reference_id);
            let Some(symbol_id) = reference.symbol_id() else {
                return false;
            };
            let variable = ctx.scoping().symbol_declaration(symbol_id);
            let node = ctx.nodes().get_node(variable);

            match node.kind() {
                AstKind::VariableDeclarator(variable) => {
                    if let Some(init) = &variable.init {
                        is_number_expression(init, ctx)
                    } else {
                        false
                    }
                }
                _ => false,
            }
        }
        _ => false,
    }
}

fn is_length_property(expression: &Expression) -> bool {
    if let Expression::StaticMemberExpression(member) = expression {
        return member.property.name == "length";
    }
    false
}

fn is_known_number_return_value(expression: &Expression) -> bool {
    let Expression::CallExpression(call) = expression else {
        return false;
    };
    match call.callee.get_inner_expression() {
        Expression::Identifier(ident) => {
            ident.name == "Number" || ident.name == "parseInt" || ident.name == "parseFloat"
        }
        Expression::StaticMemberExpression(member) => {
            let Expression::Identifier(ident_obj) = &member.object else {
                return false;
            };

            match ident_obj.name.as_str() {
                "Number"
                    if member.property.name == "parseInt"
                        || member.property.name == "parseFloat" =>
                {
                    true
                }
                "Math" if MATH_METHODS.contains(&member.property.name.as_str()) => true,
                _ => false,
            }
        }
        _ => false,
    }
}

fn is_known_number_property(expression: &Expression) -> bool {
    let Expression::StaticMemberExpression(member) = expression else {
        return false;
    };
    let Expression::Identifier(ident_obj) = &member.object else {
        return false;
    };
    match ident_obj.name.as_str() {
        "Number" if NUMBER_PROPERTIES.contains(&member.property.name.as_str()) => true,
        "Math" if MATH_PROPERTIES.contains(&member.property.name.as_str()) => true,
        _ => false,
    }
}
```

</details>