diff --git a/Userland/Libraries/LibJS/AST.cpp b/Userland/Libraries/LibJS/AST.cpp
index 997152e461..a6b97aa4a5 100644
--- a/Userland/Libraries/LibJS/AST.cpp
+++ b/Userland/Libraries/LibJS/AST.cpp
@@ -655,13 +655,13 @@ Value BinaryExpression::execute(Interpreter& interpreter, GlobalObject& global_o
         return mod(global_object, lhs_result, rhs_result);
     case BinaryOp::Exponentiation:
         return exp(global_object, lhs_result, rhs_result);
-    case BinaryOp::TypedEquals:
+    case BinaryOp::StrictlyEquals:
         return Value(is_strictly_equal(lhs_result, rhs_result));
-    case BinaryOp::TypedInequals:
+    case BinaryOp::StrictlyInequals:
         return Value(!is_strictly_equal(lhs_result, rhs_result));
-    case BinaryOp::AbstractEquals:
+    case BinaryOp::LooselyEquals:
         return Value(is_loosely_equal(global_object, lhs_result, rhs_result));
-    case BinaryOp::AbstractInequals:
+    case BinaryOp::LooselyInequals:
         return Value(!is_loosely_equal(global_object, lhs_result, rhs_result));
     case BinaryOp::GreaterThan:
         return greater_than(global_object, lhs_result, rhs_result);
@@ -1053,16 +1053,16 @@ void BinaryExpression::dump(int indent) const
     case BinaryOp::Exponentiation:
         op_string = "**";
         break;
-    case BinaryOp::TypedEquals:
+    case BinaryOp::StrictlyEquals:
         op_string = "===";
         break;
-    case BinaryOp::TypedInequals:
+    case BinaryOp::StrictlyInequals:
         op_string = "!==";
         break;
-    case BinaryOp::AbstractEquals:
+    case BinaryOp::LooselyEquals:
         op_string = "==";
         break;
-    case BinaryOp::AbstractInequals:
+    case BinaryOp::LooselyInequals:
         op_string = "!=";
         break;
     case BinaryOp::GreaterThan:
diff --git a/Userland/Libraries/LibJS/AST.h b/Userland/Libraries/LibJS/AST.h
index 22d55da347..37f21efb62 100644
--- a/Userland/Libraries/LibJS/AST.h
+++ b/Userland/Libraries/LibJS/AST.h
@@ -654,10 +654,10 @@ enum class BinaryOp {
     Division,
     Modulo,
     Exponentiation,
-    TypedEquals,
-    TypedInequals,
-    AbstractEquals,
-    AbstractInequals,
+    StrictlyEquals,
+    StrictlyInequals,
+    LooselyEquals,
+    LooselyInequals,
     GreaterThan,
     GreaterThanEquals,
     LessThan,
diff --git a/Userland/Libraries/LibJS/Bytecode/ASTCodegen.cpp b/Userland/Libraries/LibJS/Bytecode/ASTCodegen.cpp
index f25875b7ca..2fd58b5346 100644
--- a/Userland/Libraries/LibJS/Bytecode/ASTCodegen.cpp
+++ b/Userland/Libraries/LibJS/Bytecode/ASTCodegen.cpp
@@ -121,17 +121,17 @@ void BinaryExpression::generate_bytecode(Bytecode::Generator& generator) const
     case BinaryOp::LessThanEquals:
         generator.emit<Bytecode::Op::LessThanEquals>(lhs_reg);
         break;
-    case BinaryOp::AbstractInequals:
-        generator.emit<Bytecode::Op::AbstractInequals>(lhs_reg);
+    case BinaryOp::LooselyInequals:
+        generator.emit<Bytecode::Op::LooselyInequals>(lhs_reg);
         break;
-    case BinaryOp::AbstractEquals:
-        generator.emit<Bytecode::Op::AbstractEquals>(lhs_reg);
+    case BinaryOp::LooselyEquals:
+        generator.emit<Bytecode::Op::LooselyEquals>(lhs_reg);
         break;
-    case BinaryOp::TypedInequals:
-        generator.emit<Bytecode::Op::TypedInequals>(lhs_reg);
+    case BinaryOp::StrictlyInequals:
+        generator.emit<Bytecode::Op::StrictlyInequals>(lhs_reg);
         break;
-    case BinaryOp::TypedEquals:
-        generator.emit<Bytecode::Op::TypedEquals>(lhs_reg);
+    case BinaryOp::StrictlyEquals:
+        generator.emit<Bytecode::Op::StrictlyEquals>(lhs_reg);
         break;
     case BinaryOp::BitwiseAnd:
         generator.emit<Bytecode::Op::BitwiseAnd>(lhs_reg);
@@ -1268,7 +1268,7 @@ void SwitchStatement::generate_bytecode(Bytecode::Generator& generator) const
         if (switch_case.test()) {
             generator.switch_to_basic_block(*next_test_block);
             switch_case.test()->generate_bytecode(generator);
-            generator.emit<Bytecode::Op::TypedEquals>(discriminant_reg);
+            generator.emit<Bytecode::Op::StrictlyEquals>(discriminant_reg);
             next_test_block = &generator.make_block();
             generator.emit<Bytecode::Op::JumpConditional>().set_targets(Bytecode::Label { case_block }, Bytecode::Label { *next_test_block });
         } else {
diff --git a/Userland/Libraries/LibJS/Bytecode/Instruction.h b/Userland/Libraries/LibJS/Bytecode/Instruction.h
index ae98f0a5a5..4cd7742bf9 100644
--- a/Userland/Libraries/LibJS/Bytecode/Instruction.h
+++ b/Userland/Libraries/LibJS/Bytecode/Instruction.h
@@ -23,10 +23,10 @@
     O(GreaterThanEquals)             \
     O(LessThan)                      \
     O(LessThanEquals)                \
-    O(AbstractInequals)              \
-    O(AbstractEquals)                \
-    O(TypedInequals)                 \
-    O(TypedEquals)                   \
+    O(LooselyInequals)               \
+    O(LooselyEquals)                 \
+    O(StrictlyInequals)              \
+    O(StrictlyEquals)                \
     O(NewBigInt)                     \
     O(NewArray)                      \
     O(IteratorToArray)               \
diff --git a/Userland/Libraries/LibJS/Bytecode/Op.h b/Userland/Libraries/LibJS/Bytecode/Op.h
index 7785ed88fe..23f14bc026 100644
--- a/Userland/Libraries/LibJS/Bytecode/Op.h
+++ b/Userland/Libraries/LibJS/Bytecode/Op.h
@@ -80,10 +80,10 @@ private:
     O(GreaterThanEquals, greater_than_equals) \
     O(LessThan, less_than)                    \
     O(LessThanEquals, less_than_equals)       \
-    O(AbstractInequals, abstract_inequals)    \
-    O(AbstractEquals, abstract_equals)        \
-    O(TypedInequals, typed_inequals)          \
-    O(TypedEquals, typed_equals)              \
+    O(LooselyInequals, abstract_inequals)     \
+    O(LooselyEquals, abstract_equals)         \
+    O(StrictlyInequals, typed_inequals)       \
+    O(StrictlyEquals, typed_equals)           \
     O(BitwiseAnd, bitwise_and)                \
     O(BitwiseOr, bitwise_or)                  \
     O(BitwiseXor, bitwise_xor)                \
diff --git a/Userland/Libraries/LibJS/Parser.cpp b/Userland/Libraries/LibJS/Parser.cpp
index 499208907e..6ef37cf761 100644
--- a/Userland/Libraries/LibJS/Parser.cpp
+++ b/Userland/Libraries/LibJS/Parser.cpp
@@ -1424,16 +1424,16 @@ NonnullRefPtr<Expression> Parser::parse_secondary_expression(NonnullRefPtr<Expre
         return create_ast_node<BinaryExpression>({ m_state.current_token.filename(), rule_start.position(), position() }, BinaryOp::LessThanEquals, move(lhs), parse_expression(min_precedence, associativity));
     case TokenType::EqualsEqualsEquals:
         consume();
-        return create_ast_node<BinaryExpression>({ m_state.current_token.filename(), rule_start.position(), position() }, BinaryOp::TypedEquals, move(lhs), parse_expression(min_precedence, associativity));
+        return create_ast_node<BinaryExpression>({ m_state.current_token.filename(), rule_start.position(), position() }, BinaryOp::StrictlyEquals, move(lhs), parse_expression(min_precedence, associativity));
     case TokenType::ExclamationMarkEqualsEquals:
         consume();
-        return create_ast_node<BinaryExpression>({ m_state.current_token.filename(), rule_start.position(), position() }, BinaryOp::TypedInequals, move(lhs), parse_expression(min_precedence, associativity));
+        return create_ast_node<BinaryExpression>({ m_state.current_token.filename(), rule_start.position(), position() }, BinaryOp::StrictlyInequals, move(lhs), parse_expression(min_precedence, associativity));
     case TokenType::EqualsEquals:
         consume();
-        return create_ast_node<BinaryExpression>({ m_state.current_token.filename(), rule_start.position(), position() }, BinaryOp::AbstractEquals, move(lhs), parse_expression(min_precedence, associativity));
+        return create_ast_node<BinaryExpression>({ m_state.current_token.filename(), rule_start.position(), position() }, BinaryOp::LooselyEquals, move(lhs), parse_expression(min_precedence, associativity));
     case TokenType::ExclamationMarkEquals:
         consume();
-        return create_ast_node<BinaryExpression>({ m_state.current_token.filename(), rule_start.position(), position() }, BinaryOp::AbstractInequals, move(lhs), parse_expression(min_precedence, associativity));
+        return create_ast_node<BinaryExpression>({ m_state.current_token.filename(), rule_start.position(), position() }, BinaryOp::LooselyInequals, move(lhs), parse_expression(min_precedence, associativity));
     case TokenType::In:
         consume();
         return create_ast_node<BinaryExpression>({ m_state.current_token.filename(), rule_start.position(), position() }, BinaryOp::In, move(lhs), parse_expression(min_precedence, associativity));