ruby2js 3.5.3 → 4.0.2

data/lib/ruby2js/converter/vasgn.rb

@@ -8,6 +8,11 @@ module Ruby2JS
     #   (int 1))
 
     handle :lvasgn, :gvasgn do |name, value=nil|
+      if @ast.type == :lvasgn and value
+        receiver = @rbstack.map {|rb| rb[name]}.compact.last
+        return parse s(:attr, receiver, "#{name}=", value) if receiver
+      end
+
       state  = @state
       begin
         if value and value.type == :lvasgn and @state == :statement

data/lib/ruby2js/converter/while.rb

@@ -22,7 +22,7 @@ module Ruby2JS
           end
         end
 
-        put 'while ('; parse condition; puts ') {'; scope block; sput '}'
+        put 'while ('; parse condition; puts ') {'; redoable block; sput '}'
       ensure
         @next_token = next_token
       end

data/lib/ruby2js/converter/whilepost.rb

@@ -11,7 +11,7 @@ module Ruby2JS
       begin
         next_token, @next_token = @next_token, :continue
 
-        puts 'do {'; scope block; sput '} while ('; parse condition; put ')'
+        puts 'do {'; redoable block; sput '} while ('; parse condition; put ')'
       ensure
         @next_token = next_token
       end

data/lib/ruby2js/converter/xstr.rb

@@ -5,12 +5,11 @@ module Ruby2JS
     #   (str 'a'))
 
     handle :xstr do |*children|
-      str = eval capture { parse_all(*children) }
-
       if @binding
+        str = eval capture { parse_all(*children) }
         puts @binding.eval(str).to_s
       else
-        puts eval(str).to_s
+        raise SecurityError.new('Insecure operation, eval without binding option')
       end
     end
   end

data/lib/ruby2js/demo.rb

@@ -0,0 +1,53 @@
+# helper methods shared between MRI CGI/server and Opal implementations
+require 'ruby2js'
+
+module Ruby2JS
+  module Demo
+    def self.parse_autoimports(mappings)
+      autoimports = {}
+
+      mappings = mappings.gsub(/\s+|"|'/, '')
+
+      while mappings and not mappings.empty?
+        if mappings =~ /^(\w+):([^,]+)(,(.*))?$/
+          # symbol: module
+          autoimports[$1.to_sym] = $2
+          mappings = $4
+        elsif mappings =~ /^\[([\w,]+)\]:([^,]+)(,(.*))?$/
+          # [symbol, symbol]: module
+          mname, mappings = $2, $4
+          autoimports[$1.split(/,/).map(&:to_sym)] = mname
+        elsif mappings =~ /^(\w+)(,(.*))?$/
+          # symbol
+          autoimports[$1.to_sym] = $1
+          mappings = $3
+        elsif not mappings.empty?
+          $load_error = "unsupported autoimports mapping: #{mappings}"
+          mappings = ''
+        end
+      end
+
+      # if nothing is listed, provide a mapping for everything
+      autoimports = proc {|name| name.to_s} if autoimports.empty?
+
+      autoimports
+    end
+
+    def self.parse_defs(mappings)
+      defs = {}
+
+      mappings = mappings.gsub(/\s+|"|'/, '')
+
+      while mappings =~ /^(\w+):\[(:?@?\w+(,:?@?\w+)*)\](,(.*))?$/
+        mappings = $5
+        defs[$1.to_sym] = $2.gsub(':', '').split(',').map(&:to_sym)
+      end
+
+      if mappings and not mappings.empty?
+        $load_error = "unsupported defs: #{mappings}"
+      end
+
+      defs
+    end
+  end
+end

data/lib/ruby2js/es2022.rb

@@ -0,0 +1,5 @@
+require 'ruby2js'
+
+if Ruby2JS.eslevel_default < 2022
+  Ruby2JS.eslevel_default = 2022
+end

data/lib/ruby2js/es2022/strict.rb

@@ -0,0 +1,3 @@
+require 'ruby2js/es2022'
+
+Ruby2JS.strict_default = true

data/lib/ruby2js/filter.rb

@@ -13,6 +13,14 @@ module Ruby2JS
     @@included = nil
     @@excluded = []
 
+    def self.included_methods
+      @@included&.dup
+    end
+
+    def self.excluded_methods
+      @@excluded&.dup
+    end
+
     # indicate that the specified methods are not to be processed
     def self.exclude(*methods)
       if @@included
@@ -52,7 +60,7 @@ module Ruby2JS
         not @included.include? method
       else
         return true if @exclude_methods.flatten.include? method
-        @excluded.include? method
+        @excluded&.include? method
       end
     end
 

data/lib/ruby2js/filter/active_functions.rb

@@ -0,0 +1,44 @@
+require 'ruby2js'
+
+module Ruby2JS
+  module Filter
+    module ActiveFunctions
+      include SEXP
+
+      def on_send(node)
+        target, method, *args = node.children
+        return super unless args.empty?
+
+        if es2015 and method == :blank?
+          create_or_update_import("blank$")
+          process node.updated :send, [nil, "blank$", target]
+        elsif es2015 and method == :present?
+          create_or_update_import("present$")
+          process node.updated :send, [nil, "present$", target]
+        elsif es2015 and method == :presence
+          create_or_update_import("presence$")
+          process node.updated :send, [nil, "presence$", target]
+        else
+          super
+        end
+      end
+
+      private
+
+      def create_or_update_import(token)
+        af_import = @options[:import_from_skypack] ? "https://cdn.skypack.dev/@ruby2js/active-functions" : "@ruby2js/active-functions"
+
+        if found_node = prepend_list.find {|ast| ast.type == :import && ast.children.first == af_import}
+          unless found_node.children.last.find {|const| const.children.last == token}
+            prepend_list.delete found_node
+            prepend_list << s(:import, found_node.children.first, found_node.children.last.push(s(:const, nil, token)))
+          end
+        else
+          prepend_list << s(:import, af_import, [s(:const, nil, token)])
+        end
+      end
+    end
+
+    DEFAULTS.push ActiveFunctions
+  end
+end

data/lib/ruby2js/filter/camelCase.rb

@@ -9,8 +9,11 @@ module Ruby2JS
     module CamelCase
       include SEXP
 
-      WHITELIST = %w{
+      ALLOWLIST = %w{
         attr_accessor
+        attr_reader
+        attr_writer
+        method_missing
       }
 
       CAPS_EXCEPTIONS = {
@@ -37,7 +40,7 @@ module Ruby2JS
         node = super
         return node unless [:send, :csend, :attr].include? node.type
 
-        if node.children[0] == nil and WHITELIST.include? node.children[1].to_s
+        if node.children[0] == nil and ALLOWLIST.include? node.children[1].to_s
           node
         elsif node.children[0] && [:ivar, :cvar].include?(node.children[0].type)
           S(node.type, s(node.children[0].type, camelCase(node.children[0].children[0])),
@@ -61,7 +64,7 @@ module Ruby2JS
       def handle_generic_node(node, node_type)
         return node if node.type != node_type
 
-        if node.children[0] =~ /_.*\w$/
+        if node.children[0] =~ /_.*\w$/ and !ALLOWLIST.include?(node.children[0].to_s)
           S(node_type , camelCase(node.children[0]), *node.children[1..-1])
         else
           node

data/lib/ruby2js/filter/cjs.rb

@@ -1,5 +1,7 @@
 require 'ruby2js'
 
+Ruby2JS.module_default ||= :cjs
+
 module Ruby2JS
   module Filter
     module CJS

data/lib/ruby2js/filter/esm.rb

@@ -7,30 +7,77 @@ module Ruby2JS
     module ESM
       include SEXP
 
-      def initialize(*args)
-        super
-        @esm = true # signal for other filters
-        @esm_imports = nil
-      end
-
       def options=(options)
         super
+        @esm_autoexports = !@disable_autoexports && options[:autoexports]
         @esm_autoimports = options[:autoimports]
-        return unless @esm_autoimports
+        @esm_defs = options[:defs] || {}
+        @esm_explicit_tokens = Set.new
       end
 
       def process(node)
-        return super if @esm_imports or not @esm_autoimports
-        @esm_imports = Set.new
-        result = super
+        return super unless @esm_autoexports
 
-        if @esm_imports.empty?
-          result
-        else
-          s(:begin, *@esm_imports.to_a.map {|token|
-            s(:import, @esm_autoimports[token], s(:const, nil, token))
-          }, result)
+        list = [node]
+        while list.length == 1 and list.first.type == :begin
+          list = list.first.children.dup
+        end
+
+        replaced = []
+        list.map! do |child|
+          replacement = child
+
+          if [:module, :class].include? child.type and
+            child.children.first.type == :const and
+            child.children.first.children.first == nil \
+          then
+            replacement = s(:export, child)
+          elsif child.type == :casgn and child.children.first == nil
+            replacement = s(:export, child)
+          elsif child.type == :def
+            replacement = s(:export, child)
+          end
+
+          if replacement != child
+            replaced << replacement
+            @comments[replacement] = @comments[child] if @comments[child]
+          end
+
+          replacement
         end
+
+        if replaced.length == 1 and @esm_autoexports == :default
+          list.map! do |child|
+            if child == replaced.first
+              replacement = s(:export, s(:send, nil, :default, *child.children))
+              @comments[replacement] = @comments[child] if @comments[child]
+              replacement
+            else
+              child
+            end
+          end
+        end
+
+        @esm_autoexports = false
+        process s(:begin, *list)
+      end
+
+      def on_class(node)
+        @esm_explicit_tokens << node.children.first.children.last
+
+        super
+      end
+
+      def on_def(node)
+        @esm_explicit_tokens << node.children.first
+
+        super
+      end
+
+      def on_lvasgn(node)
+        @esm_explicit_tokens << node.children.first
+
+        super
       end
 
       def on_send(node)
@@ -46,7 +93,7 @@ module Ruby2JS
             end
           end
 
-          if args[0].type == :str
+          if args[0].type == :str and args.length == 1
             # import "file.css"
             #   => import "file.css"
             s(:import, args[0].children[0])
@@ -59,6 +106,8 @@ module Ruby2JS
             args[0].children[2].children[2].type == :str
             # import name from "file.js"
             #  => import name from "file.js"
+            @esm_explicit_tokens << args[0].children[1]
+
             s(:import,
               [args[0].children[2].children[2].children[0]],
               process(s(:attr, nil, args[0].children[1])))
@@ -72,15 +121,25 @@ module Ruby2JS
             #   => import Stuff as * from "file.js"
             # import [ Some, Stuff ], from: "file.js"
             #   => import { Some, Stuff } from "file.js"
-            imports = (args[0].type == :const || args[0].type == :send) ?
-              process(args[0]) : 
-              process_all(args[0].children)
-            s(:import, args[1].children, imports) unless args[1].nil?
+            # import Some, [ More, Stuff ], from: "file.js"
+            #   => import Some, { More, Stuff } from "file.js"
+            imports = []
+            if %i(const send str).include? args[0].type
+              @esm_explicit_tokens << args[0].children.last
+              imports << process(args.shift)
+            end
+
+            if args[0].type == :array
+              args[0].children.each {|i| @esm_explicit_tokens << i.children.last}
+              imports << process_all(args.shift.children)
+            end
+
+            s(:import, args[0].children, *imports) unless args[0].nil?
           end
         elsif method == :export          
           s(:export, *process_all(args))
-        elsif @esm_imports and args.length == 0 and @esm_autoimports[method]
-          @esm_imports.add(method)
+        elsif target.nil? and found_import = find_autoimport(method)
+          prepend_list << s(:import, found_import[0], found_import[1])
           super
         else
           super
@@ -88,12 +147,45 @@ module Ruby2JS
       end
 
       def on_const(node)
-        return super unless @esm_autoimports
-        if node.children.first == nil and @esm_autoimports[node.children.last]
-          @esm_imports.add(node.children.last)
+        if node.children.first == nil and found_import = find_autoimport(node.children.last)
+          prepend_list << s(:import, found_import[0], found_import[1])
+
+          values = @esm_defs[node.children.last]
+          
+	  if values
+	    values = values.map {|value| 
+	      if value.to_s.start_with? "@" 
+		[value.to_s[1..-1].to_sym, s(:self)]
+	      else
+		[value.to_sym, s(:autobind, s(:self))]
+	      end
+	    }.to_h
+
+	    @namespace.defineProps values, [node.children.last]
+	  end
         end
+
         super
       end
+
+      def on_export(node)
+        s(:export, *process_all(node.children))
+      end
+    end
+
+    private
+
+    def find_autoimport(token)
+      return nil if @esm_autoimports.nil?
+      return nil if @esm_explicit_tokens.include?(token)
+
+      token = camelCase(token) if respond_to?(:camelCase)
+
+      if @esm_autoimports[token]
+        [@esm_autoimports[token], s(:const, nil, token)]
+      elsif found_key = @esm_autoimports.keys.find {|key| key.is_a?(Array) && key.include?(token)}
+        [@esm_autoimports[found_key], found_key.map {|key| s(:const, nil, key)}]
+      end
     end
 
     DEFAULTS.push ESM

data/lib/ruby2js/filter/functions.rb

@@ -1,5 +1,6 @@
 require 'ruby2js'
-require 'regexp_parser'
+
+require 'regexp_parser/scanner'
 
 module Ruby2JS
   module Filter
@@ -7,7 +8,7 @@ module Ruby2JS
       include SEXP
 
       # require explicit opt-in to to class => constructor mapping
-      Filter.exclude :class
+      Filter.exclude :class, :call
 
       VAR_TO_ASSIGN = {
         lvar: :lvasgn,
@@ -23,91 +24,101 @@ module Ruby2JS
 
       def on_send(node)
         target, method, *args = node.children
-        return super if excluded?(method)
+        return super if excluded?(method) and method != :call
 
         if [:max, :min].include? method and args.length == 0
-          return super unless node.is_method?
-          process S(:send, s(:const, nil, :Math), node.children[1],
-            s(:splat, target))
+          if target.type == :array
+            process S(:send, s(:const, nil, :Math), node.children[1],
+              *target.children)
+          elsif node.is_method?
+            process S(:send, s(:const, nil, :Math), node.children[1],
+              s(:splat, target))
+          else
+            return super
+          end
 
-        elsif method == :call and target and target.type == :ivar
-          process S(:send, s(:self), "_#{target.children.first.to_s[1..-1]}",
-            *args)
+        elsif method == :call and target and 
+          (%i[ivar cvar].include?(target.type) or not excluded?(:call))
 
-        elsif method == :call and target and target.type == :cvar
-          process S(:send, s(:attr, s(:self), :constructor),
-            "_#{target.children.first.to_s[2..-1]}", *args)
+          S(:call, process(target), nil, *process_all(args))
 
         elsif method == :keys and args.length == 0 and node.is_method?
           process S(:send, s(:const, nil, :Object), :keys, target)
 
         elsif method == :[]= and args.length == 3 and
           args[0].type == :regexp and args[1].type == :int
+
           index = args[1].children.first
 
-          parts = Regexp::Parser.parse(args[0].children.first.children.first)
-          split = parts.index do |part|
-            part.type == :group and part.number == index
+          # identify groups
+          regex = args[0].children.first.children.first
+          tokens = Regexp::Scanner.scan(regex)
+          groups = []
+          stack = []
+          tokens.each do |token|
+            next unless token[0] == :group
+            if token[1] == :capture
+              groups.push token.dup
+              return super if groups.length == index and not stack.empty?
+              stack.push groups.last
+            elsif token[1] == :close
+              stack.pop[-1]=token.last
+            end
           end
+          group = groups[index-1]
 
-          return super unless split
+          # rewrite regex
+          prepend = nil
+          append = nil
 
-          rewritten = parts[split].to_s
-
-          dstr = [args.last]
-          if rewritten == '()'
-            index -= 1
-            rewritten = ''
+          if group[4] < regex.length
+            regex = (regex[0...group[4]] + '(' + regex[group[4]..-1] + ')').
+              sub(/\$\)$/, ')$')
+            append = 2
           end
 
-          parts = parts.to_a
-
-          pre = ''
-          if parts.first.type == :anchor
-            pre = parts.shift.to_s
-            split -= 1
+          if group[4] - group[3] == 2
+            regex = regex[0...group[3]] + regex[group[4]..-1]
+            append = 1 if append
           end
 
-          if split > 0
-            if split == 1 and parts.first.type == :group
-              rewritten = parts.first.to_s + rewritten
-            else
-              rewritten = '(' + parts[0 .. split - 1].join + ')' + rewritten
-              index += 1
-            end
-            dstr.unshift s(:send, s(:lvar, :match), :[], s(:int, 0))
+          if group[3] > 0
+            regex = ('(' + regex[0...group[3]] + ')' + regex[group[3]..-1]).
+              sub(/^\(\^/, '^(')
+            prepend = 1
+            append += 1 if append
           end
 
+          regex = process s(:regexp, s(:str, regex), args[0].children.last)
 
-          post = ''
-          if parts.last.type == :anchor
-            post = parts.pop.to_s
-          end
-
-          if split + 1 < parts.length
-            if split  + 2 == parts.length and parts.last.type == :group
-              rewritten += parts.last.to_s
-            else
-              rewritten += '(' + parts[split + 1 .. -1].join + ')'
+          # 
+          if args.last.type == :str
+            str = args.last.children.first.gsub('$', '$$')
+            str = "$#{prepend}#{str}" if prepend
+            str = "#{str}$#{append}" if append
+            expr = s(:send, target, :replace, regex, s(:str, str))
+          else
+            dstr = args.last.type == :dstr ? args.last.children.dup : [args.last]
+            if prepend
+              dstr.unshift s(:send, s(:lvar, :match), :[], s(:int, prepend-1))
+            end
+            if append
+              dstr << s(:send, s(:lvar, :match), :[], s(:int, append-1))
             end
-            dstr << s(:send, s(:lvar, :match), :[], s(:int, index))
-          end
-
-          rewritten = pre + rewritten + post
 
-          regex = process s(:regexp, s(:str, rewritten), args[0].children.last)
-          block = s(:block,
-            s(:send, target, :replace, regex),
-            s(:args, s(:arg, :match)),
-            process(s(:dstr, *dstr)))
+            expr = s(:block,
+              s(:send, target, :replace, regex),
+              s(:args, s(:arg, :match)),
+              process(s(:dstr, *dstr)))
+          end
 
           if VAR_TO_ASSIGN.keys.include? target.type
-            S(VAR_TO_ASSIGN[target.type], target.children.first, block)
+            S(VAR_TO_ASSIGN[target.type], target.children.first, expr)
           elsif target.type == :send
             if target.children[0] == nil
-              S(:lvasgn, target.children[1], block)
+              S(:lvasgn, target.children[1], expr)
             else
-              S(:send, target.children[0], :"#{target.children[1]}=", block)
+              S(:send, target.children[0], :"#{target.children[1]}=", expr)
             end
           else
             super
@@ -116,57 +127,14 @@ module Ruby2JS
         elsif method == :merge
           args.unshift target
 
-          if es2015
-            if es2018
-              process S(:hash, *args.map {|arg| s(:kwsplat, arg)})
-            else
-              process S(:send, s(:const, nil, :Object), :assign, s(:hash),
-                *args)
-            end
+          if es2018
+            process S(:hash, *args.map {|arg| s(:kwsplat, arg)})
           else
-            copy = [s(:gvasgn, :$$, s(:hash))]
-
-            s(:send, s(:block, s(:send, nil, :lambda), s(:args),
-              s(:begin, *copy, *args.map {|modname|
-              if modname.type == :hash
-                s(:begin, *modname.children.map {|pair|
-                    s(:send, s(:gvar, :$$), :[]=, *pair.children)
-                  })
-              else
-                s(:for, s(:lvasgn, :$_), modname,
-                s(:send, s(:gvar, :$$), :[]=,
-                s(:lvar, :$_), s(:send, modname, :[], s(:lvar, :$_))))
-              end
-              }, s(:return, s(:gvar, :$$)))), :[])
+            process S(:assign, s(:hash), *args)
           end
 
         elsif method == :merge!
-          if es2015
-            process S(:send, s(:const, nil, :Object), :assign, target, *args)
-          else
-            copy = []
-
-            unless
-               target.type == :send and target.children.length == 2 and
-               target.children[0] == nil
-            then
-               copy << s(:gvasgn, :$0, target)
-               target = s(:gvar, :$0)
-            end
-
-            s(:send, s(:block, s(:send, nil, :lambda), s(:args),
-              s(:begin, *copy, *args.map {|modname|
-              if modname.type == :hash
-                s(:begin, *modname.children.map {|pair|
-                    s(:send, target, :[]=, *pair.children)
-                  })
-              else
-                s(:for, s(:lvasgn, :$_), modname,
-                s(:send, target, :[]=,
-                s(:lvar, :$_), s(:send, modname, :[], s(:lvar, :$_))))
-              end
-              }, s(:return, target))), :[])
-          end
+          process S(:assign, target, *args)
 
         elsif method == :delete and args.length == 1
           if not target
@@ -242,10 +210,10 @@ module Ruby2JS
                 s(:block, s(:send, nil, :proc), s(:args, s(:arg, :s)),
                   s(:send, s(:lvar, :s), :slice, s(:int, 1))))
             else
-              # str.match(/.../g).map(s => s.match(/.../).slice(1))
+              # (str.match(/.../g) || []).map(s => s.match(/.../).slice(1))
               s(:block, s(:send,
-                s(:send, process(target), :match, gpattern), :map),
-                s(:args, s(:arg, :s)),
+                s(:or, s(:send, process(target), :match, gpattern), s(:array)),
+                :map), s(:args, s(:arg, :s)),
                 s(:return, s(:send, s(:send, s(:lvar, :s), :match, arg),
                 :slice, s(:int, 1))))
             end
@@ -540,6 +508,55 @@ module Ruby2JS
         elsif method == :floor and args.length == 0
           process S(:send, s(:const, nil, :Math), :floor, target)
 
+        elsif method == :rand and target == nil
+          if args.length == 0
+            process S(:send!, s(:const, nil, :Math), :random)
+          elsif %i[irange erange].include? args.first.type
+            range = args.first
+            multiplier = s(:send, range.children.last, :-, range.children.first)
+            if range.children.all? {|child| child.type == :int}
+              multiplier = s(:int, range.children.last.children.last - range.children.first.children.last)
+              multiplier = s(:int, multiplier.children.first + 1) if range.type == :irange
+            elsif range.type == :irange
+              if multiplier.children.last.type == :int
+                diff = multiplier.children.last.children.last - 1
+                multiplier = s(:send, *multiplier.children[0..1], s(:int, diff))
+                multiplier = multiplier.children.first if diff == 0
+                multiplier = s(:send, multiplier.children[0], :+, s(:int, -diff)) if diff < 0
+              else
+                multiplier = s(:send, multiplier, :+, s(:int, 1))
+              end
+            end
+            raw = s(:send, s(:send, s(:const, nil, :Math), :random), :*, multiplier)
+            if range.children.first != s(:int, 0)
+              raw = s(:send, raw, :+, range.children.first)
+            end
+            process S(:send, nil, :parseInt, raw)
+          else
+            process S(:send, nil, :parseInt,
+              s(:send, s(:send, s(:const, nil, :Math), :random),
+              :*, args.first))
+          end
+
+        elsif method == :sum and args.length == 0
+          process S(:send, target, :reduce, s(:block, s(:send, nil, :proc),
+            s(:args, s(:arg, :a), s(:arg, :b)),
+            s(:send, s(:lvar, :a), :+, s(:lvar, :b))), s(:int, 0))
+
+        elsif method == :method_defined? and args.length >= 1
+          if args[1] == s(:false)
+            process S(:send, s(:attr, target, :prototype), :hasOwnProperty, args[0])
+          elsif args.length == 1 or args[1] == s(:true)
+            process S(:in?, args[0], s(:attr, target, :prototype))
+          else
+            process S(:if, args[1], s(:in?, args[0], s(:attr, target, :prototype)),
+              s(:send, s(:attr, target, :prototype), :hasOwnProperty, args[0]))
+          end
+
+        elsif method == :alias_method and args.length == 2
+          process S(:send, s(:attr, target, :prototype), :[]=, args[0],
+            s(:attr, s(:attr, target, :prototype), args[1].children[0]))
+
         else
           super
         end
@@ -726,6 +743,10 @@ module Ruby2JS
             s(:return, s(:lvar, node.children[1].children[0].children[0])))),
             :[], call.children[0]])
 
+        elsif method == :define_method and call.children.length == 3
+          process node.updated(:send, [s(:attr, call.children[0], :prototype), :[]=,
+            call.children[2], s(:deff, nil, *node.children[1..-1])])
+
         else
           super
         end
@@ -735,6 +756,12 @@ module Ruby2JS
         name, inheritance, *body = node.children
         body.compact!
 
+        body.each_with_index do |node, i|
+          if node.type == :send and node.children[0..1] == [nil, :alias_method]
+            body[i] = node.updated(:send, [name, *node.children[1..-1]])
+          end
+        end
+
         if inheritance == s(:const, nil, :Exception)
           unless
             body.any? {|statement| statement.type == :def and
@@ -750,7 +777,8 @@ module Ruby2JS
           body = [s(:begin, *body)] if body.length > 1
           S(:class, name, s(:const, nil, :Error), *body)
         else
-          super
+          body = [s(:begin, *body)] if body.length > 1
+          super S(:class, name, inheritance, *body)
         end
       end
     end