twostroke 0.0.4 → 0.1.0

data/lib/twostroke/parser.rb

@@ -56,8 +56,10 @@ module Twostroke
       st = case peek_token.type
       when :RETURN;     send :return
       when :BREAK;      send :break
+      when :CONTINUE;   continue
       when :THROW;      send :throw
       when :VAR;        var
+      when :WITH;       consume_semicolon = false; with
       when :IF;         consume_semicolon = false; send :if
       when :FOR;        consume_semicolon = false; send :for
       when :SWITCH;     consume_semicolon = false; send :switch
@@ -101,7 +103,7 @@ module Twostroke
         expr = binop expr
         # this has a higher precedence than the ternary
         # so we'll hackily check for a ternary after this
-        if try_peek_token && peek_token(false).type == :QUESTION
+        if !no_ternary && try_peek_token && peek_token(false).type == :QUESTION
           ternary(expr)
         else
           expr
@@ -134,6 +136,8 @@ module Twostroke
       when :REGEXP; regexp
       when :THIS; this
       when :NULL; null
+      when :TRUE; send :true
+      when :FALSE; send :false
       when :NEW; send :new
       when :DELETE; delete
       when :BAREWORD; bareword
@@ -195,6 +199,16 @@ module Twostroke
       AST::Null.new
     end
     
+    def true
+      assert_type next_token, :TRUE
+      AST::True.new
+    end
+    
+    def false
+      assert_type next_token, :FALSE
+      AST::False.new
+    end
+    
     def bareword
       assert_type next_token, :BAREWORD
       AST::Variable.new name: token.val
@@ -209,6 +223,15 @@ module Twostroke
       ternary
     end
     
+    def with
+      assert_type next_token, :WITH
+      assert_type next_token, :OPEN_PAREN
+      with = AST::With.new object: expression
+      assert_type next_token, :CLOSE_PAREN
+      with.statement = statement
+      with
+    end
+    
     def if
       assert_type next_token, :IF
       assert_type next_token, :OPEN_PAREN
@@ -268,16 +291,26 @@ module Twostroke
       assert_type next_token, :CLOSE_PAREN
       assert_type next_token, :OPEN_BRACE
       current_case = nil
+      default = false
       while ![:CLOSE_BRACE].include? peek_token.type
         if peek_token.type == :CASE
           assert_type next_token, :CASE
           expr = expression
-          current_case = AST::Case.new expression: expr
+          node = AST::Case.new expression: expr
+          assert_type next_token, :COLON
+          sw.cases << node
+          current_case = node.statements
+        elsif peek_token.type == :DEFAULT
+          assert_type next_token, :DEFAULT
+          error! "only one default case allowed" if default
+          default = true
+          node = AST::Case.new
           assert_type next_token, :COLON
-          sw.cases << current_case
+          sw.cases << node
+          current_case = node.statements
         else
           error! "statements may only appear under a case" if current_case.nil?
-          current_case.statements << statement
+          current_case << statement
         end
       end
       assert_type next_token, :CLOSE_BRACE
@@ -340,11 +373,11 @@ module Twostroke
       assert_type next_token, :MEMBER_ACCESS
       assert_type next_token, :BAREWORD
       access = AST::MemberAccess.new object: obj, member: token.val
-      if peek_token.type == :MEMBER_ACCESS
+      if peek_token(false).type == :MEMBER_ACCESS
         member_access access
-      elsif peek_token.type == :OPEN_PAREN
+      elsif peek_token(false).type == :OPEN_PAREN
         call access
-      elsif peek_token.type == :EQUALS
+      elsif peek_token(false).type == :EQUALS
         assignment access
       else
         access
@@ -354,7 +387,7 @@ module Twostroke
     def new
       assert_type next_token, :NEW
       node = AST::New.new
-      node.callee = expression_after_unary(false, true)
+      node.callee = expression_after_unary(true, true)
       if try_peek_token && peek_token.type == :OPEN_PAREN
         call = call(node.callee)
         node.arguments = call.arguments
@@ -394,6 +427,11 @@ module Twostroke
       AST::Break.new
     end
     
+    def continue
+      assert_type next_token, :CONTINUE
+      AST::Continue.new
+    end
+    
     def throw
       assert_type next_token, :THROW
       AST::Throw.new expression: expression
@@ -489,7 +527,7 @@ module Twostroke
     
     def parens
       assert_type next_token, :OPEN_PAREN
-      expr = expression
+      expr = AST::BracketedExpression.new value: expression
       assert_type next_token, :CLOSE_PAREN
       expr
     end

data/lib/twostroke/runtime/lib/array.js

@@ -0,0 +1,144 @@
+Array.prototype.forEach = function(callback, thisObj) {
+	if(this == null) {
+		throw new TypeError("this is null or undefined");
+	}
+	var obj = Object(this);
+	thisObj = thisObj || this;
+	for(var i = 0; i < obj.length; i++) {
+		if(i in this) {
+			callback.call(thisObj, obj[i], i, obj);
+		}
+	}
+};
+
+Array.prototype.reverse = function() {
+	for(var i = 0; i < this.length / 2; i++) {
+		var j = this.length - 1 - i;
+		var tmp = this[i];
+		this[i] = this[j];
+		this[j] = tmp;
+	}
+	return this;
+};
+
+Array.prototype.concat = function(other) {
+	var x = [];
+	Array.prototype.slice.call(this).forEach(function(el) {
+		x.push(el);
+	});
+	Array.prototype.slice.call(other).forEach(function(el) {
+		x.push(el);
+	});
+	return x;
+};
+
+Array.prototype.join = function(delim) {
+	delim = delim.toString();
+	var str = "";
+	this.forEach(function(el, i) {
+		if(i > 0) {
+			str += delim;
+		}
+		str += el.toString();	
+	});
+	return str;
+};
+
+Array.prototype.indexOf = function(el, from) {
+	from = Number(from || 0);
+	if(from < 0) {
+		from += this.length;
+	}
+	for(var i = from; i < this.length; i++) {
+		if(this[i] === el) {
+			return i;
+		}
+	}
+	return -1;
+};
+
+Array.prototype.lastIndexOf = function(el, from) {
+	from = Number(from || this.length);
+	if(from < 0) {
+		from += this.length;
+	}
+	for(var i = from - 1; i >= 0; i--) {
+		if(this[i] === el) {
+			return i;
+		}
+	}
+	return -1;
+};
+
+Array.prototype.filter = function(callback, thisObj) {
+	var x = [];
+	this.forEach(function(el, i, obj) {
+		if(callback.call(this, el, i, obj)) {
+			x.push(el);
+		}
+	}, thisObj);
+	return x;
+};
+
+Array.prototype.every = function(callback, thisObj) {
+	for(var i = 0; i < this.length; i++) {
+		if(i in this) {
+			if(!callback.call(thisObj, this[i], i, this)) {
+				return false;
+			}
+		}
+	}
+	return true;
+};
+
+Array.prototype.map = function(callback, thisObj) {
+	var x = [];
+	this.forEach(function(el, i, obj) {
+		x.push(callback.call(this, el, i, obj));
+	}, thisObj);
+	return x;
+};
+
+Array.prototype.some = function(callback, thisObj) {
+	for(var i = 0; i < this.length; i++) {
+		if(i in this) {
+			if(callback.call(thisObj, this[i], i, this)) {
+				return true;
+			}
+		}
+	}
+	return false;
+};
+
+Array.prototype.reduce = function(callback, accumulator) {
+	var i = 0;
+	if(accumulator === undefined) {
+		if(!this.length) {
+			throw new TypeError("Reduce of empty array with no initial value");
+		}
+		while(i < this.length && !(i in this)) i++;
+		accumulator = this[i++];
+	}
+	for(; i < this.length; i++) {
+		if(i in this) {
+			accumulator = callback(accumulator, this[i], i, this);
+		}
+	}
+	return accumulator;
+};
+
+Array.prototype.reduceRight = function(callback, accumulator) {
+	var i = this.length - 1;
+	if(accumulator === undefined) {
+		if(!this.length) {
+			throw new TypeError("Reduce of empty array with no initial value");
+		}
+		accumulator = this[i--];
+	}
+	for(; i >= 0; i--) {
+		if(i in this) {
+			accumulator = callback(accumulator, this[i], i, this);
+		}
+	}
+	return accumulator;
+};

data/lib/twostroke/runtime/lib/array.rb

@@ -0,0 +1,71 @@
+module Twostroke::Runtime
+  Lib.register do |scope|
+    ary = Types::Array.constructor_function
+    scope.set_var "Array", ary
+    
+    proto = Types::Object.new
+    # Array.prototype.toString
+    proto.proto_put "toString", Types::Function.new(->(scope, this, args) do
+        Lib.throw_type_error "Array.prototype.toString is not generic" unless this.is_a?(Types::Array)
+        Types::String.new this.items.map { |o| 
+            if o.nil? || o.is_a?(Types::Undefined) || o.is_a?(Types::Null)
+              ""
+            else
+              Types.to_string(o).string
+            end
+          }.join(",")
+      end, nil, "toString", [])
+    # Array.prototype.valueOf
+    proto.proto_put "valueOf", Types::Function.new(->(scope, this, args) { this }, nil, "valueOf", [])
+    # Array.prototype.pop
+    proto.proto_put "pop", Types::Function.new(->(scope, this, args) {
+      Lib.throw_type_error "Array.prototype.pop is not generic" unless this.is_a? Types::Array
+      this.items.pop || Types::Undefined.new
+    }, nil, "pop", [])
+    # Array.prototype.shift
+    proto.proto_put "shift", Types::Function.new(->(scope, this, args) {
+      Lib.throw_type_error "Array.prototype.shift is not generic" unless this.is_a? Types::Array
+      this.items.shift || Types::Undefined.new
+    }, nil, "shift", [])
+    # Array.prototype.push
+    proto.proto_put "push", Types::Function.new(->(scope, this, args) {
+      Lib.throw_type_error "Array.prototype.push is not generic" unless this.is_a? Types::Array
+      args.each { |a| this.items.push a }
+      Types::Number.new this.items.size
+    }, nil, "push", [])
+    # Array.prototype.unshift
+    proto.proto_put "unshift", Types::Function.new(->(scope, this, args) {
+      Lib.throw_type_error "Array.prototype.unshift is not generic" unless this.is_a? Types::Array
+      args.each { |a| this.items.unshift a }
+      Types::Number.new this.items.size
+    }, nil, "unshift", [])
+    # Array.prototype.slice
+    proto.proto_put "slice", Types::Function.new(->(scope, this, args) {
+      begin_index = Types.to_number(args[0] || Types::Undefined.new)
+      end_index = Types.to_number(args[1] || Types::Undefined.new)
+      begin_index = Types::Number.new(0) if begin_index.nan? || begin_index.infinite?
+      if end_index.nan? || end_index.infinite?
+        Types::Array.new this.generic_items[begin_index.number.to_i..-1]
+      else
+        Types::Array.new this.generic_items[begin_index.number.to_i...end_index.number.to_i]
+      end
+    }, nil, "slice", [])
+    # Array.prototype.sort
+    proto.proto_put "sort", Types::Function.new(->(scope, this, args) {
+      Lib.throw_type_error "Array.prototype.sort is not generic" unless this.is_a? Types::Array
+      sortfn = args[0] || ->(scope, this, args) { Types::Number.new(Types.to_string(args[0]).string <=> Types.to_string(args[1]).string) }
+      this.items.reject!(&:nil?)
+      this.items.sort! { |a,b| Types.to_number(sortfn.(scope, this, [a,b])).number }
+      this
+    }, nil, "sort", [])
+    # Array.prototype.length
+    proto.define_own_property "length", get: ->(this) { Types::Number.new this.items.size }, set: ->(this,val) do
+        Lib.throw_type_error "Array.prototype.length is not generic" unless this.is_a? Types::Array
+        len = Types.to_number(val)
+        Lib.throw_range_error "invalid array length" if len.nan? || len.number < 0 || (len.number % 1) != 0
+        this.items = this.items[0...len.number.to_i]
+        len
+      end, writable: true
+    ary.proto_put "prototype", proto
+  end
+end

data/lib/twostroke/runtime/lib/boolean.rb

@@ -0,0 +1,23 @@
+module Twostroke::Runtime
+  Lib.register do |scope|
+    obj = Types::BooleanObject.constructor_function
+    scope.set_var "Boolean", obj
+    
+    proto = Types::Object.new
+    proto.proto_put "toString", Types::Function.new(->(scope, this, args) {
+      if this.is_a?(Types::BooleanObject)
+        Types::String.new(this.boolean.to_s)
+      else
+        Lib.throw_type_error "Boolean.prototype.toString is not generic"
+      end
+    }, nil, "toString", [])
+    proto.proto_put "valueOf", Types::Function.new(->(scope, this, args) {
+      if this.is_a?(Types::BooleanObject)
+        Types::Boolean.new(this.boolean)
+      else
+        Types.to_primitive(this)
+      end
+    }, nil, "valueOf", [])
+    obj.proto_put "prototype", proto
+  end
+end

data/lib/twostroke/runtime/lib/console.rb

@@ -0,0 +1,13 @@
+module Twostroke::Runtime
+  Lib.register do |scope|    
+    log = Types::Function.new(->(scope, this, args) { puts args.map { |o| Types.to_string(o).string }.join(" ") }, nil, "log", ["string"])
+  
+    console = Types::Object.new
+    ["log", "info", "warn", "error"].each do |m|
+      console.proto_put m, log
+    end
+    console.proto_put "_gets", Types::Function.new(->(scope, this, args) { Types::String.new gets }, nil, "_gets", [])
+    console.proto_put "_print", Types::Function.new(->(scope, this, args) { print args.map { |o| Types.to_string(o).string }.join(" ") }, nil, "_print", ["string"])
+    scope.set_var "console", console
+  end
+end

data/lib/twostroke/runtime/lib/date.rb

@@ -0,0 +1,65 @@
+module Twostroke::Runtime
+  Lib.register do |scope|
+    obj = Types::Function.new(->(scope, this, args) {
+        return Types::String.new Time.now.strftime("%a %b %d %Y %H:%M:%S GMT%z (%Z)") unless this.constructing?
+        args.map! { |a| Types.to_primitive a }
+        if args.size.zero?
+          this.data[:time] = Time.now
+        elsif args.size == 1
+          if args[0].is_a?(Types::Number)
+            this.data[:time] = Time.at *(args[0].number*1000).divmod(1000_000)
+          else
+            this.data[:time] = Time.parse Types.to_string(args[0]).string rescue this.data[:time] = :invalid
+          end
+        else
+          args = args.take(7)
+            .map { |a| Types.to_uint32(a) }
+            .zip([9999, 12, 31, 23, 59, 59, 999]).map { |a,b| [a || 0, b].min }
+          args[6] *= 1000 if args[6]
+          this.data[:time] = Time.local *args
+        end
+        nil
+      }, nil, "Date", [])
+    scope.set_var "Date", obj
+    
+    obj.proto_put "now", Types::Function.new(->(scope, this, args) { Types::Number.new (Time.now.to_f * 1000).floor }, nil, "now", [])
+    obj.proto_put "parse", Types::Function.new(->(scope, this, args) {
+        Types::Number.new (Time.parse(Types.to_string(args[0]).string).to_f * 1000).floor
+      }, nil, "parse", [])
+    obj.proto_put "UTC", Types::Function.new(->(scope, this, args) {
+        args = args.take(7)
+          .map { |a| Types.to_uint32(a) }
+          .zip([9999, 12, 31, 23, 59, 59, 999]) { |a,b| [a || 0, b].min }
+        args[6] *= 1000 if args[6]
+        Types::Number.new (Time.utc(*args).to_f * 1000).floor
+      }, nil, "UTC", [])
+    
+    proto = Types::Object.new
+    obj.proto_put "prototype", proto
+    
+    { "Date" => :day, "Day" => :wday, "FullYear" => :year, "Hours" => :hour,
+      "Milliseconds" => ->t{ (t.usec / 1000).to_i }, "Minutes" => :min, "Month" => :month,
+      "Seconds" => :sec, "Time" => ->t{ (t.to_f * 1000).floor }, "TimezoneOffset" => ->t{ t.utc_offset / 60 } }.each do |prop,method|
+        # Date.prototype.getXXX
+        proto.proto_put "get#{prop}", Types::Function.new(->(scope, this, args) {
+            Lib.throw_type_error "this is not a Date object" unless this.data[:time]
+            return Types::Number.new(Float::NAN) if this.data[:time] == :invalid
+            Types::Number.new(
+              if method.is_a? Symbol then this.data[:time].send method
+              elsif method.is_a? Proc then method.call this.data[:time]
+              end
+            )
+          }, nil, "get#{prop}", [])
+        # Date.prototype.getUTCXXX
+        proto.proto_put "getUTC#{prop}", Types::Function.new(->(scope, this, args) {
+            Lib.throw_type_error "this is not a Date object" unless this.data[:time]
+            return Types::Number.new(Float::NAN) if this.data[:time] == :invalid
+            Types::Number.new(
+              if method.is_a? Symbol then this.data[:time].send method
+              elsif method.is_a? Proc then method.call this.data[:time]
+              end
+            )
+          }, nil, "getUTC#{prop}", [])
+      end
+  end
+end

data/lib/twostroke/runtime/lib/error.rb

@@ -0,0 +1,36 @@
+module Twostroke::Runtime
+  Lib.register do |scope|
+    error = Types::Function.new(->(scope, this, args) {
+      this.proto_put "name", Types::String.new("Error")
+      this.proto_put "message", (args[0] || Types::Undefined.new)
+      nil # so the constructor ends up returning the object being constructed
+    }, nil, "Error", [])
+    scope.set_var "Error", error
+    error.prototype = Types::Object.new
+    error.prototype.proto_put "toString", Types::Function.new(->(scope, this, args) {
+      Types::String.new "#{Types.to_string(this.get "name").string}: #{Types.to_string(this.get "message").string}"
+    }, nil, "toString", [])
+    error.proto_put "prototype", error.prototype
+    
+    ["Eval", "Range", "Reference", "Syntax", "Type", "URI"].each do |e|
+      obj = Types::Function.new(->(scope, this, args) {
+        this.proto_put "name", Types::String.new("#{e}Error")
+        this.proto_put "message", (args[0] || Types::Undefined.new)
+        nil
+      }, nil, "#{e}Error", [])
+      scope.set_var "#{e}Error", obj
+      obj.prototype = error.prototype
+#      proto = Types::Object.new
+#      proto.prototype = error.prototype
+      obj.proto_put "prototype", error.prototype
+      Lib.define_singleton_method "throw_#{e.downcase}_error" do |message|
+        exc = Types::Object.new
+        exc.construct prototype: obj.prototype, _class: obj do
+          exc.proto_put "name", Types::String.new("#{e}Error")
+          exc.proto_put "message", Types::String.new(message)
+        end
+        throw :exception, exc
+      end
+    end
+  end
+end

data/lib/twostroke/runtime/lib/function.rb

@@ -0,0 +1,45 @@
+module Twostroke::Runtime
+  Lib.register do |scope|
+    obj = Types::Function.constructor_function
+    scope.set_var "Function", obj
+    
+    proto = Types::Object.new
+    proto.proto_put "toString", Types::Function.new(->(scope, this, args) {
+        if this.is_a?(Types::Function)
+          this.primitive_value
+        else
+          Lib.throw_type_error "Function.prototype.toString is not generic"
+        end
+      }, nil, "toString", [])
+    proto.proto_put "valueOf", Types::Function.new(->(scope, this, args) { this }, nil, "valueOf", [])
+    proto.define_own_property "arity", get: ->(this) { this.arguments.size }, writable: false
+    proto.define_own_property "length", get: ->(this) { this.arguments.size }, writable: false
+    proto.define_own_property "name", get: ->(this) { this.name }, writable: false
+    # Function.prototype.apply
+    proto.proto_put "apply", Types::Function.new(->(scope, this, args) do
+        Lib.throw_type_error "cannot call Function.prototype.apply on non-callable object" unless this.respond_to?(:call)
+        if args[0].nil? || args[0].is_a?(Types::Null) || args[0].is_a?(Types::Undefined)
+          call_this = scope.global_scope.root_object
+        else
+          call_this = Types.to_object(args[0])
+        end
+        call_args = args[1].is_a?(Types::Object) ? args[1].generic_items : []
+        this.call scope, call_this, call_args
+      end, nil, "apply", [])
+    # Function.prototype.call
+    proto.proto_put "call", Types::Function.new(->(scope, this, args) do
+        Lib.throw_type_error "cannot call Function.prototype.call on non-callable object" unless this.respond_to?(:call)
+        if args[0].nil? || args[0].is_a?(Types::Null) || args[0].is_a?(Types::Undefined)
+          call_this = scope.global_scope.root_object
+        else
+          call_this = Types.to_object(args[0])
+        end
+        this.call(scope, call_this, args[1..-1])
+      end, nil, "call", [])
+    # Function.prototype.toString
+    proto.proto_put "toString", Types::Function.new(->(scope, this, args) do
+        this.primitive_value
+      end, nil, "toString", [])
+    obj.proto_put "prototype", proto
+  end
+end

data/lib/twostroke/runtime/lib/math.rb

@@ -0,0 +1,36 @@
+module Twostroke::Runtime
+  Lib.register do |scope|
+    obj = Types::Object.new
+    scope.set_var "Math", obj
+    
+    scope.set_var "Infinity", Types::Number.new(Float::INFINITY)
+    scope.set_var "NaN", Types::Number.new(Float::NAN)
+    
+    # one argument functions
+    %w(sqrt sin cos tan).each do |method|
+      obj.proto_put method, Types::Function.new(->(scope, this, args) {
+          Types::Number.new(Math.send method, Types.to_number(args[0] || Undefined.new).number)
+        }, nil, method, [])
+    end
+
+    obj.proto_put "random", Types::Function.new(->(scope, this, args) {
+      Types::Number.new rand
+    }, nil, "random", [])
+
+    obj.proto_put "floor", Types::Function.new(->(scope, this, args) {
+        Types::Number.new Types.to_number(args[0] || Undefined.new).number.floor
+      }, nil, "floor", [])
+
+    obj.proto_put "ceil", Types::Function.new(->(scope, this, args) {
+        Types::Number.new Types.to_number(args[0] || Undefined.new).number.ceil
+      }, nil, "ceil", [])
+    
+    obj.proto_put "max", Types::Function.new(->(scope, this, args) {
+        Types::Number.new [-Float::INFINITY, *args.map { |a| Types.to_number(a).number }].max
+      }, nil, "max", [])
+    
+    obj.proto_put "min", Types::Function.new(->(scope, this, args) {
+        Types::Number.new [Float::INFINITY, *args.map { |a| Types.to_number(a).number }].min
+      }, nil, "min", [])
+  end
+end

data/lib/twostroke/runtime/lib/number.rb

@@ -0,0 +1,65 @@
+module Twostroke::Runtime
+  Lib.register do |scope|
+    obj = Types::NumberObject.constructor_function
+    scope.set_var "Number", obj
+    
+    proto = Types::Object.new
+    proto.proto_put "toString", Types::Function.new(->(scope, this, args) {
+      if this.is_a?(Types::NumberObject)
+        Types::String.new(this.number.to_s)
+      else
+        Lib.throw_type_error "Number.prototype.toString is not generic"
+      end
+    }, nil, "toString", [])
+    proto.proto_put "valueOf", Types::Function.new(->(scope, this, args) { this.is_a?(Types::NumberObject) ? Types::Number.new(this.number) : Types.to_primitive(this) }, nil, "valueOf", [])
+    # Number.prototype.toExponential
+    proto.proto_put "toExponential", Types::Function.new(->(scope, this, args) do
+        n = Types.to_number(this)
+        if n.nan? || n.infinite?
+          Types::String.new n.to_s
+        else
+          places = Math.log(n.number, 10).floor
+          significand = n.number / (10 ** places).to_f
+          if args.size > 0
+            sigfigs = Types.to_number(args[0] || Types::Undefined.new)
+            if sigfigs.nan? || sigfigs.infinite?
+              sigfigs = 0
+            else
+              sigfigs = sigfigs.number.to_i
+            end
+            Types::String.new sprintf("%.#{sigfigs}fe%s%d", significand, ("+" if places >= 0), places)
+          else
+            Types::String.new "#{significand}e#{"+" if places >= 0}#{places}"
+          end
+        end
+      end, nil, "toExponential", [])
+    # Number.prototype.toFixed
+    proto.proto_put "toFixed", Types::Function.new(->(scope, this, args) do
+        digits = Types.to_number(args[0] || Undefined.new)
+        if digits.nan? || digits.infinite?
+          digits = 0
+        else
+          digits = digits.number
+        end
+        Types::String.new sprintf("%.#{[[0,digits].max,20].min}f", Types.to_number(this).number)
+      end, nil, "toFixed", [])
+    # Number.prototype.toLocaleString
+    proto.proto_put "toLocaleString", proto.get("toString")
+    # Number.prototype.toString
+    proto.proto_put "toPrecision", Types::Function.new(->(scope, this, args) do
+        digits = Types.to_number(args[0] || Undefined.new)
+        if digits.nan? || digits.infinite?
+          digits = 0
+        else
+          digits = digits.number
+        end
+        Types::Number.new Types.to_number(this).number.round([[digits,0].max, 100].min)
+      end, nil, "toString", [])
+    obj.proto_put "prototype", proto
+    obj.proto_put "MAX_VALUE", Types::Number.new(Float::MAX)
+    obj.proto_put "MIN_VALUE", Types::Number.new(Float::MIN)
+    obj.proto_put "NaN", Types::Number.new(Float::NAN)
+    obj.proto_put "NEGATIVE_INFINITY", Types::Number.new(-Float::INFINITY)
+    obj.proto_put "POSITIVE_INFINITY", Types::Number.new(Float::INFINITY)
+  end
+end