LibJS: Add BigInt

Author: https://github.com/linusg
Commit: https://github.com/SerenityOS/serenity/commit/0ff9d7e1898
Pull-request: https://github.com/SerenityOS/serenity/pull/2509
Reviewed-by: https://github.com/alimpfard

Libraries/LibGUI/JSSyntaxHighlighter.cpp

@@ -40,6 +40,7 @@ static TextStyle style_for_token_type(Gfx::Palette palette, JS::TokenType type)
     case JS::TokenType::Eof:
         return { palette.syntax_comment() };
     case JS::TokenType::NumericLiteral:
+    case JS::TokenType::BigIntLiteral:
         return { palette.syntax_number() };
     case JS::TokenType::StringLiteral:
     case JS::TokenType::TemplateLiteralStart:

Libraries/LibJS/AST.cpp

@@ -29,10 +29,12 @@
 #include <AK/HashMap.h>
 #include <AK/ScopeGuard.h>
 #include <AK/StringBuilder.h>
+#include <LibCrypto/BigInt/SignedBigInteger.h>
 #include <LibJS/AST.h>
 #include <LibJS/Interpreter.h>
 #include <LibJS/Runtime/Accessor.h>
 #include <LibJS/Runtime/Array.h>
+#include <LibJS/Runtime/BigInt.h>
 #include <LibJS/Runtime/Error.h>
 #include <LibJS/Runtime/GlobalObject.h>
 #include <LibJS/Runtime/MarkedValueList.h>
@@ -635,6 +637,8 @@ Value UnaryExpression::execute(Interpreter& interpreter) const
             return js_string(interpreter, "boolean");
         case Value::Type::Symbol:
             return js_string(interpreter, "symbol");
+        case Value::Type::BigInt:
+            return js_string(interpreter, "bigint");
         default:
             ASSERT_NOT_REACHED();
         }
@@ -834,6 +838,12 @@ void NumericLiteral::dump(int indent) const
     printf("NumericLiteral %g\n", m_value);
 }
 
+void BigIntLiteral::dump(int indent) const
+{
+    print_indent(indent);
+    printf("BigIntLiteral %s\n", m_value.characters());
+}
+
 void BooleanLiteral::dump(int indent) const
 {
     print_indent(indent);
@@ -1108,23 +1118,28 @@ Value UpdateExpression::execute(Interpreter& interpreter) const
     auto old_value = reference.get(interpreter);
     if (interpreter.exception())
         return {};
-    old_value = old_value.to_number(interpreter);
+    old_value = old_value.to_numeric(interpreter);
     if (interpreter.exception())
         return {};
 
-    int op_result = 0;
+    Value new_value;
     switch (m_op) {
     case UpdateOp::Increment:
-        op_result = 1;
+        if (old_value.is_number())
+            new_value = Value(old_value.as_double() + 1);
+        else
+            new_value = js_bigint(interpreter, old_value.as_bigint().big_integer().plus(Crypto::SignedBigInteger { 1 }));
         break;
     case UpdateOp::Decrement:
-        op_result = -1;
+        if (old_value.is_number())
+            new_value = Value(old_value.as_double() - 1);
+        else
+            new_value = js_bigint(interpreter, old_value.as_bigint().big_integer().minus(Crypto::SignedBigInteger { 1 }));
         break;
     default:
         ASSERT_NOT_REACHED();
     }
 
-    auto new_value = Value(old_value.as_double() + op_result);
     reference.put(interpreter, new_value);
     if (interpreter.exception())
         return {};
@@ -1420,6 +1435,11 @@ Value NumericLiteral::execute(Interpreter&) const
     return Value(m_value);
 }
 
+Value BigIntLiteral::execute(Interpreter& interpreter) const
+{
+    return js_bigint(interpreter, Crypto::SignedBigInteger::from_base10(m_value.substring(0, m_value.length() - 1)));
+}
+
 Value BooleanLiteral::execute(Interpreter&) const
 {
     return Value(m_value);

Libraries/LibJS/AST.h

@@ -558,6 +558,22 @@ private:
     double m_value { 0 };
 };
 
+class BigIntLiteral final : public Literal {
+public:
+    explicit BigIntLiteral(String value)
+        : m_value(move(value))
+    {
+    }
+
+    virtual Value execute(Interpreter&) const override;
+    virtual void dump(int indent) const override;
+
+private:
+    virtual const char* class_name() const override { return "BigIntLiteral"; }
+
+    String m_value;
+};
+
 class StringLiteral final : public Literal {
 public:
     explicit StringLiteral(String value)

Libraries/LibJS/CMakeLists.txt

@@ -8,9 +8,13 @@ set(SOURCES
     Lexer.cpp
     MarkupGenerator.cpp
     Parser.cpp
-    Runtime/ArrayConstructor.cpp
     Runtime/Array.cpp
+    Runtime/ArrayConstructor.cpp
     Runtime/ArrayPrototype.cpp
+    Runtime/BigInt.cpp
+    Runtime/BigIntConstructor.cpp
+    Runtime/BigIntObject.cpp
+    Runtime/BigIntPrototype.cpp
     Runtime/BooleanConstructor.cpp
     Runtime/BooleanObject.cpp
     Runtime/BooleanPrototype.cpp
@@ -65,4 +69,4 @@ set(SOURCES
 )
 
 serenity_lib(LibJS js)
-target_link_libraries(LibJS LibM LibCore)
+target_link_libraries(LibJS LibM LibCore LibCrypto)

Libraries/LibJS/Forward.h

@@ -28,6 +28,7 @@
 
 #define JS_ENUMERATE_NATIVE_OBJECTS                                              \
     __JS_ENUMERATE(Array, array, ArrayPrototype, ArrayConstructor)               \
+    __JS_ENUMERATE(BigIntObject, bigint, BigIntPrototype, BigIntConstructor)     \
     __JS_ENUMERATE(BooleanObject, boolean, BooleanPrototype, BooleanConstructor) \
     __JS_ENUMERATE(Date, date, DatePrototype, DateConstructor)                   \
     __JS_ENUMERATE(Error, error, ErrorPrototype, ErrorConstructor)               \
@@ -55,6 +56,7 @@
 namespace JS {
 
 class ASTNode;
+class BigInt;
 class BoundFunction;
 class Cell;
 class DeferGC;

Libraries/LibJS/Lexer.cpp

@@ -348,37 +348,36 @@ Token Lexer::next()
             token_type = it->value;
         }
     } else if (is_numeric_literal_start()) {
+        token_type = TokenType::NumericLiteral;
         if (m_current_char == '0') {
             consume();
             if (m_current_char == '.') {
                 // decimal
                 consume();
-                while (isdigit(m_current_char)) {
+                while (isdigit(m_current_char))
                     consume();
-                }
-                if (m_current_char == 'e' || m_current_char == 'E') {
+                if (m_current_char == 'e' || m_current_char == 'E')
                     consume_exponent();
-                }
             } else if (m_current_char == 'e' || m_current_char == 'E') {
                 consume_exponent();
             } else if (m_current_char == 'o' || m_current_char == 'O') {
                 // octal
                 consume();
-                while (m_current_char >= '0' && m_current_char <= '7') {
+                while (m_current_char >= '0' && m_current_char <= '7')
                     consume();
-                }
             } else if (m_current_char == 'b' || m_current_char == 'B') {
                 // binary
                 consume();
-                while (m_current_char == '0' || m_current_char == '1') {
+                while (m_current_char == '0' || m_current_char == '1')
                     consume();
-                }
             } else if (m_current_char == 'x' || m_current_char == 'X') {
                 // hexadecimal
                 consume();
-                while (isxdigit(m_current_char)) {
+                while (isxdigit(m_current_char))
                     consume();
-                }
+            } else if (m_current_char == 'n') {
+                consume();
+                token_type = TokenType::BigIntLiteral;
             } else if (isdigit(m_current_char)) {
                 // octal without 'O' prefix. Forbidden in 'strict mode'
                 // FIXME: We need to make sure this produces a syntax error when in strict mode
@@ -388,20 +387,21 @@ Token Lexer::next()
             }
         } else {
             // 1...9 or period
-            while (isdigit(m_current_char)) {
+            while (isdigit(m_current_char))
                 consume();
-            }
-            if (m_current_char == '.') {
+            if (m_current_char == 'n') {
                 consume();
-                while (isdigit(m_current_char)) {
+                token_type = TokenType::BigIntLiteral;
+            } else {
+                if (m_current_char == '.') {
                     consume();
+                    while (isdigit(m_current_char))
+                        consume();
                 }
-            }
-            if (m_current_char == 'e' || m_current_char == 'E') {
-                consume_exponent();
+                if (m_current_char == 'e' || m_current_char == 'E')
+                    consume_exponent();
             }
         }
-        token_type = TokenType::NumericLiteral;
     } else if (m_current_char == '"' || m_current_char == '\'') {
         char stop_char = m_current_char;
         consume();

Libraries/LibJS/MarkupGenerator.cpp

@@ -217,6 +217,7 @@ MarkupGenerator::StyleType MarkupGenerator::style_type_for_token(Token token)
     case TokenType::UnterminatedTemplateLiteral:
         return StyleType::Invalid;
     case TokenType::NumericLiteral:
+    case TokenType::BigIntLiteral:
         return StyleType::Number;
     case TokenType::StringLiteral:
     case TokenType::TemplateLiteralStart:

Libraries/LibJS/Parser.cpp

@@ -451,6 +451,8 @@ NonnullRefPtr<Expression> Parser::parse_primary_expression()
     }
     case TokenType::NumericLiteral:
         return create_ast_node<NumericLiteral>(consume().double_value());
+    case TokenType::BigIntLiteral:
+        return create_ast_node<BigIntLiteral>(consume().value());
     case TokenType::BoolLiteral:
         return create_ast_node<BooleanLiteral>(consume().bool_value());
     case TokenType::StringLiteral:
@@ -547,7 +549,8 @@ NonnullRefPtr<ObjectExpression> Parser::parse_object_expression()
         return match_identifier_name()
             || type == TokenType::BracketOpen
             || type == TokenType::StringLiteral
-            || type == TokenType::NumericLiteral;
+            || type == TokenType::NumericLiteral
+            || type == TokenType::BigIntLiteral;
     };
 
     auto parse_property_key = [&]() -> NonnullRefPtr<Expression> {
@@ -555,6 +558,9 @@ NonnullRefPtr<ObjectExpression> Parser::parse_object_expression()
             return parse_string_literal(consume());
         } else if (match(TokenType::NumericLiteral)) {
             return create_ast_node<StringLiteral>(consume(TokenType::NumericLiteral).value());
+        } else if (match(TokenType::BigIntLiteral)) {
+            auto value = consume(TokenType::BigIntLiteral).value();
+            return create_ast_node<StringLiteral>(value.substring_view(0, value.length() - 1));
         } else if (match(TokenType::BracketOpen)) {
             consume(TokenType::BracketOpen);
             auto result = parse_expression(0);
@@ -1448,6 +1454,7 @@ bool Parser::match_expression() const
     auto type = m_parser_state.m_current_token.type();
     return type == TokenType::BoolLiteral
         || type == TokenType::NumericLiteral
+        || type == TokenType::BigIntLiteral
         || type == TokenType::StringLiteral
         || type == TokenType::TemplateLiteralStart
         || type == TokenType::NullLiteral

Libraries/LibJS/Runtime/BigInt.cpp

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2020, Linus Groh <mail@linusgroh.de>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <LibCrypto/BigInt/SignedBigInteger.h>
+#include <LibJS/Interpreter.h>
+#include <LibJS/Runtime/BigInt.h>
+
+namespace JS {
+
+BigInt::BigInt(Crypto::SignedBigInteger big_integer)
+    : m_big_integer(move(big_integer))
+{
+    ASSERT(!m_big_integer.is_invalid());
+}
+
+BigInt::~BigInt()
+{
+}
+
+BigInt* js_bigint(Heap& heap, Crypto::SignedBigInteger big_integer)
+{
+    return heap.allocate<BigInt>(move(big_integer));
+}
+
+BigInt* js_bigint(Interpreter& interpreter, Crypto::SignedBigInteger big_integer)
+{
+    return js_bigint(interpreter.heap(), move(big_integer));
+}
+
+}

Libraries/LibJS/Runtime/BigInt.h

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2020, Linus Groh <mail@linusgroh.de>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include <LibCrypto/BigInt/SignedBigInteger.h>
+#include <LibJS/Runtime/BigInt.h>
+#include <LibJS/Runtime/Cell.h>
+
+namespace JS {
+
+class BigInt final : public Cell {
+public:
+    BigInt(Crypto::SignedBigInteger);
+    virtual ~BigInt();
+
+    const Crypto::SignedBigInteger& big_integer() const { return m_big_integer; }
+    const String to_string() const { return String::format("%sn", m_big_integer.to_base10().characters()); }
+
+private:
+    virtual const char* class_name() const override { return "BigInt"; }
+
+    Crypto::SignedBigInteger m_big_integer;
+};
+
+BigInt* js_bigint(Heap&, Crypto::SignedBigInteger);
+BigInt* js_bigint(Interpreter&, Crypto::SignedBigInteger);
+
+}

Libraries/LibJS/Runtime/BigIntConstructor.cpp

@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2020, Linus Groh <mail@linusgroh.de>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <AK/String.h>
+#include <LibCrypto/BigInt/SignedBigInteger.h>
+#include <LibJS/Interpreter.h>
+#include <LibJS/Runtime/BigIntConstructor.h>
+#include <LibJS/Runtime/BigIntObject.h>
+#include <LibJS/Runtime/Error.h>
+#include <LibJS/Runtime/GlobalObject.h>
+
+namespace JS {
+
+BigIntConstructor::BigIntConstructor()
+    : NativeFunction("BigInt", *interpreter().global_object().function_prototype())
+{
+    define_property("prototype", interpreter().global_object().bigint_prototype(), 0);
+    define_property("length", Value(1), Attribute::Configurable);
+
+    u8 attr = Attribute::Writable | Attribute::Configurable;
+    define_native_function("asIntN", as_int_n, 2, attr);
+    define_native_function("asUintN", as_uint_n, 2, attr);
+}
+
+BigIntConstructor::~BigIntConstructor()
+{
+}
+
+Value BigIntConstructor::call(Interpreter& interpreter)
+{
+    auto primitive = interpreter.argument(0).to_primitive(interpreter, Value::PreferredType::Number);
+    if (interpreter.exception())
+        return {};
+    if (primitive.is_number()) {
+        if (!primitive.is_integer()) {
+            interpreter.throw_exception<RangeError>("BigInt argument must be an integer");
+            return {};
+        }
+        return js_bigint(interpreter, Crypto::SignedBigInteger { primitive.as_i32() });
+    }
+    auto* bigint = interpreter.argument(0).to_bigint(interpreter);
+    if (interpreter.exception())
+        return {};
+    return bigint;
+}
+
+Value BigIntConstructor::construct(Interpreter& interpreter)
+{
+    interpreter.throw_exception<TypeError>("BigInt is not a constructor");
+    return {};
+}
+
+Value BigIntConstructor::as_int_n(Interpreter&)
+{
+    TODO();
+}
+
+Value BigIntConstructor::as_uint_n(Interpreter&)
+{
+    TODO();
+}
+
+}

Libraries/LibJS/Runtime/BigIntConstructor.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2020, Linus Groh <mail@linusgroh.de>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include <LibJS/Runtime/NativeFunction.h>
+
+namespace JS {
+
+class BigIntConstructor final : public NativeFunction {
+public:
+    BigIntConstructor();
+    virtual ~BigIntConstructor() override;
+
+    virtual Value call(Interpreter&) override;
+    virtual Value construct(Interpreter&) override;
+
+private:
+    virtual bool has_constructor() const override { return true; }
+    virtual const char* class_name() const override { return "BigIntConstructor"; }
+
+    static Value as_int_n(Interpreter&);
+    static Value as_uint_n(Interpreter&);
+};
+
+}

Libraries/LibJS/Runtime/BigIntObject.cpp

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2020, Linus Groh <mail@linusgroh.de>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <LibJS/Heap/Heap.h>
+#include <LibJS/Interpreter.h>
+#include <LibJS/Runtime/BigIntObject.h>
+#include <LibJS/Runtime/GlobalObject.h>
+
+namespace JS {
+
+BigIntObject* BigIntObject::create(GlobalObject& global_object, BigInt& bigint)
+{
+    return global_object.heap().allocate<BigIntObject>(bigint, *global_object.bigint_prototype());
+}
+
+BigIntObject::BigIntObject(BigInt& bigint, Object& prototype)
+    : Object(&prototype)
+    , m_bigint(bigint)
+{
+}
+
+BigIntObject::~BigIntObject()
+{
+}
+
+void BigIntObject::visit_children(Cell::Visitor& visitor)
+{
+    Object::visit_children(visitor);
+    visitor.visit(&m_bigint);
+}
+
+}

Libraries/LibJS/Runtime/BigIntObject.h

@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2020, Linus Groh <mail@linusgroh.de>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include <LibJS/Runtime/BigInt.h>
+#include <LibJS/Runtime/Object.h>
+
+namespace JS {
+
+class BigIntObject final : public Object {
+public:
+    static BigIntObject* create(GlobalObject&, BigInt&);
+
+    BigIntObject(BigInt&, Object& prototype);
+    virtual ~BigIntObject();
+
+    const BigInt& bigint() const { return m_bigint; }
+    virtual Value value_of() const override
+    {
+        return Value(&m_bigint);
+    }
+
+private:
+    virtual void visit_children(Visitor&) override;
+    virtual const char* class_name() const override { return "BigIntObject"; }
+    virtual bool is_bigint_object() const override { return true; }
+
+    BigInt& m_bigint;
+};
+
+}

Libraries/LibJS/Runtime/BigIntPrototype.cpp

@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2020, Linus Groh <mail@linusgroh.de>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <LibJS/Interpreter.h>
+#include <LibJS/Runtime/BigIntObject.h>
+#include <LibJS/Runtime/BigIntPrototype.h>
+#include <LibJS/Runtime/Error.h>
+#include <LibJS/Runtime/GlobalObject.h>
+
+namespace JS {
+
+BigIntPrototype::BigIntPrototype()
+    : Object(interpreter().global_object().object_prototype())
+{
+    u8 attr = Attribute::Writable | Attribute::Configurable;
+    define_native_function("toString", to_string, 0, attr);
+    define_native_function("toLocaleString", to_locale_string, 0, attr);
+    define_native_function("valueOf", value_of, 0, attr);
+}
+
+BigIntPrototype::~BigIntPrototype()
+{
+}
+
+static BigIntObject* bigint_object_from(Interpreter& interpreter)
+{
+    auto* this_object = interpreter.this_value().to_object(interpreter);
+    if (!this_object)
+        return nullptr;
+    if (!this_object->is_bigint_object()) {
+        interpreter.throw_exception<TypeError>("Not a BigInt object");
+        return nullptr;
+    }
+    return static_cast<BigIntObject*>(this_object);
+}
+
+Value BigIntPrototype::to_string(Interpreter& interpreter)
+{
+    auto* bigint_object = bigint_object_from(interpreter);
+    if (!bigint_object)
+        return {};
+    return js_string(interpreter, bigint_object->bigint().big_integer().to_base10());
+}
+
+Value BigIntPrototype::to_locale_string(Interpreter& interpreter)
+{
+    return to_string(interpreter);
+}
+
+Value BigIntPrototype::value_of(Interpreter& interpreter)
+{
+    auto* bigint_object = bigint_object_from(interpreter);
+    if (!bigint_object)
+        return {};
+    return bigint_object->value_of();
+}
+
+}

Libraries/LibJS/Runtime/BigIntPrototype.h

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020, Linus Groh <mail@linusgroh.de>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#pragma once
+
+#include <LibJS/Runtime/Object.h>
+
+namespace JS {
+
+class BigIntPrototype final : public Object {
+public:
+    BigIntPrototype();
+    virtual ~BigIntPrototype() override;
+
+private:
+    virtual const char* class_name() const override { return "BigIntPrototype"; }
+
+    static Value to_string(Interpreter&);
+    static Value to_locale_string(Interpreter&);
+    static Value value_of(Interpreter&);
+};
+
+}

Libraries/LibJS/Runtime/GlobalObject.cpp

@@ -29,6 +29,8 @@
 #include <LibJS/Interpreter.h>
 #include <LibJS/Runtime/ArrayConstructor.h>
 #include <LibJS/Runtime/ArrayPrototype.h>
+#include <LibJS/Runtime/BigIntConstructor.h>
+#include <LibJS/Runtime/BigIntPrototype.h>
 #include <LibJS/Runtime/BooleanConstructor.h>
 #include <LibJS/Runtime/BooleanPrototype.h>
 #include <LibJS/Runtime/ConsoleObject.h>
@@ -97,6 +99,7 @@ void GlobalObject::initialize()
     define_property("Reflect", heap().allocate<ReflectObject>(), attr);
 
     add_constructor("Array", m_array_constructor, *m_array_prototype);
+    add_constructor("BigInt", m_bigint_constructor, *m_bigint_prototype);
     add_constructor("Boolean", m_boolean_constructor, *m_boolean_prototype);
     add_constructor("Date", m_date_constructor, *m_date_prototype);
     add_constructor("Error", m_error_constructor, *m_error_prototype);

Libraries/LibJS/Runtime/Object.h

@@ -105,6 +105,7 @@ public:
     virtual bool is_regexp_object() const { return false; }
     virtual bool is_string_object() const { return false; }
     virtual bool is_symbol_object() const { return false; }
+    virtual bool is_bigint_object() const { return false; }
 
     virtual const char* class_name() const override { return "Object"; }
     virtual void visit_children(Cell::Visitor&) override;

Libraries/LibJS/Runtime/Value.cpp

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
+ * Copyright (c) 2020, Linus Groh <mail@linusgroh.de>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -28,10 +29,14 @@
 #include <AK/String.h>
 #include <AK/StringBuilder.h>
 #include <AK/Utf8View.h>
+#include <LibCrypto/BigInt/SignedBigInteger.h>
+#include <LibCrypto/NumberTheory/ModularFunctions.h>
 #include <LibJS/Heap/Heap.h>
 #include <LibJS/Interpreter.h>
 #include <LibJS/Runtime/Accessor.h>
 #include <LibJS/Runtime/Array.h>
+#include <LibJS/Runtime/BigInt.h>
+#include <LibJS/Runtime/BigIntObject.h>
 #include <LibJS/Runtime/BooleanObject.h>
 #include <LibJS/Runtime/Error.h>
 #include <LibJS/Runtime/Function.h>
@@ -42,10 +47,35 @@
 #include <LibJS/Runtime/Symbol.h>
 #include <LibJS/Runtime/SymbolObject.h>
 #include <LibJS/Runtime/Value.h>
+#include <ctype.h>
 #include <math.h>
 
 namespace JS {
 
+static const Crypto::SignedBigInteger BIGINT_ZERO { 0 };
+
+static bool is_valid_bigint_value(String string)
+{
+    string = string.trim_whitespace();
+    if (string.length() > 1 && (string[0] == '-' || string[0] == '+'))
+        string = string.substring_view(1, string.length() - 1);
+    for (auto& ch : string) {
+        if (!isdigit(ch))
+            return false;
+    }
+    return true;
+}
+
+ALWAYS_INLINE bool both_number(const Value& lhs, const Value& rhs)
+{
+    return lhs.is_number() && rhs.is_number();
+}
+
+ALWAYS_INLINE bool both_bigint(const Value& lhs, const Value& rhs)
+{
+    return lhs.is_bigint() && rhs.is_bigint();
+}
+
 bool Value::is_array() const
 {
     return is_object() && as_object().is_array();
@@ -83,6 +113,8 @@ String Value::to_string_without_side_effects() const
         return m_value.as_string->string();
     case Type::Symbol:
         return m_value.as_symbol->to_string();
+    case Type::BigInt:
+        return m_value.as_bigint->to_string();
     case Type::Object:
         return String::format("[object %s]", as_object().class_name());
     case Type::Accessor:
@@ -124,6 +156,8 @@ String Value::to_string(Interpreter& interpreter) const
     case Type::Symbol:
         interpreter.throw_exception<TypeError>("Can't convert symbol to string");
         return {};
+    case Type::BigInt:
+        return m_value.as_bigint->big_integer().to_base10();
     case Type::Object: {
         auto primitive_value = as_object().to_primitive(PreferredType::String);
         if (interpreter.exception())
@@ -150,6 +184,9 @@ bool Value::to_boolean() const
     case Type::String:
         return !m_value.as_string->string().is_empty();
     case Type::Symbol:
+        return true;
+    case Type::BigInt:
+        return m_value.as_bigint->big_integer() != BIGINT_ZERO;
     case Type::Object:
         return true;
     default:
@@ -179,6 +216,8 @@ Object* Value::to_object(Interpreter& interpreter) const
         return StringObject::create(interpreter.global_object(), *m_value.as_string);
     case Type::Symbol:
         return SymbolObject::create(interpreter.global_object(), *m_value.as_symbol);
+    case Type::BigInt:
+        return BigIntObject::create(interpreter.global_object(), *m_value.as_bigint);
     case Type::Object:
         return &const_cast<Object&>(as_object());
     default:
@@ -187,6 +226,16 @@ Object* Value::to_object(Interpreter& interpreter) const
     }
 }
 
+Value Value::to_numeric(Interpreter& interpreter) const
+{
+    auto primitive = to_primitive(interpreter, Value::PreferredType::Number);
+    if (interpreter.exception())
+        return {};
+    if (primitive.is_bigint())
+        return primitive;
+    return primitive.to_number(interpreter);
+}
+
 Value Value::to_number(Interpreter& interpreter) const
 {
     switch (m_type) {
@@ -215,6 +264,9 @@ Value Value::to_number(Interpreter& interpreter) const
     case Type::Symbol:
         interpreter.throw_exception<TypeError>("Can't convert symbol to number");
         return {};
+    case Type::BigInt:
+        interpreter.throw_exception<TypeError>("Can't convert BigInt to number");
+        return {};
     case Type::Object: {
         auto primitive = m_value.as_object->to_primitive(PreferredType::Number);
         if (interpreter.exception())
@@ -226,6 +278,43 @@ Value Value::to_number(Interpreter& interpreter) const
     }
 }
 
+BigInt* Value::to_bigint(Interpreter& interpreter) const
+{
+    auto primitive = to_primitive(interpreter, PreferredType::Number);
+    if (interpreter.exception())
+        return nullptr;
+    switch (primitive.type()) {
+    case Type::Undefined:
+        interpreter.throw_exception<TypeError>("Can't convert undefined to BigInt");
+        return nullptr;
+    case Type::Null:
+        interpreter.throw_exception<TypeError>("Can't convert null to BigInt");
+        return nullptr;
+    case Type::Boolean: {
+        auto value = primitive.as_bool() ? 1 : 0;
+        return js_bigint(interpreter, Crypto::SignedBigInteger { value });
+    }
+    case Type::BigInt:
+        return &primitive.as_bigint();
+    case Type::Number:
+        interpreter.throw_exception<TypeError>("Can't convert number to BigInt");
+        return {};
+    case Type::String: {
+        auto& string = primitive.as_string().string();
+        if (!is_valid_bigint_value(string)) {
+            interpreter.throw_exception<SyntaxError>(String::format("Invalid value for BigInt: %s", string.characters()));
+            return {};
+        }
+        return js_bigint(interpreter, Crypto::SignedBigInteger::from_base10(string.trim_whitespace()));
+    }
+    case Type::Symbol:
+        interpreter.throw_exception<TypeError>("Can't convert symbol to BigInt");
+        return {};
+    default:
+        ASSERT_NOT_REACHED();
+    }
+}
+
 i32 Value::as_i32() const
 {
     return static_cast<i32>(as_double());
@@ -305,55 +394,70 @@ Value less_than_equals(Interpreter& interpreter, Value lhs, Value rhs)
 
 Value bitwise_and(Interpreter& interpreter, Value lhs, Value rhs)
 {
-    auto lhs_number = lhs.to_number(interpreter);
+    auto lhs_numeric = lhs.to_numeric(interpreter);
     if (interpreter.exception())
         return {};
-    auto rhs_number = rhs.to_number(interpreter);
+    auto rhs_numeric = rhs.to_numeric(interpreter);
     if (interpreter.exception())
         return {};
-    return Value((i32)lhs_number.as_double() & (i32)rhs_number.as_double());
+    if (both_number(lhs_numeric, rhs_numeric))
+        return Value((i32)lhs_numeric.as_double() & (i32)rhs_numeric.as_double());
+    if (both_bigint(lhs_numeric, rhs_numeric))
+        return js_bigint(interpreter, lhs_numeric.as_bigint().big_integer().bitwise_and(rhs_numeric.as_bigint().big_integer()));
+    interpreter.throw_exception<TypeError>("Can't use bitwise AND operator with BigInt and other type");
+    return {};
 }
 
 Value bitwise_or(Interpreter& interpreter, Value lhs, Value rhs)
 {
-    bool lhs_invalid = lhs.is_undefined() || lhs.is_null() || lhs.is_nan() || lhs.is_infinity();
-    bool rhs_invalid = rhs.is_undefined() || rhs.is_null() || rhs.is_nan() || rhs.is_infinity();
-
-    if (lhs_invalid && rhs_invalid)
-        return Value(0);
-
-    if (lhs_invalid || rhs_invalid)
-        return lhs_invalid ? rhs.to_number(interpreter) : lhs.to_number(interpreter);
-
-    if (!rhs.is_number() && !lhs.is_number())
-        return Value(0);
-
-    auto lhs_number = lhs.to_number(interpreter);
+    auto lhs_numeric = lhs.to_numeric(interpreter);
     if (interpreter.exception())
         return {};
-    auto rhs_number = rhs.to_number(interpreter);
+    auto rhs_numeric = rhs.to_numeric(interpreter);
     if (interpreter.exception())
         return {};
-    return Value((i32)lhs_number.as_double() | (i32)rhs_number.as_double());
+    if (both_number(lhs_numeric, rhs_numeric)) {
+        if (!lhs_numeric.is_finite_number() && !rhs_numeric.is_finite_number())
+            return Value(0);
+        if (!lhs_numeric.is_finite_number())
+            return rhs_numeric;
+        if (!rhs_numeric.is_finite_number())
+            return lhs_numeric;
+        return Value((i32)lhs_numeric.as_double() | (i32)rhs_numeric.as_double());
+    }
+    if (both_bigint(lhs_numeric, rhs_numeric))
+        return js_bigint(interpreter, lhs_numeric.as_bigint().big_integer().bitwise_or(rhs_numeric.as_bigint().big_integer()));
+    interpreter.throw_exception<TypeError>("Can't use bitwise OR operator with BigInt and other type");
+    return {};
 }
 
 Value bitwise_xor(Interpreter& interpreter, Value lhs, Value rhs)
 {
-    auto lhs_number = lhs.to_number(interpreter);
+    auto lhs_numeric = lhs.to_numeric(interpreter);
     if (interpreter.exception())
         return {};
-    auto rhs_number = rhs.to_number(interpreter);
+    auto rhs_numeric = rhs.to_numeric(interpreter);
     if (interpreter.exception())
         return {};
-    return Value((i32)lhs_number.as_double() ^ (i32)rhs_number.as_double());
+    if (both_number(lhs_numeric, rhs_numeric))
+        return Value((i32)lhs_numeric.as_double() ^ (i32)rhs_numeric.as_double());
+    if (both_bigint(lhs_numeric, rhs_numeric))
+        return js_bigint(interpreter, lhs_numeric.as_bigint().big_integer().bitwise_xor(rhs_numeric.as_bigint().big_integer()));
+    interpreter.throw_exception<TypeError>("Can't use bitwise XOR operator with BigInt and other type");
+    return {};
 }
 
 Value bitwise_not(Interpreter& interpreter, Value lhs)
 {
-    auto lhs_number = lhs.to_number(interpreter);
+    auto lhs_numeric = lhs.to_numeric(interpreter);
     if (interpreter.exception())
         return {};
-    return Value(~(i32)lhs_number.as_double());
+    if (lhs_numeric.is_number())
+        return Value(~(i32)lhs_numeric.as_double());
+    auto big_integer_bitwise_not = lhs_numeric.as_bigint().big_integer();
+    big_integer_bitwise_not = big_integer_bitwise_not.plus(Crypto::SignedBigInteger { 1 });
+    big_integer_bitwise_not.negate();
+    return js_bigint(interpreter, big_integer_bitwise_not);
 }
 
 Value unary_plus(Interpreter& interpreter, Value lhs)
@@ -363,57 +467,80 @@ Value unary_plus(Interpreter& interpreter, Value lhs)
 
 Value unary_minus(Interpreter& interpreter, Value lhs)
 {
-    auto lhs_number = lhs.to_number(interpreter);
+    auto lhs_numeric = lhs.to_numeric(interpreter);
     if (interpreter.exception())
         return {};
-    if (lhs_number.is_nan())
-        return js_nan();
-    return Value(-lhs_number.as_double());
+    if (lhs_numeric.is_number()) {
+        if (lhs_numeric.is_nan())
+            return js_nan();
+        return Value(-lhs_numeric.as_double());
+    }
+    if (lhs_numeric.as_bigint().big_integer() == BIGINT_ZERO)
+        return js_bigint(interpreter, BIGINT_ZERO);
+    auto big_integer_negated = lhs_numeric.as_bigint().big_integer();
+    big_integer_negated.negate();
+    return js_bigint(interpreter, big_integer_negated);
 }
 
 Value left_shift(Interpreter& interpreter, Value lhs, Value rhs)
 {
-    auto lhs_number = lhs.to_number(interpreter);
+    auto lhs_numeric = lhs.to_numeric(interpreter);
     if (interpreter.exception())
         return {};
-    if (!lhs_number.is_finite_number())
-        return Value(0);
-    auto rhs_number = rhs.to_number(interpreter);
+    auto rhs_numeric = rhs.to_numeric(interpreter);
     if (interpreter.exception())
         return {};
-    if (!rhs_number.is_finite_number())
-        return lhs_number;
-    return Value((i32)lhs_number.as_double() << (i32)rhs_number.as_double());
+    if (both_number(lhs_numeric, rhs_numeric)) {
+        if (!lhs_numeric.is_finite_number())
+            return Value(0);
+        if (!rhs_numeric.is_finite_number())
+            return lhs_numeric;
+        return Value((i32)lhs_numeric.as_double() << (i32)rhs_numeric.as_double());
+    }
+    if (both_bigint(lhs_numeric, rhs_numeric))
+        TODO();
+    interpreter.throw_exception<TypeError>("Can't use left-shift operator with BigInt and other type");
+    return {};
 }
 
 Value right_shift(Interpreter& interpreter, Value lhs, Value rhs)
 {
-    auto lhs_number = lhs.to_number(interpreter);
+    auto lhs_numeric = lhs.to_numeric(interpreter);
     if (interpreter.exception())
         return {};
-    if (!lhs_number.is_finite_number())
-        return Value(0);
-    auto rhs_number = rhs.to_number(interpreter);
+    auto rhs_numeric = rhs.to_numeric(interpreter);
     if (interpreter.exception())
         return {};
-    if (!rhs_number.is_finite_number())
-        return lhs_number;
-    return Value((i32)lhs_number.as_double() >> (i32)rhs_number.as_double());
+    if (both_number(lhs_numeric, rhs_numeric)) {
+        if (!lhs_numeric.is_finite_number())
+            return Value(0);
+        if (!rhs_numeric.is_finite_number())
+            return lhs_numeric;
+        return Value((i32)lhs_numeric.as_double() >> (i32)rhs_numeric.as_double());
+    }
+    if (both_bigint(lhs_numeric, rhs_numeric))
+        TODO();
+    interpreter.throw_exception<TypeError>("Can't use right-shift operator with BigInt and other type");
+    return {};
 }
 
 Value unsigned_right_shift(Interpreter& interpreter, Value lhs, Value rhs)
 {
-    auto lhs_number = lhs.to_number(interpreter);
+    auto lhs_numeric = lhs.to_numeric(interpreter);
     if (interpreter.exception())
         return {};
-    if (!lhs_number.is_finite_number())
-        return Value(0);
-    auto rhs_number = rhs.to_number(interpreter);
+    auto rhs_numeric = rhs.to_numeric(interpreter);
     if (interpreter.exception())
         return {};
-    if (!rhs_number.is_finite_number())
-        return lhs_number;
-    return Value((unsigned)lhs_number.as_double() >> (i32)rhs_number.as_double());
+    if (both_number(lhs_numeric, rhs_numeric)) {
+        if (!lhs_numeric.is_finite_number())
+            return Value(0);
+        if (!rhs_numeric.is_finite_number())
+            return lhs_numeric;
+        return Value((unsigned)lhs_numeric.as_double() >> (i32)rhs_numeric.as_double());
+    }
+    interpreter.throw_exception<TypeError>("Can't use unsigned right-shift operator with BigInt");
+    return {};
 }
 
 Value add(Interpreter& interpreter, Value lhs, Value rhs)
@@ -438,73 +565,104 @@ Value add(Interpreter& interpreter, Value lhs, Value rhs)
         return js_string(interpreter, builder.to_string());
     }
 
-    auto lhs_number = lhs_primitive.to_number(interpreter);
+    auto lhs_numeric = lhs_primitive.to_numeric(interpreter);
     if (interpreter.exception())
         return {};
-    auto rhs_number = rhs_primitive.to_number(interpreter);
+    auto rhs_numeric = rhs_primitive.to_numeric(interpreter);
     if (interpreter.exception())
         return {};
-    return Value(lhs_number.as_double() + rhs_number.as_double());
+    if (both_number(lhs_numeric, rhs_numeric))
+        return Value(lhs_numeric.as_double() + rhs_numeric.as_double());
+    if (both_bigint(lhs_numeric, rhs_numeric))
+        return js_bigint(interpreter, lhs_numeric.as_bigint().big_integer().plus(rhs_numeric.as_bigint().big_integer()));
+    interpreter.throw_exception<TypeError>("Can't use addition operator with BigInt and other type");
+    return {};
 }
 
 Value sub(Interpreter& interpreter, Value lhs, Value rhs)
 {
-    auto lhs_number = lhs.to_number(interpreter);
+    auto lhs_numeric = lhs.to_numeric(interpreter);
     if (interpreter.exception())
         return {};
-    auto rhs_number = rhs.to_number(interpreter);
+    auto rhs_numeric = rhs.to_numeric(interpreter);
     if (interpreter.exception())
         return {};
-    return Value(lhs_number.as_double() - rhs_number.as_double());
+    if (both_number(lhs_numeric, rhs_numeric))
+        return Value(lhs_numeric.as_double() - rhs_numeric.as_double());
+    if (both_bigint(lhs_numeric, rhs_numeric))
+        return js_bigint(interpreter, lhs_numeric.as_bigint().big_integer().minus(rhs_numeric.as_bigint().big_integer()));
+    interpreter.throw_exception<TypeError>("Can't use subtraction operator with BigInt and other type");
+    return {};
 }
 
 Value mul(Interpreter& interpreter, Value lhs, Value rhs)
 {
-    auto lhs_number = lhs.to_number(interpreter);
+    auto lhs_numeric = lhs.to_numeric(interpreter);
     if (interpreter.exception())
         return {};
-    auto rhs_number = rhs.to_number(interpreter);
+    auto rhs_numeric = rhs.to_numeric(interpreter);
     if (interpreter.exception())
         return {};
-    return Value(lhs_number.as_double() * rhs_number.as_double());
+    if (both_number(lhs_numeric, rhs_numeric))
+        return Value(lhs_numeric.as_double() * rhs_numeric.as_double());
+    if (both_bigint(lhs_numeric, rhs_numeric))
+        return js_bigint(interpreter, lhs_numeric.as_bigint().big_integer().multiplied_by(rhs_numeric.as_bigint().big_integer()));
+    interpreter.throw_exception<TypeError>("Can't use multiplication operator with BigInt and other type");
+    return {};
 }
 
 Value div(Interpreter& interpreter, Value lhs, Value rhs)
 {
-    auto lhs_number = lhs.to_number(interpreter);
+    auto lhs_numeric = lhs.to_numeric(interpreter);
     if (interpreter.exception())
         return {};
-    auto rhs_number = rhs.to_number(interpreter);
+    auto rhs_numeric = rhs.to_numeric(interpreter);
     if (interpreter.exception())
         return {};
-    return Value(lhs_number.as_double() / rhs_number.as_double());
+    if (both_number(lhs_numeric, rhs_numeric))
+        return Value(lhs_numeric.as_double() / rhs_numeric.as_double());
+    if (both_bigint(lhs_numeric, rhs_numeric))
+        return js_bigint(interpreter, lhs_numeric.as_bigint().big_integer().divided_by(rhs_numeric.as_bigint().big_integer()).quotient);
+    interpreter.throw_exception<TypeError>("Can't use division operator with BigInt and other type");
+    return {};
 }
 
 Value mod(Interpreter& interpreter, Value lhs, Value rhs)
 {
-    auto lhs_number = lhs.to_number(interpreter);
+    auto lhs_numeric = lhs.to_numeric(interpreter);
     if (interpreter.exception())
         return {};
-    auto rhs_number = rhs.to_number(interpreter);
+    auto rhs_numeric = rhs.to_numeric(interpreter);
     if (interpreter.exception())
         return {};
-    if (lhs_number.is_nan() || rhs_number.is_nan())
-        return js_nan();
-    auto index = lhs_number.as_double();
-    auto period = rhs_number.as_double();
-    auto trunc = (double)(i32)(index / period);
-    return Value(index - trunc * period);
+    if (both_number(lhs_numeric, rhs_numeric)) {
+        if (lhs_numeric.is_nan() || rhs_numeric.is_nan())
+            return js_nan();
+        auto index = lhs_numeric.as_double();
+        auto period = rhs_numeric.as_double();
+        auto trunc = (double)(i32)(index / period);
+        return Value(index - trunc * period);
+    }
+    if (both_bigint(lhs_numeric, rhs_numeric))
+        return js_bigint(interpreter, lhs_numeric.as_bigint().big_integer().divided_by(rhs_numeric.as_bigint().big_integer()).remainder);
+    interpreter.throw_exception<TypeError>("Can't use modulo operator with BigInt and other type");
+    return {};
 }
 
 Value exp(Interpreter& interpreter, Value lhs, Value rhs)
 {
-    auto lhs_number = lhs.to_number(interpreter);
+    auto lhs_numeric = lhs.to_numeric(interpreter);
     if (interpreter.exception())
         return {};
-    auto rhs_number = rhs.to_number(interpreter);
+    auto rhs_numeric = rhs.to_numeric(interpreter);
     if (interpreter.exception())
         return {};
-    return Value(pow(lhs_number.as_double(), rhs_number.as_double()));
+    if (both_number(lhs_numeric, rhs_numeric))
+        return Value(pow(lhs_numeric.as_double(), rhs_numeric.as_double()));
+    if (both_bigint(lhs_numeric, rhs_numeric))
+        return js_bigint(interpreter, Crypto::NumberTheory::Power(lhs_numeric.as_bigint().big_integer(), rhs_numeric.as_bigint().big_integer()));
+    interpreter.throw_exception<TypeError>("Can't use exponentiation operator with BigInt and other type");
+    return {};
 }
 
 Value in(Interpreter& interpreter, Value lhs, Value rhs)
@@ -547,6 +705,14 @@ bool same_value(Interpreter& interpreter, Value lhs, Value rhs)
         return lhs.as_double() == rhs.as_double();
     }
 
+    if (lhs.is_bigint()) {
+        auto lhs_big_integer = lhs.as_bigint().big_integer();
+        auto rhs_big_integer = rhs.as_bigint().big_integer();
+        if (lhs_big_integer == BIGINT_ZERO && rhs_big_integer == BIGINT_ZERO && lhs_big_integer.is_negative() != rhs_big_integer.is_negative())
+            return false;
+        return lhs_big_integer == rhs_big_integer;
+    }
+
     return same_value_non_numeric(interpreter, lhs, rhs);
 }
 
@@ -558,17 +724,18 @@ bool same_value_zero(Interpreter& interpreter, Value lhs, Value rhs)
     if (lhs.is_number()) {
         if (lhs.is_nan() && rhs.is_nan())
             return true;
-        if ((lhs.is_positive_zero() || lhs.is_negative_zero()) && (rhs.is_positive_zero() || rhs.is_negative_zero()))
-            return true;
         return lhs.as_double() == rhs.as_double();
     }
 
+    if (lhs.is_bigint())
+        return lhs.as_bigint().big_integer() == rhs.as_bigint().big_integer();
+
     return same_value_non_numeric(interpreter, lhs, rhs);
 }
 
 bool same_value_non_numeric(Interpreter&, Value lhs, Value rhs)
 {
-    ASSERT(!lhs.is_number());
+    ASSERT(!lhs.is_number() && !lhs.is_bigint());
     ASSERT(lhs.type() == rhs.type());
 
     switch (lhs.type()) {
@@ -598,11 +765,12 @@ bool strict_eq(Interpreter& interpreter, Value lhs, Value rhs)
             return false;
         if (lhs.as_double() == rhs.as_double())
             return true;
-        if ((lhs.is_positive_zero() || lhs.is_negative_zero()) && (rhs.is_positive_zero() || rhs.is_negative_zero()))
-            return true;
         return false;
     }
 
+    if (lhs.is_bigint())
+        return lhs.as_bigint().big_integer() == rhs.as_bigint().big_integer();
+
     return same_value_non_numeric(interpreter, lhs, rhs);
 }
 
@@ -620,25 +788,46 @@ bool abstract_eq(Interpreter& interpreter, Value lhs, Value rhs)
     if (lhs.is_string() && rhs.is_number())
         return abstract_eq(interpreter, lhs.to_number(interpreter), rhs);
 
+    if (lhs.is_bigint() && rhs.is_string()) {
+        auto& rhs_string = rhs.as_string().string();
+        if (!is_valid_bigint_value(rhs_string))
+            return false;
+        return abstract_eq(interpreter, lhs, js_bigint(interpreter, Crypto::SignedBigInteger::from_base10(rhs_string)));
+    }
+
+    if (lhs.is_string() && rhs.is_bigint())
+        return abstract_eq(interpreter, rhs, lhs);
+
     if (lhs.is_boolean())
         return abstract_eq(interpreter, lhs.to_number(interpreter), rhs);
 
     if (rhs.is_boolean())
         return abstract_eq(interpreter, lhs, rhs.to_number(interpreter));
 
-    if ((lhs.is_string() || lhs.is_number() || lhs.is_symbol()) && rhs.is_object())
+    if ((lhs.is_string() || lhs.is_number() || lhs.is_bigint() || lhs.is_symbol()) && rhs.is_object())
         return abstract_eq(interpreter, lhs, rhs.to_primitive(interpreter));
 
-    if (lhs.is_object() && (rhs.is_string() || rhs.is_number() || rhs.is_symbol()))
+    if (lhs.is_object() && (rhs.is_string() || rhs.is_number() || lhs.is_bigint() || rhs.is_symbol()))
         return abstract_eq(interpreter, lhs.to_primitive(interpreter), rhs);
 
+    if ((lhs.is_bigint() && rhs.is_number()) || (lhs.is_number() && rhs.is_bigint())) {
+        if (lhs.is_nan() || lhs.is_infinity() || rhs.is_nan() || rhs.is_infinity())
+            return false;
+        if ((lhs.is_number() && !lhs.is_integer()) || (rhs.is_number() && !rhs.is_integer()))
+            return false;
+        if (lhs.is_number())
+            return Crypto::SignedBigInteger { lhs.as_i32() } == rhs.as_bigint().big_integer();
+        else
+            return Crypto::SignedBigInteger { rhs.as_i32() } == lhs.as_bigint().big_integer();
+    }
+
     return false;
 }
 
 TriState abstract_relation(Interpreter& interpreter, bool left_first, Value lhs, Value rhs)
 {
-    Value x_primitive = {};
-    Value y_primitive = {};
+    Value x_primitive;
+    Value y_primitive;
 
     if (left_first) {
         x_primitive = lhs.to_primitive(interpreter, Value::PreferredType::Number);
@@ -681,12 +870,30 @@ TriState abstract_relation(Interpreter& interpreter, bool left_first, Value lhs,
         ASSERT_NOT_REACHED();
     }
 
-    // FIXME add BigInt cases here once we have BigInt
+    if (x_primitive.is_bigint() && y_primitive.is_string()) {
+        auto& y_string = y_primitive.as_string().string();
+        if (!is_valid_bigint_value(y_string))
+            return TriState::Unknown;
+        if (x_primitive.as_bigint().big_integer() < Crypto::SignedBigInteger::from_base10(y_string))
+            return TriState::True;
+        else
+            return TriState::False;
+    }
 
-    auto x_numeric = x_primitive.to_number(interpreter);
+    if (x_primitive.is_string() && y_primitive.is_bigint()) {
+        auto& x_string = x_primitive.as_string().string();
+        if (!is_valid_bigint_value(x_string))
+            return TriState::Unknown;
+        if (Crypto::SignedBigInteger::from_base10(x_string) < y_primitive.as_bigint().big_integer())
+            return TriState::True;
+        else
+            return TriState::False;
+    }
+
+    auto x_numeric = x_primitive.to_numeric(interpreter);
     if (interpreter.exception())
         return {};
-    auto y_numeric = y_primitive.to_number(interpreter);
+    auto y_numeric = y_primitive.to_numeric(interpreter);
     if (interpreter.exception())
         return {};
 
@@ -699,10 +906,33 @@ TriState abstract_relation(Interpreter& interpreter, bool left_first, Value lhs,
     if (x_numeric.is_negative_infinity() || y_numeric.is_positive_infinity())
         return TriState::True;
 
-    auto x_value = x_numeric.as_double();
-    auto y_value = y_numeric.as_double();
+    if (x_numeric.is_number() && y_numeric.is_number()) {
+        if (x_numeric.as_double() < y_numeric.as_double())
+            return TriState::True;
+        else
+            return TriState::False;
+    }
 
-    if (x_value < y_value)
+    if (x_numeric.is_bigint() && y_numeric.is_bigint()) {
+        if (x_numeric.as_bigint().big_integer() < y_numeric.as_bigint().big_integer())
+            return TriState::True;
+        else
+            return TriState::False;
+    }
+
+    ASSERT((x_numeric.is_number() && y_numeric.is_bigint()) || (x_numeric.is_bigint() && y_numeric.is_number()));
+
+    bool x_lower_than_y;
+    if (x_numeric.is_number()) {
+        x_lower_than_y = x_numeric.is_integer()
+            ? Crypto::SignedBigInteger { x_numeric.as_i32() } < y_numeric.as_bigint().big_integer()
+            : (Crypto::SignedBigInteger { x_numeric.as_i32() } < y_numeric.as_bigint().big_integer() || Crypto::SignedBigInteger { x_numeric.as_i32() + 1 } < y_numeric.as_bigint().big_integer());
+    } else {
+        x_lower_than_y = y_numeric.is_integer()
+            ? x_numeric.as_bigint().big_integer() < Crypto::SignedBigInteger { y_numeric.as_i32() }
+            : (x_numeric.as_bigint().big_integer() < Crypto::SignedBigInteger { y_numeric.as_i32() } || x_numeric.as_bigint().big_integer() < Crypto::SignedBigInteger { y_numeric.as_i32() + 1 });
+    }
+    if (x_lower_than_y)
         return TriState::True;
     else
         return TriState::False;

Libraries/LibJS/Runtime/Value.h

@@ -31,7 +31,6 @@
 #include <AK/LogStream.h>
 #include <AK/Types.h>
 #include <LibJS/Forward.h>
-#include <LibJS/Runtime/Symbol.h>
 #include <math.h>
 
 // 2 ** 53 - 1
@@ -51,6 +50,7 @@ public:
         Boolean,
         Symbol,
         Accessor,
+        BigInt,
     };
 
     enum class PreferredType {
@@ -68,6 +68,7 @@ public:
     bool is_boolean() const { return m_type == Type::Boolean; }
     bool is_symbol() const { return m_type == Type::Symbol; }
     bool is_accessor() const { return m_type == Type::Accessor; };
+    bool is_bigint() const { return m_type == Type::BigInt; };
     bool is_cell() const { return is_string() || is_accessor() || is_object(); }
     bool is_array() const;
     bool is_function() const;
@@ -140,6 +141,12 @@ public:
         m_value.as_accessor = accessor;
     }
 
+    Value(BigInt* bigint)
+        : m_type(Type::BigInt)
+    {
+        m_value.as_bigint = bigint;
+    }
+
     explicit Value(Type type)
         : m_type(type)
     {
@@ -207,6 +214,12 @@ public:
         return *m_value.as_accessor;
     }
 
+    BigInt& as_bigint()
+    {
+        ASSERT(is_bigint());
+        return *m_value.as_bigint;
+    }
+
     Function& as_function();
 
     i32 as_i32() const;
@@ -216,7 +229,9 @@ public:
     PrimitiveString* to_primitive_string(Interpreter&);
     Value to_primitive(Interpreter&, PreferredType preferred_type = PreferredType::Default) const;
     Object* to_object(Interpreter&) const;
+    Value to_numeric(Interpreter&) const;
     Value to_number(Interpreter&) const;
+    BigInt* to_bigint(Interpreter&) const;
     double to_double(Interpreter&) const;
     i32 to_i32(Interpreter&) const;
     size_t to_size_t(Interpreter&) const;
@@ -242,6 +257,7 @@ private:
         Object* as_object;
         Cell* as_cell;
         Accessor* as_accessor;
+        BigInt* as_bigint;
     } m_value;
 };
 

Libraries/LibJS/Tests/BigInt.asIntN.js

@@ -0,0 +1,9 @@
+load("test-common.js");
+
+try {
+    assert(BigInt.asIntN.length === 2);
+
+    console.log("PASS");
+} catch (e) {
+    console.log("FAIL: " + e);
+}

Libraries/LibJS/Tests/BigInt.asUintN.js

@@ -0,0 +1,9 @@
+load("test-common.js");
+
+try {
+    assert(BigInt.asUintN.length === 2);
+
+    console.log("PASS");
+} catch (e) {
+    console.log("FAIL: " + e);
+}

Libraries/LibJS/Tests/BigInt.js

@@ -0,0 +1,62 @@
+load("test-common.js");
+
+try {
+    assert(BigInt.length === 1);
+    assert(BigInt.name === "BigInt");
+
+    assert(BigInt(0) === 0n);
+    assert(BigInt(1) === 1n);
+    assert(BigInt(+1) === 1n);
+    assert(BigInt(-1) === -1n);
+    assert(BigInt("") === 0n);
+    assert(BigInt("0") === 0n);
+    assert(BigInt("1") === 1n);
+    assert(BigInt("+1") === 1n);
+    assert(BigInt("-1") === -1n);
+    assert(BigInt("-1") === -1n);
+    assert(BigInt([]) === 0n);
+    assert(BigInt("42") === 42n);
+    assert(BigInt("  \n  00100  \n  ") === 100n);
+    assert(BigInt(123n) === 123n);
+    assert(BigInt("3323214327642987348732109829832143298746432437532197321") === 3323214327642987348732109829832143298746432437532197321n);
+
+    assertThrowsError(() => {
+        new BigInt();
+    }, {
+        error: TypeError,
+        message: "BigInt is not a constructor"
+    });
+
+    [null, undefined, Symbol()].forEach(value => {
+        assertThrowsError(() => {
+            BigInt(value);
+        }, {
+            error: TypeError,
+            message: typeof value === "symbol"
+                ? "Can't convert symbol to BigInt"
+                : `Can't convert ${value} to BigInt`
+        });
+    });
+
+    ["foo", "123n", "1+1", {}, function () { }].forEach(value => {
+        assertThrowsError(() => {
+            BigInt(value);
+        }, {
+            error: SyntaxError,
+            message: `Invalid value for BigInt: ${value}`
+        });
+    });
+
+    [1.23, Infinity, -Infinity, NaN].forEach(value => {
+        assertThrowsError(() => {
+            BigInt(value);
+        }, {
+            error: RangeError,
+            message: "BigInt argument must be an integer"
+        });
+    });
+
+    console.log("PASS");
+} catch (e) {
+    console.log("FAIL: " + e);
+}

Libraries/LibJS/Tests/BigInt.prototype.toLocaleString.js

@@ -0,0 +1,18 @@
+load("test-common.js");
+
+try {
+    assert(BigInt.prototype.toLocaleString.length === 0);
+
+    assertThrowsError(() => {
+        BigInt.prototype.toLocaleString.call("foo");
+    }, {
+        error: TypeError,
+        message: "Not a BigInt object"
+    });
+    
+    assert(BigInt(123).toLocaleString() === "123");
+
+    console.log("PASS");
+} catch (e) {
+    console.log("FAIL: " + e);
+}

Libraries/LibJS/Tests/BigInt.prototype.toString.js

@@ -0,0 +1,18 @@
+load("test-common.js");
+
+try {
+    assert(BigInt.prototype.toString.length === 0);
+
+    assertThrowsError(() => {
+        BigInt.prototype.toString.call("foo");
+    }, {
+        error: TypeError,
+        message: "Not a BigInt object"
+    });
+    
+    assert(BigInt(123).toString() === "123");
+
+    console.log("PASS");
+} catch (e) {
+    console.log("FAIL: " + e);
+}

Libraries/LibJS/Tests/BigInt.prototype.valueOf.js

@@ -0,0 +1,20 @@
+load("test-common.js");
+
+try {
+    assert(BigInt.prototype.valueOf.length === 0);
+
+    assertThrowsError(() => {
+        BigInt.prototype.valueOf.call("foo");
+    }, {
+        error: TypeError,
+        message: "Not a BigInt object"
+    });
+
+    assert(typeof BigInt(123).valueOf() === "bigint");
+    // FIXME: Uncomment once we support Object() with argument
+    // assert(typeof Object(123n).valueOf() === "bigint");
+
+    console.log("PASS");
+} catch (e) {
+    console.log("FAIL: " + e);
+}

Libraries/LibJS/Tests/bigint-basic.js

@@ -0,0 +1,68 @@
+load("test-common.js");
+
+try {
+    var bigint = 123n;
+
+    assert(typeof bigint === "bigint");
+    assert(-bigint === -123n);
+    assert("" + bigint === "123")
+
+    assertThrowsError(() => {
+        +bigint;
+    }, {
+        error: TypeError,
+        message: "Can't convert BigInt to number"
+    });
+
+    assert(12n + 34n === 46n);
+    assert(12n - 34n === -22n);
+    assert(8n * 12n === 96n);
+    assert(123n / 10n === 12n);
+    assert(2n ** 3n === 8n);
+    assert(5n % 3n === 2n);
+    assert(45977665298704210987n + 714320987142450987412098743217984576n / 4598741987421098765327980n * 987498743n === 199365500239020623962n);
+
+    assert((12n & 5n) === 4n);
+    assert((1n | 2n) === 3n);
+    assert((5n ^ 3n) === 6n);
+    assert(~1n === -2n);
+
+    bigint = 1n;
+    assert(bigint++ === 1n);
+    assert(bigint === 2n);
+    assert(bigint-- === 2n);
+    assert(bigint === 1n);
+    assert(++bigint === 2n);
+    assert(bigint === 2n);
+    assert(--bigint === 1n);
+    assert(bigint === 1n);
+
+
+    assert((1n == 1n) === true);
+    assert((1n == 1) === true);
+    assert((1 == 1n) === true);
+    assert((1n == 1.23) === false);
+    assert((1.23 == 1n) === false);
+
+    assert((1n != 1n) === false);
+    assert((1n != 1) === false);
+    assert((1 != 1n) === false);
+    assert((1n != 1.23) === true);
+    assert((1.23 != 1n) === true);
+
+    assert((1n === 1n) === true);
+    assert((1n === 1) == false);
+    assert((1 === 1n) === false);
+    assert((1n === 1.23) === false);
+    assert((1.23 === 1n) === false);
+
+    assert((1n !== 1n) === false);
+    assert((1n !== 1) === true);
+    assert((1 !== 1n) === true);
+    assert((1n !== 1.23) === true);
+    assert((1.23 !== 1n) === true);
+
+    console.log("PASS");
+} catch (e) {
+    console.log("FAIL: " + e);
+}

Libraries/LibJS/Tests/bigint-number-mix-errors.js

@@ -0,0 +1,82 @@
+load("test-common.js");
+
+try {
+    [1, null, undefined].forEach(value => {
+        assertThrowsError(() => {
+            1n + value;
+        }, {
+            error: TypeError,
+            message: "Can't use addition operator with BigInt and other type"
+        });
+        assertThrowsError(() => {
+            1n - value;
+        }, {
+            error: TypeError,
+            message: "Can't use subtraction operator with BigInt and other type"
+        });
+        assertThrowsError(() => {
+            1n * value;
+        }, {
+            error: TypeError,
+            message: "Can't use multiplication operator with BigInt and other type"
+        });
+        assertThrowsError(() => {
+            1n / value;
+        }, {
+            error: TypeError,
+            message: "Can't use division operator with BigInt and other type"
+        });
+        assertThrowsError(() => {
+            1n % value;
+        }, {
+            error: TypeError,
+            message: "Can't use modulo operator with BigInt and other type"
+        });
+        assertThrowsError(() => {
+            1n ** value;
+        }, {
+            error: TypeError,
+            message: "Can't use exponentiation operator with BigInt and other type"
+        });
+        assertThrowsError(() => {
+            1n | value;
+        }, {
+            error: TypeError,
+            message: "Can't use bitwise OR operator with BigInt and other type"
+        });
+        assertThrowsError(() => {
+            1n & value;
+        }, {
+            error: TypeError,
+            message: "Can't use bitwise AND operator with BigInt and other type"
+        });
+        assertThrowsError(() => {
+            1n ^ value;
+        }, {
+            error: TypeError,
+            message: "Can't use bitwise XOR operator with BigInt and other type"
+        });
+        assertThrowsError(() => {
+            1n << value;
+        }, {
+            error: TypeError,
+            message: "Can't use left-shift operator with BigInt and other type"
+        });
+        assertThrowsError(() => {
+            1n >> value;
+        }, {
+            error: TypeError,
+            message: "Can't use right-shift operator with BigInt and other type"
+        });
+        assertThrowsError(() => {
+            1n >>> value;
+        }, {
+            error: TypeError,
+            message: "Can't use unsigned right-shift operator with BigInt"
+        });
+    });
+
+    console.log("PASS");
+} catch (e) {
+    console.log("FAIL: " + e);
+}

Libraries/LibJS/Tests/object-basic.js

@@ -15,6 +15,7 @@ try {
         duplicate: "world"
     };
     assert(o[1] === 23);
+    assert(o[1n] === 23);
     assert(o["1"] === 23);
     assert(o.foo === "bar");
     assert(o["foo"] === "bar");
@@ -30,6 +31,9 @@ try {
     o[10] = "123";
     assert(o[10] === "123");
     assert(o["10"] === "123");
+    o[10n] = "123";
+    assert(o[10] === "123");
+    assert(o["10"] === "123");
     o[-1] = "hello friends";
     assert(o[-1] === "hello friends");
     assert(o["-1"] === "hello friends");

Libraries/LibJS/Token.h

@@ -40,6 +40,7 @@ namespace JS {
     __ENUMERATE_JS_TOKEN(AsteriskEquals)              \
     __ENUMERATE_JS_TOKEN(Async)                       \
     __ENUMERATE_JS_TOKEN(Await)                       \
+    __ENUMERATE_JS_TOKEN(BigIntLiteral)               \
     __ENUMERATE_JS_TOKEN(BoolLiteral)                 \
     __ENUMERATE_JS_TOKEN(BracketClose)                \
     __ENUMERATE_JS_TOKEN(BracketOpen)                 \

Userland/js.cpp

@@ -266,7 +266,7 @@ void print_value(JS::Value value, HashTable<JS::Object*>& seen_objects)
 
     if (value.is_string())
         printf("\033[32;1m");
-    else if (value.is_number())
+    else if (value.is_number() || value.is_bigint())
         printf("\033[35;1m");
     else if (value.is_boolean())
         printf("\033[33;1m");
@@ -620,6 +620,7 @@ int main(int argc, char** argv)
                     stylize({ start, end }, { Line::Style::Foreground(Line::Style::XtermColor::Red), Line::Style::Underline });
                     break;
                 case JS::TokenType::NumericLiteral:
+                case JS::TokenType::BigIntLiteral:
                     stylize({ start, end }, { Line::Style::Foreground(Line::Style::XtermColor::Magenta) });
                     break;
                 case JS::TokenType::StringLiteral: