opal 1.7.2 → 1.8.0.alpha1

data/docs/bridging.md

@@ -0,0 +1,112 @@
+# Opal Bridging
+
+## Intro
+
+Opal's "bridging" makes JavaScript objects become Ruby object in Opal, boosting language interoperability and performance by using native JavaScript versions of certain Ruby classes.
+
+## Bridging Basics
+
+Opal modifies the prototype chain of a JavaScript constructor function by injecting a Ruby class and its superclasses, enabling bridged JavaScript classes to inherit Ruby behaviors.
+
+Prototype chain pre-bridging: 
+
+- constructor (window.String)
+  - JavaScript prototype chain (window.Object)
+    - null
+
+After bridging with `::Object`:
+
+- constructor (window.String)
+  - Ruby superclass chain (Opal.Object, Opal.Kernel, Opal.BasicObject)
+    - JavaScript prototype chain (window.Object)
+      - null
+
+The `Opal.bridge` function is used for this, allowing the JavaScript class to become a Ruby class. You can also use a syntax like: ```class MyCar < `Car` ``` which counterintuitively doesn't mean inheritance - `MyCar`'s superclass will be Object, but `MyCar` will be bridged into native JavaScript `Car` class.
+
+The bridged JavaScript classes are usable in Ruby, but with an adapted interface: JavaScript methods accessed from Ruby use x-strings and Ruby methods accessed from JavaScript use $-prefixed method names (e.g., reduce->$reduce). 
+
+This strategy avoids type casting for bridged objects and boosts performance by utilizing native JavaScript objects. 
+
+Example:
+
+JavaScript `Car` class:
+
+```javascript
+class Car {
+  constructor(make, model) {
+    this.make = make;
+    this.model = model;
+  }
+
+  getCarInfo() {
+    return `${this.make} ${this.model}`;
+  }
+}
+```
+
+Bridged Ruby `MyCar` class:
+
+```ruby
+class MyCar < `Car`
+  def self.new(make, model)
+    `new Car(make, model)`
+  end
+
+  def car_info
+    `self.getCarInfo()`
+  end
+end
+
+car = MyCar.new('Toyota', 'Corolla')
+puts car.car_info  # Outputs: "Toyota Corolla"
+```
+
+This bridges `Car` to `MyCar`, creating a `Car` instance with `new Car(make, model)`. We call `getCarInfo()` via `self`, referencing the same JavaScript and Ruby object due to bridging. Thus, creating a `MyCar` instance makes a `Car` instance, and `car_info` on the `car` object outputs `"Toyota Corolla"`. This shows seamless Ruby-JavaScript interaction via bridging.
+
+## Inheritance & Bridging
+
+Creating a subclass of a native JavaScript class is possible. Bridging doesn't affect JavaScript's behavior or inheritance hierarchy.
+
+## Bridging Considerations
+
+### Bridged Class Methods
+
+Access JavaScript class methods as properties on the constructor with `class.$$constructor`, where `class` is a Ruby class. You can access it using `self`.
+
+### Performance
+
+Bridging is quicker than wrapping as no wrapper object is used, but altering the prototype chain could affect JavaScript engine performance.
+
+### Exception Handling
+
+JavaScript `Error` is bridged to Ruby `Exception` for unified error handling.
+
+### Native JavaScript Interactions
+
+Use x-strings for interacting with native JavaScript. The `Native` class wraps JavaScript objects and offers a Ruby-like API.
+
+### Type Conversions
+
+With bridging creating equivalent Ruby and JavaScript objects, no explicit type conversion is needed. The `Native` library's `#to_n` is how you convert non-bridged objects.
+
+## Bridged Classes in Corelib
+
+Opal's core library bridges several commonly used JavaScript classes, including `Array`, `Boolean`, `Number` (think: `Float` which also may act as an `Integer`), `Proc`, `Time`, `RegExp`, and `String`, allowing interaction with these JavaScript instances as their Ruby equivalents. Also `Hash` bridges the Javascript `Map` class and works very well between Javascript and Opal if primitives of the Javascript types "string", "number" and "symbol" (which must be global, generated with `Symbol.for()`) are used as keys. When other types or objects are used as keys, there may be issues retrieving the Map entries from each language, because the original references of the objects that have been used as keys are required for retrieval. When using a `Map` with object keys passed from Javascript as Hash in Opal, calling `Hash#rehash` may resolve issues and make entries accessible.
+
+However, Opal doesn't bridge common JavaScript classes like `Set` due to significant differences in behavior and interfaces between Ruby and JavaScript.
+
+## Drawbacks
+
+Bridging effectively utilizes JavaScript objects within Ruby, but it does have its downsides.
+
+The main drawback of Opal bridging is that it modifies the prototypes of JavaScript classes, potentially leading to prototype pollution. This can cause conflicts with other JavaScript code expecting the prototype in its original state, potentially causing hard-to-trace bugs or slower code execution due to changes impacting the JavaScript engine's performance.
+
+Additionally, bridging requires comprehensive knowledge of both Ruby and JavaScript, and understanding how Opal implements the bridge. Incorrect usage can lead to complex, hard-to-debug issues.
+
+An alternative to bridging is using `Native::Wrapper`. This module in Opal's standard library allows interaction with JavaScript objects without modifying their prototypes. It offers a Ruby-friendly API for accessing and calling JavaScript methods, as well as handling JavaScript properties, thus avoiding the prototype pollution issue.
+
+In conclusion, bridging provides powerful functionality for Ruby-JavaScript code interaction, but it should be used cautiously and with a deep understanding of its implications. Depending on your needs, `Native::Wrapper` may be a safer and more intuitive alternative.
+
+## Conclusion
+
+Opal's bridging mechanism offers an enticing method for combining Ruby and JavaScript's strengths into a single environment. Despite requiring caution due to potential drawbacks, bridging enables developers to create Ruby idiomatic APIs for accessing JavaScript code. By leveraging this mechanism, we can redefine conventional web programming paradigms and create more vibrant, dynamic applications.

data/docs/compiled_ruby.md

@@ -78,18 +78,17 @@ Ruby syntaxes for word arrays etc are also supported.
 
 #### Hash
 
-Inside a generated Ruby script, a function `Opal.hash` is available which
-creates a new hash. This is also available in JavaScript as `Opal.hash`
-and simply returns a new instance of the `Hash` class.
+Inside Javascript `new Map()` can be used, which
+creates simply a new instance of the `Hash` class.
 
 ```ruby
-{ :foo => 100, :baz => 700 }    # => Opal.hash("foo", 100, "baz", 700)
-{ foo: 42, bar: [1, 2, 3] }     # => Opal.hash("foo", 42, "bar", [1, 2, 3])
+{ :foo => 100, :baz => 700 }    # => new Map([["foo", 100], ["baz", 700]])
+{ foo: 42, bar: [1, 2, 3] }     # => new Map([["foo", 42], ["bar", [1, 2, 3]]])
 ```
 
 #### Range
 
-Similar to hash, there is a function `Opal.range` available to create
+There is a function `Opal.range` available to create
 range instances.
 
 ```ruby
@@ -598,10 +597,10 @@ array.$map(); // => [2,4,6]
 
 ### Hash
 
-Since Ruby hashes are implemented directly with an Opal class, there's no "toll-free" bridging available (unlike with strings and arrays, for example). However, it's quite possible to interact with hashes from JavaScript:
+Since Ruby hashes are bridged to `Map`. It's quite possible to interact with hashes from JavaScript:
 
 ```javascript
-var myHash = Opal.hash({a: 1, b: 2});
+var myHash = new Map([['a', 1], ['b', 2]]);
 // output of $inspect: {"a"=>1, "b"=>2}
 myHash.$store('a', 10);
 // output of $inspect: {"a"=>10, "b"=>2}
@@ -609,10 +608,11 @@ myHash.$fetch('b','');
 // 2
 myHash.$fetch('z','');
 // ""
-myHash.$update(Opal.hash({b: 20, c: 30}));
+myHash.$update(new Map([['b', 20], ['c', 30]]));
 // output of $inspect: {"a"=>10, "b"=>20, "c"=>30}
 myHash.$to_n(); // provided by the Native module
-// output: {"a": 10, "b": 20, "c": 30} aka a standard JavaScript object
+// output: Map(2) {'b' => 20, 'c' => 30}
+// aka a standard JavaScript Map
 ```
 
 NOTE: Be aware `Hash#to_n` produces a duplicate copy of the hash.

data/docs/getting_started.md

@@ -1,10 +1,10 @@
 # Getting Started
 
-Opal is a ruby to javascript compiler, an implementation of the ruby corelib and stdlib, and associated gems for building fast client side web applications in ruby.
+Opal is a Ruby to JavaScript compiler, an implementation of the Ruby corelib and stdlib, and associated gems for building fast client-side web applications in Ruby.
 
 ## Installation
 
-Opal is available as a gem, and can be installed via:
+Opal is available as a gem and can be installed via:
 
 ```
 $ gem install opal
@@ -16,49 +16,45 @@ Or added to your Gemfile as:
 gem 'opal'
 ```
 
-## Getting started with Opal
+## Getting Started with Opal
 
-At its very core, opal provides a simple method of compiling a string of ruby into javascript that can run on top of the opal runtime, provided by `opal.js`:
+At its core, Opal provides a simple method of compiling a string of Ruby into JavaScript that can run on top of the Opal runtime:
 
 ```ruby
 Opal.compile("[1, 2, 3].each { |a| puts a }")
 # => "(function() { ... })()"
 ```
 
-`opal` includes sprockets support for compiling Ruby (and ERB) assets, and treating them as first class JavaScript citizens. It works in a similar way to CoffeeScript, where JavaScript files can simply require Ruby sources, and Ruby sources can require JavaScript and other Ruby files.
+Opal allows for Ruby (and ERB) assets to be compiled and treated as first-class JavaScript citizens. Ruby sources can require JavaScript and other Ruby files, working similar to CoffeeScript.
 
-This relies on the Opal load path. Any gem containing opal code registers that directory to the Opal load path. Opal will then use all Opal load paths when running sprockets instances. For rails applications, `opal-rails` does this automatically. For building a simple application, we have to do this manually.
+This relies on the Opal load path. Any gem containing Opal code registers that directory to the Opal load path. Opal will then use all Opal load paths when running instances.
 
+### Adding Lookup Paths
 
-### Adding lookup paths
+Opal uses a load path to create a set of locations from which Opal can require files. If you want to add a directory to this load path, you can add it to the global environment.
 
-Opal uses a load path which works with sprockets to create a set of locations which opal can require files
-from. If you want to add a directory to this load path, you can add it to the global environment.
-
-In the `Opal` module, a property `paths` is used to hold the load paths which
-`Opal` uses to require files from. You can add a directory to this:
+In the `Opal` module, a property `paths` is used to hold the load paths which `Opal` uses to require files from. You can add a directory to this:
 
 ```ruby
 Opal.append_path '../my_lib'
 ```
 
-Now, any ruby files in this directory can be discovered.
-
+Now, any Ruby files in this directory can be discovered.
 
 ## FAQ
 
-### Why does Opal exist?
+### Why Does Opal Exist?
 
-To try and keep ruby relevant in a world where client-side applications are making javascript the primary development platform.
+Opal aims to keep Ruby relevant in a world where client-side applications are making JavaScript the primary development platform.
 
-### How compatible is Opal?
+### How Compatible is Opal?
 
-We run opal against the [ruby spec](https://github.com/ruby/spec) as our primary testing setup. We try to make Opal as compatible as possible, whilst also taking into account restrictions of JavaScript when applicable. Opal supports the majority of ruby syntax features, as well as a very large part of the corelib implementation. We support method\_missing, modules, classes, instance\_exec, blocks, procs and lots lots more. Opal can compile and run RSpec unmodified, as well as self hosting the compiler at runtime.
+Opal is tested against the [Ruby spec](https://github.com/ruby/spec) as our primary testing setup. The goal is to make Opal as compatible as possible while also considering the restrictions of JavaScript when applicable. Opal supports the majority of Ruby syntax features, as well as a very large part of the corelib implementation. Opal can compile and run RSpec unmodified, as well as self-host the compiler at runtime.
 
-### What version of ruby does Opal target?
+### What Version of Ruby Does Opal Target?
 
-We are running tests under ruby 3.0.0 conditions, but are mostly compatible with 2.6 level features.
+Opal's tests are run under Ruby 3.2.0 conditions, but it remains mostly compatible with 2.6 level features.
 
-### Why doesn't Opal support mutable strings?
+### Why Doesn't Opal Support Mutable Strings?
 
-All strings in Opal are immutable because ruby strings just get compiled directly into javascript strings, which are immutable. Wrapping ruby strings as a custom JavaScript object would add a lot of overhead as well as making interaction between ruby and javascript libraries more difficult.
+All strings in Opal are immutable because Ruby strings are compiled directly into JavaScript strings, which are immutable. Wrapping Ruby strings as a custom JavaScript object would add a lot of overhead and complicate interaction between Ruby and JavaScript libraries.

data/docs/index.md

@@ -8,7 +8,7 @@ The guides for earlier releases are [available here](/docs).
 
 ## Start here
 
-#### [Getting Started with Opal](etting_started.html)
+#### [Getting Started with Opal](getting_started.html)
 
 Everything you need to know to install Opal and create your first application.
 

data/lib/opal/builder_scheduler/prefork.rb

@@ -131,8 +131,8 @@ module Opal
 
       class Fork
         def initialize(forkset)
-          @parent_read, @child_write = IO.pipe
-          @child_read, @parent_write = IO.pipe
+          @parent_read, @child_write = IO.pipe(binmode: true)
+          @child_read, @parent_write = IO.pipe(binmode: true)
           @forkset = forkset
           @in_fork = false
 

data/lib/opal/cache/file_cache.rb

@@ -78,19 +78,16 @@ module Opal
         nil
       end
 
-      # This complex piece of code tries to check if we can robustly mkdir_p a directory.
+      # Check if we can robustly mkdir_p a directory.
       def self.dir_writable?(*paths)
-        dir = nil
-        paths = paths.reduce([]) do |a, b|
-          [*a, dir = a.last ? File.expand_path(b, a.last) : b]
-        end
+        return false unless File.exist?(paths.first)
 
-        File.exist?(paths.first) &&
-          paths.reverse.all? do |i|
-            !File.exist?(i) || (File.directory?(i) && File.writable?(i))
-          end
+        until paths.empty?
+          dir = File.expand_path(paths.shift, dir)
+          ok = File.directory?(dir) && File.writable?(dir) if File.exist?(dir)
+        end
 
-        dir
+        dir if ok
       end
 
       def self.find_dir

data/lib/opal/cli_runners/chrome_cdp_interface.rb

@@ -1,3 +1,4 @@
+# backtick_javascript: true
 # frozen_string_literal: true
 
 # This script I converted into Opal, so that I don't have to write
@@ -121,14 +122,16 @@ var server = http.createServer(function(req, res) {
 
 // actual CDP code
 
-CDP.List(options, function(err, targets) {
+CDP.List(options, async function(err, targets) {
   // default CDP port is 9222, Firefox runner is at 9333
   // Lets collect clients for
   // Chrome CDP starting at 9273 ...
   // Firefox CDP starting 9334 ...
   port_offset = targets ? targets.length + 51 : 51; // default CDP port is 9222, Node CDP port 9229, Firefox is at 9333
 
-  return CDP(options, function(browser_client) {
+  const {webSocketDebuggerUrl} = await CDP.Version(options);
+
+  return await CDP({target: webSocketDebuggerUrl}, function(browser_client) {
 
     server.listen({ port: port_offset + options.port, host: options.host });
 

data/lib/opal/cli_runners/firefox_cdp_interface.rb

@@ -1,3 +1,4 @@
+# backtick_javascript: true
 # frozen_string_literal: true
 
 # This script I converted into Opal, so that I don't have to write
@@ -94,10 +95,12 @@ var server = http.createServer(function(req, res) {
 
 // actual CDP code
 
-CDP.List(options, function(err, targets) {
+CDP.List(options, async function(err, targets) {
   offset = targets ? targets.length + 1 : 1;
 
-  return CDP(options, function(browser_client) {
+  const {webSocketDebuggerUrl} = await CDP.Version(options);
+
+  return await CDP({target: webSocketDebuggerUrl}, function(browser_client) {
 
     server.listen({port: offset + options.port, host: options.host });
 

data/lib/opal/compiler.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+if RUBY_ENGINE == 'opal'
+  require 'corelib/string/unpack'
+end
 require 'set'
 require 'opal/parser'
 require 'opal/fragment'
@@ -8,6 +11,7 @@ require 'opal/eof_content'
 require 'opal/errors'
 require 'opal/magic_comments'
 require 'opal/nodes/closure'
+require 'opal/source_map'
 
 module Opal
   # Compile a string of ruby code into javascript.
@@ -184,6 +188,30 @@ module Opal
     # Adds comments for every method definition
     compiler_option :parse_comments, default: false, as: :parse_comments?
 
+    # @!method backtick_javascript?
+    #
+    # Allows use of a backtick operator (and `%x{}``) to embed verbatim JavaScript.
+    # If false, backtick operator will
+    compiler_option :backtick_javascript, default: nil, as: :backtick_javascript?, magic_comment: true
+
+    # Warn about impending compatibility break
+    def backtick_javascript_or_warn?
+      case backtick_javascript?
+      when true
+        true
+      when nil
+        @backtick_javascript_warned ||= begin
+          warning 'Backtick operator usage interpreted as intent to embed JavaScript; this code will ' \
+                  'break in Opal 2.0; add a magic comment: `# backtick_javascript: true`'
+          true
+        end
+
+        true
+      when false
+        false
+      end
+    end
+
     compiler_option :scope_variables, default: []
 
     # @!method async_await
@@ -572,7 +600,11 @@ module Opal
       when :return, :js_return, :returnable_yield
         sexp
       when :xstr
-        sexp.updated(nil, [s(:js_return, *sexp.children)])
+        if backtick_javascript_or_warn?
+          sexp.updated(nil, [s(:js_return, *sexp.children)])
+        else
+          sexp
+        end
       when :if
         cond, true_body, false_body = *sexp
         sexp.updated(

data/lib/opal/nodes/args/extract_kwoptarg.rb

@@ -16,12 +16,13 @@ module Opal
         children :lvar_name, :default_value
 
         def compile
+          helper :hash_get
           key_name = @sexp.meta[:arg_name]
           scope.used_kwargs << key_name
 
           add_temp lvar_name
 
-          line "#{lvar_name} = $kwargs.$$smap[#{key_name.to_s.inspect}];"
+          line "#{lvar_name} = $hash_get($kwargs, #{key_name.to_s.inspect});"
 
           return if default_value.children[1] == :undefined
 

data/lib/opal/nodes/call.rb

@@ -366,7 +366,7 @@ module Opal
       end
 
       add_special :__OPAL_COMPILER_CONFIG__ do
-        push fragment "Opal.hash({ arity_check: #{compiler.arity_check?} })"
+        push fragment "(new Map([['arity_check', #{compiler.arity_check?}]]))"
       end
 
       add_special :lambda do |compile_default|

data/lib/opal/nodes/call_special.rb

@@ -60,8 +60,8 @@ module Opal
       end
     end
 
-    # /regexp/ =~ rhs
-    # s(:match_with_lvasgn, lhs, rhs)
+    # Handles match_with_lvasgn nodes which represent matching a regular expression
+    # with a right-hand side value and assigning the match result to a left-hand side variable.
     class Match3Node < Base
       handle :match_with_lvasgn
 
@@ -69,58 +69,82 @@ module Opal
 
       def compile
         sexp = s(:send, lhs, :=~, rhs)
+
         # Handle named matches like: /(?<abc>b)/ =~ 'b'
         if lhs.type == :regexp && lhs.children.first.type == :str
-          re = lhs.children.first.children.first
-          names = re.scan(/\(\?<([^>]*)>/).flatten.map(&:to_sym)
-          unless names.empty?
-            # $m3names = $~ ? $~.named_captures : {}
-            names_def = s(:lvasgn, :$m3names,
-              s(:if,
-                s(:gvar, :$~),
-                s(:send, s(:gvar, :$~), :named_captures),
-                s(:hash)
-              )
-            )
+          names = extract_names(lhs)
 
-            names = names.map do |name|
-              # abc = $m3names[:abc]
-              s(:lvasgn, name,
-                s(:send,
-                  s(:lvar, :$m3names),
-                  :[],
-                  s(:sym, name)
-                )
-              )
-            end
-
-            if stmt?
-              # We don't care about a return value of this one, so we
-              # ignore it and just assign the local variables.
-              #
-              # (/(?<abc>b)/ =~ 'f')
-              # $m3names = $~ ? $~.named_captures : {}
-              # abc = $m3names[:abc]
-              sexp = s(:begin, sexp, names_def, *names)
-            else
-              # We actually do care about a return value, so we must
-              # keep it saved.
-              #
-              # $m3tmp = (/(?<abc>b)/ =~ 'f')
-              # $m3names = $~ ? $~.named_captures : {}
-              # abc = $m3names[:abc]
-              # $m3tmp
-              sexp = s(:begin,
-                s(:lvasgn, :$m3tmp, sexp),
-                names_def,
-                *names,
-                s(:lvar, :$m3tmp)
-              )
-            end
+          unless names.empty?
+            names_def = generate_names_definition
+            names_assignments = generate_names_assignments(names)
+
+            sexp = if stmt?
+                     handle_statement(sexp, names_def, names_assignments)
+                   else
+                     handle_non_statement(sexp, names_def, names_assignments)
+                   end
           end
         end
+
         push process(sexp, @level)
       end
+
+      private
+
+      def extract_names(regexp_node)
+        re = regexp_node.children.first.children.first
+        re.scan(/\(\?<([^>]*)>/).flatten.map(&:to_sym)
+      end
+
+      def generate_names_definition
+        # Generate names definition: $m3names = $~ ? $~.named_captures : {}
+        s(:lvasgn, :$m3names,
+          s(:if,
+            s(:gvar, :$~),
+            s(:send, s(:gvar, :$~), :named_captures),
+            s(:hash)
+          )
+        )
+      end
+
+      def generate_names_assignments(names)
+        # Generate names assignments: abc = $m3names[:abc]
+        names.map do |name|
+          s(:lvasgn, name,
+            s(:send,
+              s(:lvar, :$m3names),
+              :[],
+              s(:sym, name)
+            )
+          )
+        end
+      end
+
+      def handle_statement(sexp, names_def, names_assignments)
+        # We don't care about a return value of this one, so we
+        # ignore it and just assign the local variables.
+        #
+        # (/(?<abc>b)/ =~ 'f')
+        # $m3names = $~ ? $~.named_captures : {}
+        # abc = $m3names[:abc]
+        s(:begin, sexp, names_def, *names_assignments)
+      end
+
+      def handle_non_statement(sexp, names_def, names_assignments)
+        # We actually do care about a return value, so we must
+        # keep it saved.
+        #
+        # $m3tmp = (/(?<abc>b)/ =~ 'f')
+        # $m3names = $~ ? $~.named_captures : {}
+        # abc = $m3names[:abc]
+        # $m3tmp
+        s(:begin,
+          s(:lvasgn, :$m3tmp, sexp),
+          names_def,
+          *names_assignments,
+          s(:lvar, :$m3tmp)
+        )
+      end
     end
   end
 end

data/lib/opal/nodes/hash.rb

@@ -27,14 +27,12 @@ module Opal
       end
 
       def simple_keys?
-        keys.all? { |key| %i[sym str].include?(key.type) }
+        keys.all? { |key| %i[sym str int].include?(key.type) }
       end
 
       def compile
         if has_kwsplat
           compile_merge
-        elsif simple_keys?
-          compile_hash2
         else
           compile_hash
         end
@@ -47,8 +45,6 @@ module Opal
       # Each kwsplat overrides previosly defined keys
       # Hash k/v pairs override previously defined kwsplat values
       def compile_merge
-        helper :hash
-
         result, seq = [], []
 
         children.each do |child|
@@ -76,38 +72,26 @@ module Opal
       end
 
       # Compiles a hash without kwsplats
-      # with complex keys.
+      # with simple or complex keys.
       def compile_hash
-        helper :hash
-
         children.each_with_index do |pair, idx|
           key, value = pair.children
           push ', ' unless idx == 0
-          push expr(key), ', ', expr(value)
-        end
-
-        wrap '$hash(', ')'
-      end
-
-      # Compiles a hash without kwsplats
-      # and containing **only** string/symbols as keys.
-      def compile_hash2
-        hash_obj, hash_keys = {}, []
-        helper :hash2
-
-        keys.size.times do |idx|
-          key = keys[idx].children[0].to_s.inspect
-          hash_keys << key unless hash_obj.include? key
-          hash_obj[key] = expr(values[idx])
+          if %i[sym str].include?(key.type)
+            push "[#{key.children[0].to_s.inspect}", ', ', expr(value), ']'
+          else
+            push '[', expr(key), ', ', expr(value), ']'
+          end
         end
 
-        hash_keys.each_with_index do |key, idx|
-          push ', ' unless idx == 0
-          push "#{key}: "
-          push hash_obj[key]
+        if keys.empty?
+          push '(new Map())'
+        elsif simple_keys?
+          wrap '(new Map([', ']))'
+        else
+          helper :hash_rehash
+          wrap '$hash_rehash(new Map([', ']))'
         end
-
-        wrap "$hash2([#{hash_keys.join ', '}], {", '})'
       end
     end