diff --git a/src/js/binaryen.js-post.js b/src/js/binaryen.js-post.js
index c9fb62e5f47..55e3c609a29 100644
--- a/src/js/binaryen.js-post.js
+++ b/src/js/binaryen.js-post.js
@@ -29,7 +29,9 @@ function i8sToStack(i8s) {
 function initializeConstants() {
 
   // Types
-  [ ['none', 'None'],
+  Module['Type'] = {};
+  [
+    ['none', 'None'],
     ['i32', 'Int32'],
     ['i64', 'Int64'],
     ['f32', 'Float32'],
@@ -49,9 +51,11 @@ function initializeConstants() {
     ['unreachable', 'Unreachable'],
     ['auto', 'Auto']
   ].forEach(entry => {
-    Module[entry[0]] = Module['_BinaryenType' + entry[1]]();
+    Module['Type'][entry[0]] = Module['_BinaryenType' + entry[1]]();
   });
 
+  // Heap types
+  Module['HeapType'] = {};
   [
     ['func', 'Func'],
     ['extern', 'Ext'],
@@ -61,22 +65,21 @@ function initializeConstants() {
     ['struct', 'Struct'],
     ['array', 'Array'],
     ['string', 'String'],
-    /*
-    TODO: Reconcile with `none` above (line 32).
-    Maybe keep this as 'none' and change the above to 'void'?
     ['none', 'None'],
-    */
     ['noextern', 'Noext'],
     ['nofunc', 'Nofunc'],
   ].forEach(entry => {
-    Module[entry[0]] = Module['_BinaryenHeapType' + entry[1]]();
+    Module['HeapType'][entry[0]] = Module['_BinaryenHeapType' + entry[1]]();
   });
 
-  [ ['notPacked', 'NotPacked'],
+  // Packed types
+  Module['PackedType'] = {};
+  [
+    ['notPacked', 'NotPacked'],
     ['i8', 'Int8'],
     ['i16', 'Int16']
   ].forEach(entry => {
-    Module[entry[0]] = Module['_BinaryenPackedType' + entry[1]]();
+    Module['PackedType'][entry[0]] = Module['_BinaryenPackedType' + entry[1]]();
   });
 
   // Expression ids
@@ -708,7 +711,7 @@ function wrapModule(module, self = {}) {
     return preserveStack(() =>
       Module['_BinaryenBlock'](module, name ? strToStack(name) : 0,
                                i32sToStack(children), children.length,
-                               typeof type !== 'undefined' ? type : Module['none'])
+                               typeof type !== 'undefined' ? type : Module['Type']['none'])
     );
   };
   self['if'] = function(condition, ifTrue, ifFalse) {
@@ -811,10 +814,10 @@ function wrapModule(module, self = {}) {
         return preserveStack(() => Module['_BinaryenAtomicNotify'](module, ptr, notifyCount, strToStack(name)));
       },
       'wait32'(ptr, expected, timeout, name) {
-        return preserveStack(() => Module['_BinaryenAtomicWait'](module, ptr, expected, timeout, Module['i32'], strToStack(name)));
+        return preserveStack(() => Module['_BinaryenAtomicWait'](module, ptr, expected, timeout, Module['Type']['i32'], strToStack(name)));
       },
       'wait64'(ptr, expected, timeout, name) {
-        return preserveStack(() => Module['_BinaryenAtomicWait'](module, ptr, expected, timeout, Module['i64'], strToStack(name)));
+        return preserveStack(() => Module['_BinaryenAtomicWait'](module, ptr, expected, timeout, Module['Type']['i64'], strToStack(name)));
       }
     }
   }
@@ -827,28 +830,28 @@ function wrapModule(module, self = {}) {
 
   self['i32'] = {
     'load'(offset, align, ptr, name) {
-      return preserveStack(() => Module['_BinaryenLoad'](module, 4, true, offset, align, Module['i32'], ptr, strToStack(name)));
+      return preserveStack(() => Module['_BinaryenLoad'](module, 4, true, offset, align, Module['Type']['i32'], ptr, strToStack(name)));
     },
     'load8_s'(offset, align, ptr, name) {
-      return preserveStack(() => Module['_BinaryenLoad'](module, 1, true, offset, align, Module['i32'], ptr, strToStack(name)));
+      return preserveStack(() => Module['_BinaryenLoad'](module, 1, true, offset, align, Module['Type']['i32'], ptr, strToStack(name)));
     },
     'load8_u'(offset, align, ptr, name) {
-      return preserveStack(() => Module['_BinaryenLoad'](module, 1, false, offset, align, Module['i32'], ptr, strToStack(name)));
+      return preserveStack(() => Module['_BinaryenLoad'](module, 1, false, offset, align, Module['Type']['i32'], ptr, strToStack(name)));
     },
     'load16_s'(offset, align, ptr, name) {
-      return preserveStack(() => Module['_BinaryenLoad'](module, 2, true, offset, align, Module['i32'], ptr, strToStack(name)));
+      return preserveStack(() => Module['_BinaryenLoad'](module, 2, true, offset, align, Module['Type']['i32'], ptr, strToStack(name)));
     },
     'load16_u'(offset, align, ptr, name) {
-      return preserveStack(() => Module['_BinaryenLoad'](module, 2, false, offset, align, Module['i32'], ptr, strToStack(name)));
+      return preserveStack(() => Module['_BinaryenLoad'](module, 2, false, offset, align, Module['Type']['i32'], ptr, strToStack(name)));
     },
     'store'(offset, align, ptr, value, name) {
-      return preserveStack(() => Module['_BinaryenStore'](module, 4, offset, align, ptr, value, Module['i32'], strToStack(name)));
+      return preserveStack(() => Module['_BinaryenStore'](module, 4, offset, align, ptr, value, Module['Type']['i32'], strToStack(name)));
     },
     'store8'(offset, align, ptr, value, name) {
-      return preserveStack(() => Module['_BinaryenStore'](module, 1, offset, align, ptr, value, Module['i32'], strToStack(name)));
+      return preserveStack(() => Module['_BinaryenStore'](module, 1, offset, align, ptr, value, Module['Type']['i32'], strToStack(name)));
     },
     'store16'(offset, align, ptr, value, name) {
-      return preserveStack(() => Module['_BinaryenStore'](module, 2, offset, align, ptr, value, Module['i32'], strToStack(name)));
+      return preserveStack(() => Module['_BinaryenStore'](module, 2, offset, align, ptr, value, Module['Type']['i32'], strToStack(name)));
     },
     'const'(x) {
       return preserveStack(() => {
@@ -990,152 +993,152 @@ function wrapModule(module, self = {}) {
     },
     'atomic': {
       'load'(offset, ptr, name, order) {
-        return preserveStack(() => Module['_BinaryenAtomicLoad'](module, 4, offset, Module['i32'], ptr, strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+        return preserveStack(() => Module['_BinaryenAtomicLoad'](module, 4, offset, Module['Type']['i32'], ptr, strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
       },
       'load8_u'(offset, ptr, name, order) {
-        return preserveStack(() => Module['_BinaryenAtomicLoad'](module, 1, offset, Module['i32'], ptr, strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+        return preserveStack(() => Module['_BinaryenAtomicLoad'](module, 1, offset, Module['Type']['i32'], ptr, strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
       },
       'load16_u'(offset, ptr, name) {
-        return preserveStack(() => Module['_BinaryenAtomicLoad'](module, 2, offset, Module['i32'], ptr, strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+        return preserveStack(() => Module['_BinaryenAtomicLoad'](module, 2, offset, Module['Type']['i32'], ptr, strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
       },
       'store'(offset, ptr, value, name, order) {
-        return preserveStack(() => Module['_BinaryenAtomicStore'](module, 4, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+        return preserveStack(() => Module['_BinaryenAtomicStore'](module, 4, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
       },
       'store8'(offset, ptr, value, name, order) {
-        return preserveStack(() => Module['_BinaryenAtomicStore'](module, 1, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+        return preserveStack(() => Module['_BinaryenAtomicStore'](module, 1, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
       },
       'store16'(offset, ptr, value, name, order) {
-        return preserveStack(() => Module['_BinaryenAtomicStore'](module, 2, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+        return preserveStack(() => Module['_BinaryenAtomicStore'](module, 2, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
       },
       'rmw': {
         'add'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 4, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 4, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'sub'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 4, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 4, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'and'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 4, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 4, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'or'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 4, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 4, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'xor'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 4, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 4, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'xchg'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 4, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 4, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'cmpxchg'(offset, ptr, expected, replacement, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicCmpxchg'](module, 4, offset, ptr, expected, replacement, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicCmpxchg'](module, 4, offset, ptr, expected, replacement, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
       },
       'rmw8_u': {
         'add'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 1, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 1, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'sub'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 1, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 1, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'and'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 1, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 1, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'or'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 1, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 1, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'xor'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 1, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 1, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'xchg'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 1, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 1, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'cmpxchg'(offset, ptr, expected, replacement, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicCmpxchg'](module, 1, offset, ptr, expected, replacement, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicCmpxchg'](module, 1, offset, ptr, expected, replacement, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
       },
       'rmw16_u': {
         'add'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 2, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 2, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'sub'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 2, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 2, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'and'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 2, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 2, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'or'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 2, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 2, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'xor'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 2, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 2, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'xchg'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 2, offset, ptr, value, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 2, offset, ptr, value, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'cmpxchg'(offset, ptr, expected, replacement, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicCmpxchg'](module, 2, offset, ptr, expected, replacement, Module['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicCmpxchg'](module, 2, offset, ptr, expected, replacement, Module['Type']['i32'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
       },
     },
     'pop'() {
-      return Module['_BinaryenPop'](module, Module['i32']);
+      return Module['_BinaryenPop'](module, Module['Type']['i32']);
     }
   };
 
   self['i64'] = {
     'load'(offset, align, ptr, name) {
-      return preserveStack(() => Module['_BinaryenLoad'](module, 8, true, offset, align, Module['i64'], ptr, strToStack(name)));
+      return preserveStack(() => Module['_BinaryenLoad'](module, 8, true, offset, align, Module['Type']['i64'], ptr, strToStack(name)));
     },
     'load8_s'(offset, align, ptr, name) {
-      return preserveStack(() => Module['_BinaryenLoad'](module, 1, true, offset, align, Module['i64'], ptr, strToStack(name)));
+      return preserveStack(() => Module['_BinaryenLoad'](module, 1, true, offset, align, Module['Type']['i64'], ptr, strToStack(name)));
     },
     'load8_u'(offset, align, ptr, name) {
-      return preserveStack(() => Module['_BinaryenLoad'](module, 1, false, offset, align, Module['i64'], ptr, strToStack(name)));
+      return preserveStack(() => Module['_BinaryenLoad'](module, 1, false, offset, align, Module['Type']['i64'], ptr, strToStack(name)));
     },
     'load16_s'(offset, align, ptr, name) {
-      return preserveStack(() => Module['_BinaryenLoad'](module, 2, true, offset, align, Module['i64'], ptr, strToStack(name)));
+      return preserveStack(() => Module['_BinaryenLoad'](module, 2, true, offset, align, Module['Type']['i64'], ptr, strToStack(name)));
     },
     'load16_u'(offset, align, ptr, name) {
-      return preserveStack(() => Module['_BinaryenLoad'](module, 2, false, offset, align, Module['i64'], ptr, strToStack(name)));
+      return preserveStack(() => Module['_BinaryenLoad'](module, 2, false, offset, align, Module['Type']['i64'], ptr, strToStack(name)));
     },
     'load32_s'(offset, align, ptr, name) {
-      return preserveStack(() => Module['_BinaryenLoad'](module, 4, true, offset, align, Module['i64'], ptr, strToStack(name)));
+      return preserveStack(() => Module['_BinaryenLoad'](module, 4, true, offset, align, Module['Type']['i64'], ptr, strToStack(name)));
     },
     'load32_u'(offset, align, ptr, name) {
-      return preserveStack(() => Module['_BinaryenLoad'](module, 4, false, offset, align, Module['i64'], ptr, strToStack(name)));
+      return preserveStack(() => Module['_BinaryenLoad'](module, 4, false, offset, align, Module['Type']['i64'], ptr, strToStack(name)));
     },
     'store'(offset, align, ptr, value, name) {
-      return preserveStack(() => Module['_BinaryenStore'](module, 8, offset, align, ptr, value, Module['i64'], strToStack(name)));
+      return preserveStack(() => Module['_BinaryenStore'](module, 8, offset, align, ptr, value, Module['Type']['i64'], strToStack(name)));
     },
     'store8'(offset, align, ptr, value, name) {
-      return preserveStack(() => Module['_BinaryenStore'](module, 1, offset, align, ptr, value, Module['i64'], strToStack(name)));
+      return preserveStack(() => Module['_BinaryenStore'](module, 1, offset, align, ptr, value, Module['Type']['i64'], strToStack(name)));
     },
     'store16'(offset, align, ptr, value, name) {
-      return preserveStack(() => Module['_BinaryenStore'](module, 2, offset, align, ptr, value, Module['i64'], strToStack(name)));
+      return preserveStack(() => Module['_BinaryenStore'](module, 2, offset, align, ptr, value, Module['Type']['i64'], strToStack(name)));
     },
     'store32'(offset, align, ptr, value, name) {
-      return preserveStack(() => Module['_BinaryenStore'](module, 4, offset, align, ptr, value, Module['i64'], strToStack(name)));
+      return preserveStack(() => Module['_BinaryenStore'](module, 4, offset, align, ptr, value, Module['Type']['i64'], strToStack(name)));
     },
     'const'(x, y = undefined) {
       return preserveStack(() => {
@@ -1302,161 +1305,161 @@ function wrapModule(module, self = {}) {
     },
     'atomic': {
       'load'(offset, ptr, name, order) {
-        return preserveStack(() => Module['_BinaryenAtomicLoad'](module, 8, offset, Module['i64'], ptr, strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+        return preserveStack(() => Module['_BinaryenAtomicLoad'](module, 8, offset, Module['Type']['i64'], ptr, strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
       },
       'load8_u'(offset, ptr, name, order) {
-        return preserveStack(() => Module['_BinaryenAtomicLoad'](module, 1, offset, Module['i64'], ptr, strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+        return preserveStack(() => Module['_BinaryenAtomicLoad'](module, 1, offset, Module['Type']['i64'], ptr, strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
       },
       'load16_u'(offset, ptr, name, order) {
-        return preserveStack(() => Module['_BinaryenAtomicLoad'](module, 2, offset, Module['i64'], ptr, strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+        return preserveStack(() => Module['_BinaryenAtomicLoad'](module, 2, offset, Module['Type']['i64'], ptr, strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
       },
       'load32_u'(offset, ptr, name, order) {
-        return preserveStack(() => Module['_BinaryenAtomicLoad'](module, 4, offset, Module['i64'], ptr, strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+        return preserveStack(() => Module['_BinaryenAtomicLoad'](module, 4, offset, Module['Type']['i64'], ptr, strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
       },
       'store'(offset, ptr, value, name, order) {
-        return preserveStack(() => Module['_BinaryenAtomicStore'](module, 8, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+        return preserveStack(() => Module['_BinaryenAtomicStore'](module, 8, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
       },
       'store8'(offset, ptr, value, name, order) {
-        return preserveStack(() => Module['_BinaryenAtomicStore'](module, 1, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+        return preserveStack(() => Module['_BinaryenAtomicStore'](module, 1, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
       },
       'store16'(offset, ptr, value, name, order) {
-        return preserveStack(() => Module['_BinaryenAtomicStore'](module, 2, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+        return preserveStack(() => Module['_BinaryenAtomicStore'](module, 2, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
       },
       'store32'(offset, ptr, value, name, order) {
-        return preserveStack(() => Module['_BinaryenAtomicStore'](module, 4, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+        return preserveStack(() => Module['_BinaryenAtomicStore'](module, 4, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
       },
       'rmw': {
         'add'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 8, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 8, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'sub'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 8, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 8, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'and'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 8, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 8, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'or'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 8, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 8, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'xor'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 8, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 8, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'xchg'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 8, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 8, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'cmpxchg'(offset, ptr, expected, replacement, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicCmpxchg'](module, 8, offset, ptr, expected, replacement, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicCmpxchg'](module, 8, offset, ptr, expected, replacement, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
       },
       'rmw8_u': {
         'add'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 1, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 1, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'sub'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 1, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 1, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'and'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 1, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 1, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'or'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 1, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 1, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'xor'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 1, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 1, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'xchg'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 1, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 1, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'cmpxchg'(offset, ptr, expected, replacement, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicCmpxchg'](module, 1, offset, ptr, expected, replacement, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicCmpxchg'](module, 1, offset, ptr, expected, replacement, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
       },
       'rmw16_u': {
         'add'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 2, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 2, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'sub'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 2, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 2, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'and'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 2, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 2, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'or'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 2, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 2, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'xor'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 2, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 2, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'xchg'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 2, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 2, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'cmpxchg'(offset, ptr, expected, replacement, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicCmpxchg'](module, 2, offset, ptr, expected, replacement, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicCmpxchg'](module, 2, offset, ptr, expected, replacement, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
       },
       'rmw32_u': {
         'add'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 4, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAdd'], 4, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'sub'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 4, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWSub'], 4, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'and'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 4, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWAnd'], 4, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'or'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 4, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWOr'], 4, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'xor'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 4, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXor'], 4, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'xchg'(offset, ptr, value, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 4, offset, ptr, value, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicRMW'](module, Module['AtomicRMWXchg'], 4, offset, ptr, value, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
         'cmpxchg'(offset, ptr, expected, replacement, name, order) {
           return preserveStack(() =>
-            Module['_BinaryenAtomicCmpxchg'](module, 4, offset, ptr, expected, replacement, Module['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
+            Module['_BinaryenAtomicCmpxchg'](module, 4, offset, ptr, expected, replacement, Module['Type']['i64'], strToStack(name), typeof order !== 'undefined' ? order : Module['MemoryOrder']['seqcst']));
         },
       },
     },
     'pop'() {
-      return Module['_BinaryenPop'](module, Module['i64']);
+      return Module['_BinaryenPop'](module, Module['Type']['i64']);
     }
   };
 
   self['f32'] = {
     'load'(offset, align, ptr, name) {
-      return preserveStack(() => Module['_BinaryenLoad'](module, 4, true, offset, align, Module['f32'], ptr, strToStack(name)));
+      return preserveStack(() => Module['_BinaryenLoad'](module, 4, true, offset, align, Module['Type']['f32'], ptr, strToStack(name)));
     },
     'store'(offset, align, ptr, value, name) {
-      return preserveStack(() => Module['_BinaryenStore'](module, 4, offset, align, ptr, value, Module['f32'], strToStack(name)));
+      return preserveStack(() => Module['_BinaryenStore'](module, 4, offset, align, ptr, value, Module['Type']['f32'], strToStack(name)));
     },
     'const'(x) {
       return preserveStack(() => {
@@ -1555,16 +1558,16 @@ function wrapModule(module, self = {}) {
       return Module['_BinaryenBinary'](module, Module['GeFloat32'], left, right);
     },
     'pop'() {
-      return Module['_BinaryenPop'](module, Module['f32']);
+      return Module['_BinaryenPop'](module, Module['Type']['f32']);
     }
   };
 
   self['f64'] = {
     'load'(offset, align, ptr, name) {
-      return preserveStack(() => Module['_BinaryenLoad'](module, 8, true, offset, align, Module['f64'], ptr, strToStack(name)));
+      return preserveStack(() => Module['_BinaryenLoad'](module, 8, true, offset, align, Module['Type']['f64'], ptr, strToStack(name)));
     },
     'store'(offset, align, ptr, value, name) {
-      return preserveStack(() => Module['_BinaryenStore'](module, 8, offset, align, ptr, value, Module['f64'], strToStack(name)));
+      return preserveStack(() => Module['_BinaryenStore'](module, 8, offset, align, ptr, value, Module['Type']['f64'], strToStack(name)));
     },
     'const'(x) {
       return preserveStack(() => {
@@ -1668,13 +1671,13 @@ function wrapModule(module, self = {}) {
       return Module['_BinaryenBinary'](module, Module['GeFloat64'], left, right);
     },
     'pop'() {
-      return Module['_BinaryenPop'](module, Module['f64']);
+      return Module['_BinaryenPop'](module, Module['Type']['f64']);
     }
   };
 
   self['v128'] = {
     'load'(offset, align, ptr, name) {
-      return preserveStack(() => Module['_BinaryenLoad'](module, 16, false, offset, align, Module['v128'], ptr, strToStack(name)));
+      return preserveStack(() => Module['_BinaryenLoad'](module, 16, false, offset, align, Module['Type']['v128'], ptr, strToStack(name)));
     },
     'load8_splat'(offset, align, ptr, name) {
       return preserveStack(() => Module['_BinaryenSIMDLoad'](module, Module['Load8SplatVec128'], offset, align, ptr, strToStack(name)));
@@ -1745,7 +1748,7 @@ function wrapModule(module, self = {}) {
         Module['_BinaryenSIMDLoadStoreLane'](module, Module['Store64LaneVec128'], offset, align, index, ptr, vec, strToStack(name)));
     },
     'store'(offset, align, ptr, value, name) {
-      return preserveStack(() => Module['_BinaryenStore'](module, 16, offset, align, ptr, value, Module['v128'], strToStack(name)));
+      return preserveStack(() => Module['_BinaryenStore'](module, 16, offset, align, ptr, value, Module['Type']['v128'], strToStack(name)));
     },
     'const'(i8s) {
       return preserveStack(() => {
@@ -1776,7 +1779,7 @@ function wrapModule(module, self = {}) {
       return Module['_BinaryenSIMDTernary'](module, Module['BitselectVec128'], left, right, cond);
     },
     'pop'() {
-      return Module['_BinaryenPop'](module, Module['v128']);
+      return Module['_BinaryenPop'](module, Module['Type']['v128']);
     }
   };
 
@@ -2418,49 +2421,49 @@ function wrapModule(module, self = {}) {
 
   self['funcref'] = {
     'pop'() {
-      return Module['_BinaryenPop'](module, Module['funcref']);
+      return Module['_BinaryenPop'](module, Module['Type']['funcref']);
     }
   };
 
   self['externref'] = {
     'pop'() {
-      return Module['_BinaryenPop'](module, Module['externref']);
+      return Module['_BinaryenPop'](module, Module['Type']['externref']);
     }
   };
 
   self['anyref'] = {
     'pop'() {
-      return Module['_BinaryenPop'](module, Module['anyref']);
+      return Module['_BinaryenPop'](module, Module['Type']['anyref']);
     }
   };
 
   self['eqref'] = {
     'pop'() {
-      return Module['_BinaryenPop'](module, Module['eqref']);
+      return Module['_BinaryenPop'](module, Module['Type']['eqref']);
     }
   };
 
   self['i31ref'] = {
     'pop'() {
-      return Module['_BinaryenPop'](module, Module['i31ref']);
+      return Module['_BinaryenPop'](module, Module['Type']['i31ref']);
     }
   };
 
   self['structref'] = {
     'pop'() {
-      return Module['_BinaryenPop'](module, Module['structref']);
+      return Module['_BinaryenPop'](module, Module['Type']['structref']);
     }
   };
 
   self['arrayref'] = {
     'pop'() {
-      return Module['_BinaryenPop'](module, Module['arrayref']);
+      return Module['_BinaryenPop'](module, Module['Type']['arrayref']);
     }
   };
 
   self['stringref'] = {
     'pop'() {
-      return Module['_BinaryenPop'](module, Module['stringref']);
+      return Module['_BinaryenPop'](module, Module['Type']['stringref']);
     }
   };
 
@@ -2567,11 +2570,11 @@ function wrapModule(module, self = {}) {
   };
 
   self['br_on_null'] = function(name, value) {
-    return preserveStack(() => Module['_BinaryenBrOn'](module, Module['BrOnNull'], strToStack(name), value, Module['unreachable']));
+    return preserveStack(() => Module['_BinaryenBrOn'](module, Module['BrOnNull'], strToStack(name), value, Module['Type']['unreachable']));
   };
 
   self['br_on_non_null'] = function(name, value) {
-    return preserveStack(() => Module['_BinaryenBrOn'](module, Module['BrOnNonNull'], strToStack(name), value, Module['unreachable']));
+    return preserveStack(() => Module['_BinaryenBrOn'](module, Module['BrOnNonNull'], strToStack(name), value, Module['Type']['unreachable']));
   };
 
   self['br_on_cast'] = function(name, value, castType) {
@@ -3224,11 +3227,11 @@ Module['getExpressionInfo'] = function(expr) {
   switch (id) {
     case Module['ConstId']:
       switch (type) {
-        case Module['i32']: info.value = Module['_BinaryenConstGetValueI32'](expr); break;
-        case Module['i64']: info.value = Module['_BinaryenConstGetValueI64'](expr); break;
-        case Module['f32']: info.value = Module['_BinaryenConstGetValueF32'](expr); break;
-        case Module['f64']: info.value = Module['_BinaryenConstGetValueF64'](expr); break;
-        case Module['v128']: {
+        case Module['Type']['i32']: info.value = Module['_BinaryenConstGetValueI32'](expr); break;
+        case Module['Type']['i64']: info.value = Module['_BinaryenConstGetValueI64'](expr); break;
+        case Module['Type']['f32']: info.value = Module['_BinaryenConstGetValueF32'](expr); break;
+        case Module['Type']['f64']: info.value = Module['_BinaryenConstGetValueF64'](expr); break;
+        case Module['Type']['v128']: {
           preserveStack(() => {
             const tempBuffer = stackAlloc(16);
             Module['_BinaryenConstGetValueV128'](expr, tempBuffer);
diff --git a/test/binaryen.js/atomics.js b/test/binaryen.js/atomics.js
index 5eabd211e2e..52e430d9e22 100644
--- a/test/binaryen.js/atomics.js
+++ b/test/binaryen.js/atomics.js
@@ -7,7 +7,7 @@ var wast = `
 var module = binaryen.parseText(wast);
 
 // i32/i64.atomic.load/store
-module.addFunction("main", binaryen.none, binaryen.none, [], module.block("", [
+module.addFunction("main", binaryen.Type.none, binaryen.Type.none, [], module.block("", [
   // i32
   module.i32.atomic.store(0,
     module.i32.const(0),
diff --git a/test/binaryen.js/copy-expression.js b/test/binaryen.js/copy-expression.js
index 261c028faba..f6145d1fc94 100644
--- a/test/binaryen.js/copy-expression.js
+++ b/test/binaryen.js/copy-expression.js
@@ -3,11 +3,11 @@ var module = new binaryen.Module();
 // Create an expression and copy it
 var original = module.block(null, [
   module.if(
-    module.local.get(0, binaryen.i32),
+    module.local.get(0, binaryen.Type.i32),
     module.i32.const(1),
     module.i32.const(2)
   )
-], binaryen.i32);
+], binaryen.Type.i32);
 var copy = module.copyExpression(original);
 
 // Check that the expression incl. sub-expressions are copies
diff --git a/test/binaryen.js/emit_asmjs.js b/test/binaryen.js/emit_asmjs.js
index e7b9afee2a7..de4c4055305 100644
--- a/test/binaryen.js/emit_asmjs.js
+++ b/test/binaryen.js/emit_asmjs.js
@@ -1,6 +1,6 @@
 var module = new binaryen.Module();
 
-module.addFunction("main", binaryen.i32, binaryen.i32, [], module.local.get(0, binaryen.i32));
+module.addFunction("main", binaryen.Type.i32, binaryen.Type.i32, [], module.local.get(0, binaryen.Type.i32));
 
 module.addFunctionExport("main", "main");
 
diff --git a/test/binaryen.js/exception-handling.js b/test/binaryen.js/exception-handling.js
index ec158552124..82c56b7630d 100644
--- a/test/binaryen.js/exception-handling.js
+++ b/test/binaryen.js/exception-handling.js
@@ -19,7 +19,7 @@ var module = new binaryen.Module();
 module.setFeatures(binaryen.Features.ReferenceTypes |
                    binaryen.Features.ExceptionHandling);
 
-module.addTag("e", binaryen.i32, binaryen.none);
+module.addTag("e", binaryen.Type.i32, binaryen.Type.none);
 
 // (try $l0
 //   (do
@@ -42,7 +42,7 @@ var try_catch = module.try(
         module.drop(module.i32.pop()),
         rethrow
       ],
-      binaryen.none
+      binaryen.Type.none
     )
   ],
   ''
@@ -74,7 +74,7 @@ var try_delegate = module.try(
 );
 
 var body = module.block('', [try_catch, try_delegate])
-var func = module.addFunction("test", binaryen.none, binaryen.none, [], body);
+var func = module.addFunction("test", binaryen.Type.none, binaryen.Type.none, [], body);
 
 console.log(module.emitText());
 assert(module.validate());
diff --git a/test/binaryen.js/expressionrunner.js b/test/binaryen.js/expressionrunner.js
index 9535b3eeca7..1834c91ec4f 100644
--- a/test/binaryen.js/expressionrunner.js
+++ b/test/binaryen.js/expressionrunner.js
@@ -12,7 +12,7 @@ function assertDeepEqual(x, y) {
 }
 
 var module = new binaryen.Module();
-module.addGlobal("aGlobal", binaryen.i32, true, module.i32.const(0));
+module.addGlobal("aGlobal", binaryen.Type.i32, true, module.i32.const(0));
 
 // Should evaluate down to a constant
 var runner = new binaryen.ExpressionRunner(module);
@@ -26,7 +26,7 @@ assertDeepEqual(
   binaryen.getExpressionInfo(expr),
   {
     id: binaryen.ExpressionIds.Const,
-    type: binaryen.i32,
+    type: binaryen.Type.i32,
     value: 3
   }
 );
@@ -47,7 +47,7 @@ assertDeepEqual(
   binaryen.getExpressionInfo(expr),
   {
     id: binaryen.ExpressionIds.Const,
-    type: binaryen.i32,
+    type: binaryen.Type.i32,
     value: 4
   }
 );
@@ -56,7 +56,7 @@ assertDeepEqual(
 runner = new binaryen.ExpressionRunner(module);
 expr = runner.runAndDispose(
   module.i32.add(
-    module.local.get(0, binaryen.i32),
+    module.local.get(0, binaryen.Type.i32),
     module.i32.const(1)
   )
 );
@@ -73,7 +73,7 @@ assert(expr === 0);
 runner = new binaryen.ExpressionRunner(module);
 expr = runner.runAndDispose(
   module.i32.add(
-    module.local.tee(0, module.i32.const(4), binaryen.i32),
+    module.local.tee(0, module.i32.const(4), binaryen.Type.i32),
     module.i32.const(1)
   )
 );
@@ -81,7 +81,7 @@ assertDeepEqual(
   binaryen.getExpressionInfo(expr),
   {
     id: binaryen.ExpressionIds.Const,
-    type: binaryen.i32,
+    type: binaryen.Type.i32,
     value: 5
   }
 );
@@ -90,7 +90,7 @@ assertDeepEqual(
 runner = new binaryen.ExpressionRunner(module, Flags.PreserveSideeffects);
 expr = runner.runAndDispose(
   module.i32.add(
-    module.local.tee(0, module.i32.const(4), binaryen.i32),
+    module.local.tee(0, module.i32.const(4), binaryen.Type.i32),
     module.i32.const(1)
   )
 );
@@ -102,19 +102,19 @@ expr = runner.runAndDispose(
   module.i32.add(
     module.block(null, [
       module.local.set(0, module.i32.const(2)),
-      module.local.get(0, binaryen.i32)
-    ], binaryen.i32),
+      module.local.get(0, binaryen.Type.i32)
+    ], binaryen.Type.i32),
     module.block(null, [
       module.global.set("aGlobal", module.i32.const(4)),
-      module.global.get("aGlobal", binaryen.i32)
-    ], binaryen.i32)
+      module.global.get("aGlobal", binaryen.Type.i32)
+    ], binaryen.Type.i32)
   )
 );
 assertDeepEqual(
   binaryen.getExpressionInfo(expr),
   {
     id: binaryen.ExpressionIds.Const,
-    type: binaryen.i32,
+    type: binaryen.Type.i32,
     value: 6
   }
 );
@@ -125,15 +125,15 @@ assert(runner.setLocalValue(0, module.i32.const(3)));
 assert(runner.setGlobalValue("aGlobal", module.i32.const(4)));
 expr = runner.runAndDispose(
   module.i32.add(
-    module.local.get(0, binaryen.i32),
-    module.global.get("aGlobal", binaryen.i32)
+    module.local.get(0, binaryen.Type.i32),
+    module.global.get("aGlobal", binaryen.Type.i32)
   )
 );
 assertDeepEqual(
   binaryen.getExpressionInfo(expr),
   {
     id: binaryen.ExpressionIds.Const,
-    type: binaryen.i32,
+    type: binaryen.Type.i32,
     value: 7
   }
 );
@@ -146,7 +146,7 @@ expr = runner.runAndDispose(
     module.call("add", [
       module.i32.const(3),
       module.i32.const(4)
-    ], binaryen.i32)
+    ], binaryen.Type.i32)
   )
 );
 assert(expr === 0);
@@ -156,7 +156,7 @@ runner = new binaryen.ExpressionRunner(module, Flags.Default, 1);
 expr = runner.runAndDispose(
   module.block(null, [
     module.i32.const(1),
-  ], binaryen.i32)
+  ], binaryen.Type.i32)
 );
 assert(expr === 0);
 
diff --git a/test/binaryen.js/expressions.js b/test/binaryen.js/expressions.js
index de3550d6f3c..a1cb7120728 100644
--- a/test/binaryen.js/expressions.js
+++ b/test/binaryen.js/expressions.js
@@ -35,7 +35,7 @@ console.log("# Block");
   assert(theBlock instanceof binaryen.Expression);
   assert(theBlock.id === binaryen.BlockId);
   assert(theBlock.name === null);
-  assert(theBlock.type === binaryen.none);
+  assert(theBlock.type === binaryen.Type.none);
   
   var info = binaryen.getExpressionInfo(theBlock);
   assert(info.id === theBlock.id);
@@ -45,8 +45,8 @@ console.log("# Block");
 
   theBlock.name ="theName";
   assert(theBlock.name === "theName");
-  theBlock.type = binaryen.i32;
-  assert(theBlock.type === binaryen.i32);
+  theBlock.type = binaryen.Type.i32;
+  assert(theBlock.type === binaryen.Type.i32);
   assert(theBlock.numChildren === 0);
   assertDeepEqual(theBlock.children, []);
   assertDeepEqual(theBlock.getChildren(), []);
@@ -111,7 +111,7 @@ console.log("# If");
   assert(theIf.condition === condition);
   assert(theIf.ifTrue === ifTrue);
   assert(theIf.ifFalse === ifFalse);
-  assert(theIf.type == binaryen.i32);
+  assert(theIf.type == binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theIf);
   assert(info.id === theIf.id);
@@ -168,7 +168,7 @@ console.log("# Loop");
   assert(theLoop.id === binaryen.LoopId);
   assert(theLoop.name === name);
   assert(theLoop.body === body);
-  assert(theLoop.type === binaryen.i32);
+  assert(theLoop.type === binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theLoop);
   assert(info.id === theLoop.id);
@@ -181,7 +181,7 @@ console.log("# Loop");
   theLoop.body = body = module.drop(body);
   assert(theLoop.body === body);
   theLoop.finalize();
-  assert(theLoop.type === binaryen.none);
+  assert(theLoop.type === binaryen.Type.none);
 
   info = binaryen.getExpressionInfo(theLoop);
   assert(info.type === theLoop.type);
@@ -211,7 +211,7 @@ console.log("# Break");
   assert(theBreak.name === name);
   assert(theBreak.condition === condition);
   assert(theBreak.value === value);
-  assert(theBreak.type === binaryen.i32);
+  assert(theBreak.type === binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theBreak);
   assert(info.id === theBreak.id);
@@ -259,7 +259,7 @@ console.log("# Switch");
   assert(theSwitch.defaultName === defaultName);
   assert(theSwitch.condition === condition);
   assert(theSwitch.value === value);
-  assert(theSwitch.type === binaryen.unreachable);
+  assert(theSwitch.type === binaryen.Type.unreachable);
 
   var info = binaryen.getExpressionInfo(theSwitch);
   assert(info.id === theSwitch.id);
@@ -315,14 +315,14 @@ console.log("# Call");
     module.i32.const(1),
     module.i32.const(2)
   ];
-  const theCall = binaryen.Call(module.call(target, operands, binaryen.i32));
+  const theCall = binaryen.Call(module.call(target, operands, binaryen.Type.i32));
   assert(theCall instanceof binaryen.Call);
   assert(theCall instanceof binaryen.Expression);
   assert(theCall.target === target);
   assertDeepEqual(theCall.operands, operands);
   assertDeepEqual(theCall.getOperands(), operands);
   assert(theCall.return === false);
-  assert(theCall.type === binaryen.i32);
+  assert(theCall.type === binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theCall);
   assert(info.id === theCall.id);
@@ -350,7 +350,7 @@ console.log("# Call");
   theCall.return = true;
   assert(theCall.return === true);
   theCall.finalize();
-  assert(theCall.type === binaryen.unreachable); // finalized tail call
+  assert(theCall.type === binaryen.Type.unreachable); // finalized tail call
 
   info = binaryen.getExpressionInfo(theCall);
   assert(info.type === theCall.type);
@@ -359,9 +359,9 @@ console.log("# Call");
   assert(info.isReturn === theCall.return);
 
   theCall.return = false;
-  theCall.type = binaryen.i32;
+  theCall.type = binaryen.Type.i32;
   theCall.finalize();
-  assert(theCall.type === binaryen.i32); // finalized call
+  assert(theCall.type === binaryen.Type.i32); // finalized call
 
   info = binaryen.getExpressionInfo(theCall);
   assert(info.type === theCall.type);
@@ -383,8 +383,8 @@ console.log("# CallIndirect");
 
   var table = "0";
   var target = module.i32.const(42);
-  var params = binaryen.none;
-  var results = binaryen.none;
+  var params = binaryen.Type.none;
+  var results = binaryen.Type.none;
   var operands = [
     module.i32.const(1),
     module.i32.const(2)
@@ -429,12 +429,12 @@ console.log("# CallIndirect");
   theCallIndirect.insertOperandAt(0, module.i32.const(7));
   theCallIndirect.return = true;
   assert(theCallIndirect.return === true);
-  theCallIndirect.params = params = binaryen.createType([ binaryen.i32, binaryen.i32 ]);
+  theCallIndirect.params = params = binaryen.createType([ binaryen.Type.i32, binaryen.Type.i32 ]);
   assert(theCallIndirect.params === params);
-  theCallIndirect.results = results = binaryen.i32;
+  theCallIndirect.results = results = binaryen.Type.i32;
   assert(theCallIndirect.results === results);
   theCallIndirect.finalize();
-  assert(theCallIndirect.type === binaryen.unreachable); // finalized tail call
+  assert(theCallIndirect.type === binaryen.Type.unreachable); // finalized tail call
 
   info = binaryen.getExpressionInfo(theCallIndirect);
   assert(info.type === theCallIndirect.type);
@@ -466,7 +466,7 @@ console.log("# LocalGet");
   const module = new binaryen.Module();
 
   var index = 1;
-  var type = binaryen.i32;
+  var type = binaryen.Type.i32;
   const theLocalGet = binaryen.LocalGet(module.local.get(index, type));
   assert(theLocalGet instanceof binaryen.LocalGet);
   assert(theLocalGet instanceof binaryen.Expression);
@@ -480,7 +480,7 @@ console.log("# LocalGet");
 
   theLocalGet.index = index = 2;
   assert(theLocalGet.index === index);
-  theLocalGet.type = type = binaryen.f64;
+  theLocalGet.type = type = binaryen.Type.f64;
   assert(theLocalGet.type === type);
   theLocalGet.finalize();
 
@@ -510,7 +510,7 @@ console.log("# LocalSet");
   assert(theLocalSet.index === index);
   assert(theLocalSet.value === value);
   assert(theLocalSet.tee === false);
-  assert(theLocalSet.type == binaryen.none);
+  assert(theLocalSet.type == binaryen.Type.none);
 
   var info = binaryen.getExpressionInfo(theLocalSet);
   assert(info.id === theLocalSet.id);
@@ -523,10 +523,10 @@ console.log("# LocalSet");
   assert(theLocalSet.index === index);
   theLocalSet.value = value = module.i32.const(3);
   assert(theLocalSet.value === value);
-  theLocalSet.type = binaryen.i32;
-  assert(theLocalSet.type === binaryen.i32);
+  theLocalSet.type = binaryen.Type.i32;
+  assert(theLocalSet.type === binaryen.Type.i32);
   assert(theLocalSet.tee === true);
-  theLocalSet.type = binaryen.none;
+  theLocalSet.type = binaryen.Type.none;
   theLocalSet.finalize();
 
   info = binaryen.getExpressionInfo(theLocalSet);
@@ -550,7 +550,7 @@ console.log("# GlobalGet");
   const module = new binaryen.Module();
 
   var name = "a";
-  var type = binaryen.i32;
+  var type = binaryen.Type.i32;
   const theGlobalGet = binaryen.GlobalGet(module.global.get(name, type));
   assert(theGlobalGet instanceof binaryen.GlobalGet);
   assert(theGlobalGet instanceof binaryen.Expression);
@@ -564,7 +564,7 @@ console.log("# GlobalGet");
 
   theGlobalGet.name = name = "b";
   assert(theGlobalGet.name === name);
-  theGlobalGet.type = type = binaryen.f64;
+  theGlobalGet.type = type = binaryen.Type.f64;
   assert(theGlobalGet.type === type);
   theGlobalGet.finalize();
 
@@ -593,7 +593,7 @@ console.log("# GlobalSet");
   assert(theGlobalSet instanceof binaryen.Expression);
   assert(theGlobalSet.name === name);
   assert(theGlobalSet.value === value);
-  assert(theGlobalSet.type == binaryen.none);
+  assert(theGlobalSet.type == binaryen.Type.none);
 
   var info = binaryen.getExpressionInfo(theGlobalSet);
   assert(info.id === theGlobalSet.id);
@@ -625,7 +625,7 @@ console.log("# MemorySize");
 (function testMemorySize() {
   const module = new binaryen.Module();
   module.setMemory(1, 1, null);
-  var type = binaryen.i32;
+  var type = binaryen.Type.i32;
   const theMemorySize = binaryen.MemorySize(module.memory.size());
   assert(theMemorySize instanceof binaryen.MemorySize);
   assert(theMemorySize instanceof binaryen.Expression);
@@ -651,7 +651,7 @@ console.log("# MemoryGrow");
   const module = new binaryen.Module();
   module.setMemory(1, 1, null);
 
-  var type = binaryen.i32;
+  var type = binaryen.Type.i32;
   var delta = module.i32.const(1);
   const theMemoryGrow = binaryen.MemoryGrow(module.memory.grow(delta));
   assert(theMemoryGrow instanceof binaryen.MemoryGrow);
@@ -698,7 +698,7 @@ console.log("# Load");
   assert(theLoad.bytes === 4);
   assert(theLoad.signed === true);
   assert(theLoad.atomic === false);
-  assert(theLoad.type == binaryen.i32);
+  assert(theLoad.type == binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theLoad);
   assert(info.id === theLoad.id);
@@ -716,8 +716,8 @@ console.log("# Load");
   assert(theLoad.align === align);
   theLoad.ptr = ptr = module.i32.const(128);
   assert(theLoad.ptr === ptr);
-  theLoad.type = binaryen.i64;
-  assert(theLoad.type === binaryen.i64);
+  theLoad.type = binaryen.Type.i64;
+  assert(theLoad.type === binaryen.Type.i64);
   theLoad.signed = false;
   assert(theLoad.signed === false);
   theLoad.bytes = 8;
@@ -763,8 +763,8 @@ console.log("# Store");
   assert(theStore.value === value);
   assert(theStore.bytes === 4);
   assert(theStore.atomic === false);
-  assert(theStore.valueType === binaryen.i32);
-  assert(theStore.type === binaryen.none);
+  assert(theStore.valueType === binaryen.Type.i32);
+  assert(theStore.type === binaryen.Type.none);
 
   var info = binaryen.getExpressionInfo(theStore);
   assert(info.id === theStore.id);
@@ -787,8 +787,8 @@ console.log("# Store");
   assert(theStore.value === value);
   theStore.signed = false;
   assert(theStore.signed === false);
-  theStore.valueType = binaryen.i64;
-  assert(theStore.valueType === binaryen.i64);
+  theStore.valueType = binaryen.Type.i64;
+  assert(theStore.valueType === binaryen.Type.i64);
   theStore.bytes = 8;
   assert(theStore.bytes === 8);
   theStore.memoryOrder = binaryen.MemoryOrder.seqcst;
@@ -825,7 +825,7 @@ console.log("# Const");
   assert(theConst.valueI32 === 1);
   theConst.valueI32 = 2;
   assert(theConst.valueI32 === 2);
-  assert(theConst.type === binaryen.i32);
+  assert(theConst.type === binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theConst);
   assert(info.id === theConst.id);
@@ -835,7 +835,7 @@ console.log("# Const");
   theConst.valueI64 = 3;
   assert(theConst.valueI64 === 3n);
   theConst.finalize();
-  assert(theConst.type == binaryen.i64);
+  assert(theConst.type == binaryen.Type.i64);
 
   info = binaryen.getExpressionInfo(theConst);
   assert(info.type === theConst.type);
@@ -844,7 +844,7 @@ console.log("# Const");
   theConst.valueF32 = 5;
   assert(theConst.valueF32 === 5);
   theConst.finalize();
-  assert(theConst.type === binaryen.f32);
+  assert(theConst.type === binaryen.Type.f32);
 
   info = binaryen.getExpressionInfo(theConst);
   assert(info.type === theConst.type);
@@ -853,7 +853,7 @@ console.log("# Const");
   theConst.valueF64 = 6;
   assert(theConst.valueF64 === 6);
   theConst.finalize();
-  assert(theConst.type === binaryen.f64);
+  assert(theConst.type === binaryen.Type.f64);
 
   info = binaryen.getExpressionInfo(theConst);
   assert(info.type === theConst.type);
@@ -862,7 +862,7 @@ console.log("# Const");
   theConst.valueV128 = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16];
   assertDeepEqual(theConst.valueV128, [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]);
   theConst.finalize();
-  assert(theConst.type === binaryen.v128);
+  assert(theConst.type === binaryen.Type.v128);
 
   info = binaryen.getExpressionInfo(theConst);
   assert(info.type === theConst.type);
@@ -889,7 +889,7 @@ console.log("# Unary");
   assert(theUnary instanceof binaryen.Expression);
   assert(theUnary.op === op);
   assert(theUnary.value === value);
-  assert(theUnary.type === binaryen.i32);
+  assert(theUnary.type === binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theUnary);
   assert(info.id === theUnary.id);
@@ -901,9 +901,9 @@ console.log("# Unary");
   assert(theUnary.op === op);
   theUnary.value = value = module.i64.const(2);
   assert(theUnary.value === value);
-  theUnary.type = binaryen.f32;
+  theUnary.type = binaryen.Type.f32;
   theUnary.finalize();
-  assert(theUnary.type === binaryen.i32);
+  assert(theUnary.type === binaryen.Type.i32);
 
   info = binaryen.getExpressionInfo(theUnary);
   assert(info.type === theUnary.type);
@@ -933,7 +933,7 @@ console.log("# Binary");
   assert(theBinary.op === op);
   assert(theBinary.left === left);
   assert(theBinary.right === right);
-  assert(theBinary.type === binaryen.i32)
+  assert(theBinary.type === binaryen.Type.i32)
 
   var info = binaryen.getExpressionInfo(theBinary);
   assert(info.id === theBinary.id);
@@ -948,9 +948,9 @@ console.log("# Binary");
   assert(theBinary.left === left);
   theBinary.right = right = module.i64.const(4);
   assert(theBinary.right === right);
-  theBinary.type = binaryen.f32;
+  theBinary.type = binaryen.Type.f32;
   theBinary.finalize();
-  assert(theBinary.type === binaryen.i64);
+  assert(theBinary.type === binaryen.Type.i64);
 
   info = binaryen.getExpressionInfo(theBinary);
   assert(info.type === theBinary.type);
@@ -1045,7 +1045,7 @@ console.log("# Select");
   assert(theSelect.condition === condition);
   assert(theSelect.ifTrue === ifTrue);
   assert(theSelect.ifFalse === ifFalse);
-  assert(theSelect.type === binaryen.i32);
+  assert(theSelect.type === binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theSelect);
   assert(info.id === theSelect.id);
@@ -1061,7 +1061,7 @@ console.log("# Select");
   theSelect.ifFalse = ifFalse = module.i64.const(6);
   assert(theSelect.ifFalse === ifFalse);
   theSelect.finalize();
-  assert(theSelect.type === binaryen.i64);
+  assert(theSelect.type === binaryen.Type.i64);
 
   info = binaryen.getExpressionInfo(theSelect);
   assert(info.type === theSelect.type);
@@ -1088,7 +1088,7 @@ console.log("# Drop");
   assert(theDrop instanceof binaryen.Drop);
   assert(theDrop instanceof binaryen.Expression);
   assert(theDrop.value === value);
-  assert(theDrop.type === binaryen.none);
+  assert(theDrop.type === binaryen.Type.none);
 
   var info = binaryen.getExpressionInfo(theDrop);
   assert(info.id === theDrop.id);
@@ -1099,7 +1099,7 @@ console.log("# Drop");
   assert(theDrop.value === value);
 
   theDrop.finalize();
-  assert(theDrop.type === binaryen.none);
+  assert(theDrop.type === binaryen.Type.none);
 
   info = binaryen.getExpressionInfo(theDrop);
   assert(info.type === theDrop.type);
@@ -1124,7 +1124,7 @@ console.log("# Return");
   assert(theReturn instanceof binaryen.Return);
   assert(theReturn instanceof binaryen.Expression);
   assert(theReturn.value === value);
-  assert(theReturn.type === binaryen.unreachable);
+  assert(theReturn.type === binaryen.Type.unreachable);
 
   var info = binaryen.getExpressionInfo(theReturn);
   assert(info.id === theReturn.id);
@@ -1135,7 +1135,7 @@ console.log("# Return");
   assert(theReturn.value === value);
 
   theReturn.finalize();
-  assert(theReturn.type === binaryen.unreachable);
+  assert(theReturn.type === binaryen.Type.unreachable);
 
   info = binaryen.getExpressionInfo(theReturn);
   assert(info.type === theReturn.type);
@@ -1168,7 +1168,7 @@ console.log("# AtomicRMW");
   assert(theAtomicRMW.offset === offset);
   assert(theAtomicRMW.ptr === ptr);
   assert(theAtomicRMW.value === value);
-  assert(theAtomicRMW.type === binaryen.i32);
+  assert(theAtomicRMW.type === binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theAtomicRMW);
   assert(info.id === theAtomicRMW.id);
@@ -1189,9 +1189,9 @@ console.log("# AtomicRMW");
   assert(theAtomicRMW.ptr === ptr);
   theAtomicRMW.value = value = module.i64.const(5);
   assert(theAtomicRMW.value === value);
-  theAtomicRMW.type = binaryen.i64;
+  theAtomicRMW.type = binaryen.Type.i64;
   theAtomicRMW.finalize();
-  assert(theAtomicRMW.type === binaryen.i64);
+  assert(theAtomicRMW.type === binaryen.Type.i64);
 
   info = binaryen.getExpressionInfo(theAtomicRMW);
   assert(info.type === theAtomicRMW.type);
@@ -1228,7 +1228,7 @@ console.log("# AtomicCmpxchg");
   assert(theAtomicCmpxchg.ptr === ptr);
   assert(theAtomicCmpxchg.expected === expected);
   assert(theAtomicCmpxchg.replacement === replacement);
-  assert(theAtomicCmpxchg.type === binaryen.i32);
+  assert(theAtomicCmpxchg.type === binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theAtomicCmpxchg);
   assert(info.id === theAtomicCmpxchg.id);
@@ -1249,9 +1249,9 @@ console.log("# AtomicCmpxchg");
   assert(theAtomicCmpxchg.expected === expected);
   theAtomicCmpxchg.replacement = replacement = module.i64.const(7);
   assert(theAtomicCmpxchg.replacement === replacement);
-  theAtomicCmpxchg.type = binaryen.i64;
+  theAtomicCmpxchg.type = binaryen.Type.i64;
   theAtomicCmpxchg.finalize();
-  assert(theAtomicCmpxchg.type === binaryen.i64);
+  assert(theAtomicCmpxchg.type === binaryen.Type.i64);
 
   info = binaryen.getExpressionInfo(theAtomicCmpxchg);
   assert(info.type === theAtomicCmpxchg.type);
@@ -1284,9 +1284,9 @@ console.log("# AtomicWait");
   assert(theAtomicWait instanceof binaryen.Expression);
   assert(theAtomicWait.ptr === ptr);
   assert(theAtomicWait.expected === expected);
-  assert(theAtomicWait.expectedType === binaryen.i32);
+  assert(theAtomicWait.expectedType === binaryen.Type.i32);
   assert(theAtomicWait.timeout === timeout);
-  assert(theAtomicWait.type === binaryen.i32);
+  assert(theAtomicWait.type === binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theAtomicWait);
   assert(info.id === theAtomicWait.id);
@@ -1300,13 +1300,13 @@ console.log("# AtomicWait");
   assert(theAtomicWait.ptr === ptr);
   theAtomicWait.expected = expected = module.i32.const(6);
   assert(theAtomicWait.expected === expected);
-  theAtomicWait.expectedType = binaryen.i64;
-  assert(theAtomicWait.expectedType === binaryen.i64);
+  theAtomicWait.expectedType = binaryen.Type.i64;
+  assert(theAtomicWait.expectedType === binaryen.Type.i64);
   theAtomicWait.timeout = timeout = module.i64.const(7);
   assert(theAtomicWait.timeout === timeout);
-  theAtomicWait.type = binaryen.f64;
+  theAtomicWait.type = binaryen.Type.f64;
   theAtomicWait.finalize();
-  assert(theAtomicWait.type === binaryen.i32);
+  assert(theAtomicWait.type === binaryen.Type.i32);
 
   info = binaryen.getExpressionInfo(theAtomicWait);
   assert(info.type === theAtomicWait.type);
@@ -1337,7 +1337,7 @@ console.log("# AtomicNotify");
   assert(theAtomicNotify instanceof binaryen.Expression);
   assert(theAtomicNotify.ptr === ptr);
   assert(theAtomicNotify.notifyCount === notifyCount);
-  assert(theAtomicNotify.type === binaryen.i32);
+  assert(theAtomicNotify.type === binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theAtomicNotify);
   assert(info.id === theAtomicNotify.id);
@@ -1349,9 +1349,9 @@ console.log("# AtomicNotify");
   assert(theAtomicNotify.ptr === ptr);
   theAtomicNotify.notifyCount = notifyCount = module.i32.const(4);
   assert(theAtomicNotify.notifyCount === notifyCount);
-  theAtomicNotify.type = binaryen.f64;
+  theAtomicNotify.type = binaryen.Type.f64;
   theAtomicNotify.finalize();
-  assert(theAtomicNotify.type === binaryen.i32);
+  assert(theAtomicNotify.type === binaryen.Type.i32);
 
   info = binaryen.getExpressionInfo(theAtomicNotify);
   assert(info.type === theAtomicNotify.type);
@@ -1376,7 +1376,7 @@ console.log("# AtomicFence");
   assert(theAtomicFence instanceof binaryen.AtomicFence);
   assert(theAtomicFence instanceof binaryen.Expression);
   assert(theAtomicFence.order === binaryen.MemoryOrder.seqcst);
-  assert(theAtomicFence.type === binaryen.none);
+  assert(theAtomicFence.type === binaryen.Type.none);
 
   var info = binaryen.getExpressionInfo(theAtomicFence);
   assert(info.id === theAtomicFence.id);
@@ -1413,7 +1413,7 @@ console.log("# SIMDExtract");
   assert(theSIMDExtract.op === op);
   assert(theSIMDExtract.vec === vec);
   assert(theSIMDExtract.index === index);
-  assert(theSIMDExtract.type === binaryen.i32);
+  assert(theSIMDExtract.type === binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theSIMDExtract);
   assert(info.id === theSIMDExtract.id);
@@ -1428,9 +1428,9 @@ console.log("# SIMDExtract");
   assert(theSIMDExtract.vec === vec);
   theSIMDExtract.index = index = 1;
   assert(theSIMDExtract.index === index);
-  theSIMDExtract.type = binaryen.f64;
+  theSIMDExtract.type = binaryen.Type.f64;
   theSIMDExtract.finalize();
-  assert(theSIMDExtract.type === binaryen.i32);
+  assert(theSIMDExtract.type === binaryen.Type.i32);
   
   info = binaryen.getExpressionInfo(theSIMDExtract);
   assert(info.type === theSIMDExtract.type);
@@ -1463,7 +1463,7 @@ console.log("# SIMDReplace");
   assert(theSIMDReplace.vec === vec);
   assert(theSIMDReplace.index === index);
   assert(theSIMDReplace.value === value);
-  assert(theSIMDReplace.type === binaryen.v128);
+  assert(theSIMDReplace.type === binaryen.Type.v128);
 
   var info = binaryen.getExpressionInfo(theSIMDReplace);
   assert(info.id === theSIMDReplace.id);
@@ -1481,9 +1481,9 @@ console.log("# SIMDReplace");
   assert(theSIMDReplace.index === index);
   theSIMDReplace.value = value = module.i32.const(2);
   assert(theSIMDReplace.value === value);
-  theSIMDReplace.type = binaryen.f64;
+  theSIMDReplace.type = binaryen.Type.f64;
   theSIMDReplace.finalize();
-  assert(theSIMDReplace.type === binaryen.v128);
+  assert(theSIMDReplace.type === binaryen.Type.v128);
 
   info = binaryen.getExpressionInfo(theSIMDReplace);
   assert(info.type === theSIMDReplace.type);
@@ -1515,7 +1515,7 @@ console.log("# SIMDShuffle");
   assert(theSIMDShuffle.left === left);
   assert(theSIMDShuffle.right === right);
   assertDeepEqual(theSIMDShuffle.mask, mask);
-  assert(theSIMDShuffle.type === binaryen.v128);
+  assert(theSIMDShuffle.type === binaryen.Type.v128);
 
   var info = binaryen.getExpressionInfo(theSIMDShuffle);
   assert(info.id === theSIMDShuffle.id);
@@ -1530,9 +1530,9 @@ console.log("# SIMDShuffle");
   assert(theSIMDShuffle.right === right);
   theSIMDShuffle.mask = mask = [3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3];
   assertDeepEqual(theSIMDShuffle.mask, mask);
-  theSIMDShuffle.type = binaryen.f64;
+  theSIMDShuffle.type = binaryen.Type.f64;
   theSIMDShuffle.finalize();
-  assert(theSIMDShuffle.type === binaryen.v128);
+  assert(theSIMDShuffle.type === binaryen.Type.v128);
 
   info = binaryen.getExpressionInfo(theSIMDShuffle);
   assert(info.type === theSIMDShuffle.type);
@@ -1565,7 +1565,7 @@ console.log("# SIMDTernary");
   assert(theSIMDTernary.a === a);
   assert(theSIMDTernary.b === b);
   assert(theSIMDTernary.c === c);
-  assert(theSIMDTernary.type === binaryen.v128);
+  assert(theSIMDTernary.type === binaryen.Type.v128);
 
   var info = binaryen.getExpressionInfo(theSIMDTernary);
   assert(info.id === theSIMDTernary.id);
@@ -1598,7 +1598,7 @@ console.log("# SIMDShift");
   assert(theSIMDShift.op === op);
   assert(theSIMDShift.vec === vec);
   assert(theSIMDShift.shift === shift);
-  assert(theSIMDShift.type === binaryen.v128);
+  assert(theSIMDShift.type === binaryen.Type.v128);
 
   var info = binaryen.getExpressionInfo(theSIMDShift);
   assert(info.id === theSIMDShift.id);
@@ -1613,9 +1613,9 @@ console.log("# SIMDShift");
   assert(theSIMDShift.vec === vec);
   theSIMDShift.shift = shift = module.i32.const(2);
   assert(theSIMDShift.shift === shift);
-  theSIMDShift.type = binaryen.f64;
+  theSIMDShift.type = binaryen.Type.f64;
   theSIMDShift.finalize();
-  assert(theSIMDShift.type === binaryen.v128);
+  assert(theSIMDShift.type === binaryen.Type.v128);
 
   info = binaryen.getExpressionInfo(theSIMDShift);
   assert(info.type === theSIMDShift.type);
@@ -1648,7 +1648,7 @@ console.log("# SIMDLoad");
   assert(theSIMDLoad.offset === offset);
   assert(theSIMDLoad.align === align);
   assert(theSIMDLoad.ptr === ptr);
-  assert(theSIMDLoad.type === binaryen.v128);
+  assert(theSIMDLoad.type === binaryen.Type.v128);
 
   var info = binaryen.getExpressionInfo(theSIMDLoad);
   assert(info.id === theSIMDLoad.id);
@@ -1665,9 +1665,9 @@ console.log("# SIMDLoad");
   assert(theSIMDLoad.align === align);
   theSIMDLoad.ptr = ptr = module.i32.const(2);
   assert(theSIMDLoad.ptr === ptr);
-  theSIMDLoad.type = binaryen.f64;
+  theSIMDLoad.type = binaryen.Type.f64;
   theSIMDLoad.finalize();
-  assert(theSIMDLoad.type === binaryen.v128);
+  assert(theSIMDLoad.type === binaryen.Type.v128);
 
   info = binaryen.getExpressionInfo(theSIMDLoad);
   assert(info.type === theSIMDLoad.type);
@@ -1705,7 +1705,7 @@ console.log("# SIMDLoadStoreLane");
   assert(theSIMDLoadStoreLane.index === index);
   assert(theSIMDLoadStoreLane.ptr === ptr);
   assert(theSIMDLoadStoreLane.vec === vec);
-  assert(theSIMDLoadStoreLane.type === binaryen.v128);
+  assert(theSIMDLoadStoreLane.type === binaryen.Type.v128);
   assert(theSIMDLoadStoreLane.store === false);
 
   var info = binaryen.getExpressionInfo(theSIMDLoadStoreLane);
@@ -1731,9 +1731,9 @@ console.log("# SIMDLoadStoreLane");
   assert(theSIMDLoadStoreLane.ptr === ptr);
   theSIMDLoadStoreLane.vec = vec = module.v128.const([1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]);
   assert(theSIMDLoadStoreLane.vec === vec);
-  theSIMDLoadStoreLane.type = binaryen.f64;
+  theSIMDLoadStoreLane.type = binaryen.Type.f64;
   theSIMDLoadStoreLane.finalize();
-  assert(theSIMDLoadStoreLane.type === binaryen.v128);
+  assert(theSIMDLoadStoreLane.type === binaryen.Type.v128);
 
   info = binaryen.getExpressionInfo(theSIMDLoadStoreLane);
   assert(info.type === theSIMDLoadStoreLane.type);
@@ -1753,10 +1753,10 @@ console.log("# SIMDLoadStoreLane");
 
   theSIMDLoadStoreLane.op = op = binaryen.Operations.Store16LaneVec128;
   assert(theSIMDLoadStoreLane.op === op);
-  theSIMDLoadStoreLane.type = binaryen.f64;
+  theSIMDLoadStoreLane.type = binaryen.Type.f64;
   assert(theSIMDLoadStoreLane.store === true);
   theSIMDLoadStoreLane.finalize();
-  assert(theSIMDLoadStoreLane.type === binaryen.none);
+  assert(theSIMDLoadStoreLane.type === binaryen.Type.none);
 
   info = binaryen.getExpressionInfo(theSIMDLoadStoreLane);
   assert(info.type === theSIMDLoadStoreLane.type);
@@ -1789,7 +1789,7 @@ console.log("# MemoryInit");
   assert(theMemoryInit.dest === dest);
   assert(theMemoryInit.offset === offset);
   assert(theMemoryInit.size === size);
-  assert(theMemoryInit.type === binaryen.none);
+  assert(theMemoryInit.type === binaryen.Type.none);
 
   var info = binaryen.getExpressionInfo(theMemoryInit);
   assert(info.id === theMemoryInit.id);
@@ -1807,9 +1807,9 @@ console.log("# MemoryInit");
   assert(theMemoryInit.offset === offset);
   theMemoryInit.size = size = module.i32.const(8);
   assert(theMemoryInit.size === size);
-  theMemoryInit.type = binaryen.f64;
+  theMemoryInit.type = binaryen.Type.f64;
   theMemoryInit.finalize();
-  assert(theMemoryInit.type === binaryen.none);
+  assert(theMemoryInit.type === binaryen.Type.none);
 
   info = binaryen.getExpressionInfo(theMemoryInit);
   assert(info.type === theMemoryInit.type);
@@ -1837,7 +1837,7 @@ console.log("# DataDrop");
   assert(theDataDrop instanceof binaryen.DataDrop);
   assert(theDataDrop instanceof binaryen.Expression);
   assert(theDataDrop.segment === segment);
-  assert(theDataDrop.type === binaryen.none);
+  assert(theDataDrop.type === binaryen.Type.none);
 
   var info = binaryen.getExpressionInfo(theDataDrop);
   assert(info.id === theDataDrop.id);
@@ -1846,9 +1846,9 @@ console.log("# DataDrop");
 
   theDataDrop.segment = segment = "2";
   assert(theDataDrop.segment === "2");
-  theDataDrop.type = binaryen.f64;
+  theDataDrop.type = binaryen.Type.f64;
   theDataDrop.finalize();
-  assert(theDataDrop.type === binaryen.none);
+  assert(theDataDrop.type === binaryen.Type.none);
 
   info = binaryen.getExpressionInfo(theDataDrop);
   assert(info.type === theDataDrop.type);
@@ -1878,7 +1878,7 @@ console.log("# MemoryCopy");
   assert(theMemoryCopy.dest === dest);
   assert(theMemoryCopy.source === source);
   assert(theMemoryCopy.size === size);
-  assert(theMemoryCopy.type === binaryen.none);
+  assert(theMemoryCopy.type === binaryen.Type.none);
 
   var info = binaryen.getExpressionInfo(theMemoryCopy);
   assert(info.id === theMemoryCopy.id);
@@ -1893,9 +1893,9 @@ console.log("# MemoryCopy");
   assert(theMemoryCopy.source === source);
   theMemoryCopy.size = size = module.i32.const(6);
   assert(theMemoryCopy.size === size);
-  theMemoryCopy.type = binaryen.f64;
+  theMemoryCopy.type = binaryen.Type.f64;
   theMemoryCopy.finalize();
-  assert(theMemoryCopy.type === binaryen.none);
+  assert(theMemoryCopy.type === binaryen.Type.none);
 
   info = binaryen.getExpressionInfo(theMemoryCopy);
   assert(info.type === theMemoryCopy.type);
@@ -1927,7 +1927,7 @@ console.log("# MemoryFill");
   assert(theMemoryFill.dest === dest);
   assert(theMemoryFill.value === value);
   assert(theMemoryFill.size === size);
-  assert(theMemoryFill.type === binaryen.none);
+  assert(theMemoryFill.type === binaryen.Type.none);
 
   var info = binaryen.getExpressionInfo(theMemoryFill);
   assert(info.id === theMemoryFill.id);
@@ -1942,9 +1942,9 @@ console.log("# MemoryFill");
   assert(theMemoryFill.value === value);
   theMemoryFill.size = size = module.i32.const(6);
   assert(theMemoryFill.size === size);
-  theMemoryFill.type = binaryen.f64;
+  theMemoryFill.type = binaryen.Type.f64;
   theMemoryFill.finalize();
-  assert(theMemoryFill.type === binaryen.none);
+  assert(theMemoryFill.type === binaryen.Type.none);
 
   info = binaryen.getExpressionInfo(theMemoryFill);
   assert(info.type === theMemoryFill.type);
@@ -1966,23 +1966,23 @@ console.log("# RefIsNull");
 (function testRefIsNull() {
   const module = new binaryen.Module();
 
-  var value = module.local.get(1, binaryen.externref);
+  var value = module.local.get(1, binaryen.Type.externref);
   const theRefIsNull = binaryen.RefIsNull(module.ref.is_null(value));
   assert(theRefIsNull instanceof binaryen.RefIsNull);
   assert(theRefIsNull instanceof binaryen.Expression);
   assert(theRefIsNull.value === value);
-  assert(theRefIsNull.type === binaryen.i32);
+  assert(theRefIsNull.type === binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theRefIsNull);
   assert(info.id === theRefIsNull.id);
   assert(info.type === theRefIsNull.type);
   assert(info.value === theRefIsNull.value);
 
-  theRefIsNull.value = value = module.local.get(2, binaryen.externref);
+  theRefIsNull.value = value = module.local.get(2, binaryen.Type.externref);
   assert(theRefIsNull.value === value);
-  theRefIsNull.type = binaryen.f64;
+  theRefIsNull.type = binaryen.Type.f64;
   theRefIsNull.finalize();
-  assert(theRefIsNull.type === binaryen.i32);
+  assert(theRefIsNull.type === binaryen.Type.i32);
 
   info = binaryen.getExpressionInfo(theRefIsNull);
   assert(info.type === theRefIsNull.type);
@@ -2003,14 +2003,14 @@ console.log("# RefAs");
   const module = new binaryen.Module();
 
   var op = binaryen.Operations.RefAsNonNull;
-  var value = module.local.get(1, binaryen.anyref);
-  var externref = module.local.get(3, binaryen.externref);
+  var value = module.local.get(1, binaryen.Type.anyref);
+  var externref = module.local.get(3, binaryen.Type.externref);
   const theRefAs = binaryen.RefAs(module.ref.as_non_null(value));
   assert(theRefAs instanceof binaryen.RefAs);
   assert(theRefAs instanceof binaryen.Expression);
   assert(theRefAs.op === op);
   assert(theRefAs.value === value);
-  assert(theRefAs.type !== binaryen.i32); // TODO: === (ref any)
+  assert(theRefAs.type !== binaryen.Type.i32); // TODO: === (ref any)
 
   var info = binaryen.getExpressionInfo(theRefAs);
   assert(info.id === theRefAs.id);
@@ -2021,11 +2021,11 @@ console.log("# RefAs");
   theRefAs.op = op = binaryen.Operations.RefAsExternConvertAny;
   assert(theRefAs.op === op);
   theRefAs.op = op = binaryen.Operations.RefAsNonNull;
-  theRefAs.value = value = module.local.get(2, binaryen.anyref);
+  theRefAs.value = value = module.local.get(2, binaryen.Type.anyref);
   assert(theRefAs.value === value);
-  theRefAs.type = binaryen.f64;
+  theRefAs.type = binaryen.Type.f64;
   theRefAs.finalize();
-  assert(theRefAs.type !== binaryen.f64); // TODO: === (ref any)
+  assert(theRefAs.type !== binaryen.Type.f64); // TODO: === (ref any)
 
   info = binaryen.getExpressionInfo(theRefAs);
   assert(info.type === theRefAs.type);
@@ -2047,7 +2047,7 @@ console.log("# RefAs");
 console.log("# RefFunc");
 (function testRefFunc() {
   const module = new binaryen.Module();
-  module.addFunction("a", binaryen.none, binaryen.none, [], module.nop());
+  module.addFunction("a", binaryen.Type.none, binaryen.Type.none, [], module.nop());
   var type = binaryen.Function(module.getFunction("a")).type;
 
   var func = "a";
@@ -2087,14 +2087,14 @@ console.log("# RefEq");
 (function testRefEq() {
   const module = new binaryen.Module();
 
-  var left = module.local.get(0, binaryen.eqref);
-  var right = module.local.get(1, binaryen.eqref);
+  var left = module.local.get(0, binaryen.Type.eqref);
+  var right = module.local.get(1, binaryen.Type.eqref);
   const theRefEq = binaryen.RefEq(module.ref.eq(left, right));
   assert(theRefEq instanceof binaryen.RefEq);
   assert(theRefEq instanceof binaryen.Expression);
   assert(theRefEq.left === left);
   assert(theRefEq.right === right);
-  assert(theRefEq.type === binaryen.i32);
+  assert(theRefEq.type === binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theRefEq);
   assert(info.id === theRefEq.id);
@@ -2102,13 +2102,13 @@ console.log("# RefEq");
   assert(info.left === theRefEq.left);
   assert(info.right === theRefEq.right);
 
-  theRefEq.left = left = module.local.get(2, binaryen.eqref);
+  theRefEq.left = left = module.local.get(2, binaryen.Type.eqref);
   assert(theRefEq.left === left);
-  theRefEq.right = right = module.local.get(3, binaryen.eqref);
+  theRefEq.right = right = module.local.get(3, binaryen.Type.eqref);
   assert(theRefEq.right === right);
-  theRefEq.type = binaryen.f64;
+  theRefEq.type = binaryen.Type.f64;
   theRefEq.finalize();
-  assert(theRefEq.type === binaryen.i32);
+  assert(theRefEq.type === binaryen.Type.i32);
 
   info = binaryen.getExpressionInfo(theRefEq);
   assert(info.type === theRefEq.type);
@@ -2129,14 +2129,14 @@ console.log("# RefTest");
 (function testRefTest() {
   const module = new binaryen.Module();
 
-  var ref = module.local.get(0, binaryen.anyref);
-  var castType = binaryen.anyref;
+  var ref = module.local.get(0, binaryen.Type.anyref);
+  var castType = binaryen.Type.anyref;
   const theRefTest = binaryen.RefTest(module.ref.test(ref, castType));
   assert(theRefTest instanceof binaryen.RefTest);
   assert(theRefTest instanceof binaryen.Expression);
   assert(theRefTest.ref === ref);
   assert(theRefTest.castType === castType);
-  assert(theRefTest.type === binaryen.i32);
+  assert(theRefTest.type === binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theRefTest);
   assert(info.id === theRefTest.id);
@@ -2144,13 +2144,13 @@ console.log("# RefTest");
   assert(info.ref === theRefTest.ref);
   assert(info.castType === theRefTest.castType);
 
-  theRefTest.ref = ref = module.local.get(2, binaryen.externref);
+  theRefTest.ref = ref = module.local.get(2, binaryen.Type.externref);
   assert(theRefTest.ref === ref);
-  theRefTest.castType = castType = binaryen.externref;
+  theRefTest.castType = castType = binaryen.Type.externref;
   assert(theRefTest.castType === castType);
-  theRefTest.type = binaryen.f64;
+  theRefTest.type = binaryen.Type.f64;
   theRefTest.finalize();
-  assert(theRefTest.type === binaryen.i32);
+  assert(theRefTest.type === binaryen.Type.i32);
 
   info = binaryen.getExpressionInfo(theRefTest);
   assert(info.type === theRefTest.type);
@@ -2171,8 +2171,8 @@ console.log("# RefCast");
 (function testRefCast() {
   const module = new binaryen.Module();
 
-  var ref = module.local.get(0, binaryen.anyref);
-  var type = binaryen.anyref;
+  var ref = module.local.get(0, binaryen.Type.anyref);
+  var type = binaryen.Type.anyref;
   const theRefCast = binaryen.RefCast(module.ref.cast(ref, type));
   assert(theRefCast instanceof binaryen.RefCast);
   assert(theRefCast instanceof binaryen.Expression);
@@ -2184,9 +2184,9 @@ console.log("# RefCast");
   assert(info.type === theRefCast.type);
   assert(info.ref === theRefCast.ref);
 
-  theRefCast.ref = ref = module.local.get(2, binaryen.externref);
+  theRefCast.ref = ref = module.local.get(2, binaryen.Type.externref);
   assert(theRefCast.ref === ref);
-  theRefCast.type = type = binaryen.externref;
+  theRefCast.type = type = binaryen.Type.externref;
   theRefCast.finalize();
   assert(theRefCast.type === type);
 
@@ -2209,9 +2209,9 @@ console.log("# BrOn");
   const module = new binaryen.Module();
 
   var name = "br";
-  var ref = module.local.get(0, binaryen.externref);
+  var ref = module.local.get(0, binaryen.Type.externref);
   var op = binaryen.Operations.BrOnNull;
-  var castType = binaryen.unreachable;
+  var castType = binaryen.Type.unreachable;
   const theBrOn = binaryen.BrOn(module.br_on_null(name, ref));
   assert(theBrOn instanceof binaryen.BrOn);
   assert(theBrOn instanceof binaryen.Expression);
@@ -2232,11 +2232,11 @@ console.log("# BrOn");
 
   theBrOn.name = name = "br2";
   assert(theBrOn.name === name);
-  theBrOn.ref = ref = module.local.get(1, binaryen.anyref);
+  theBrOn.ref = ref = module.local.get(1, binaryen.Type.anyref);
   assert(theBrOn.ref === ref);
   theBrOn.op = op = binaryen.Operations.BrOnCast;
   assert(theBrOn.op === op);
-  theBrOn.castType = castType = binaryen.i31ref;
+  theBrOn.castType = castType = binaryen.Type.i31ref;
   assert(theBrOn.castType === castType);
   theBrOn.finalize();
 
@@ -2260,11 +2260,11 @@ console.log("# StructNew");
 (function testStructNew() {
   const builder = new binaryen.TypeBuilder(2);
   builder.setStructType(0, [
-    { type: binaryen.i32, packedType: binaryen.notPacked, mutable: true },
+    { type: binaryen.Type.i32, packedType: binaryen.PackedType.notPacked, mutable: true },
   ]);
   builder.setStructType(1, [
-    { type: binaryen.i32, packedType: binaryen.i16, mutable: true },
-    { type: binaryen.i64, packedType: binaryen.notPacked, mutable: true }
+    { type: binaryen.Type.i32, packedType: binaryen.PackedType.i16, mutable: true },
+    { type: binaryen.Type.i64, packedType: binaryen.PackedType.notPacked, mutable: true }
   ]);
   var [
     struct0Type,
@@ -2327,11 +2327,11 @@ console.log("# StructGet");
 (function testStructGet() {
   const builder = new binaryen.TypeBuilder(2);
   builder.setStructType(0, [
-    { type: binaryen.i32, packedType: binaryen.notPacked, mutable: true },
+    { type: binaryen.Type.i32, packedType: binaryen.PackedType.notPacked, mutable: true },
   ]);
   builder.setStructType(1, [
-    { type: binaryen.i32, packedType: binaryen.i16, mutable: true },
-    { type: binaryen.i64, packedType: binaryen.notPacked, mutable: true }
+    { type: binaryen.Type.i32, packedType: binaryen.PackedType.i16, mutable: true },
+    { type: binaryen.Type.i64, packedType: binaryen.PackedType.notPacked, mutable: true }
   ]);
   var [
     struct0Type,
@@ -2342,7 +2342,7 @@ console.log("# StructGet");
 
   var index = 0;
   var ref = module.local.get(0, struct0Type);
-  var type = binaryen.i32;
+  var type = binaryen.Type.i32;
   var signed = false;
   const theStructGet = binaryen.StructGet(module.struct.get(index, ref, type, signed));
   assert(theStructGet instanceof binaryen.StructGet);
@@ -2365,7 +2365,7 @@ console.log("# StructGet");
   assert(theStructGet.ref === ref);
   theStructGet.signed = signed = true;
   assert(theStructGet.signed === signed);
-  theStructGet.type = type = binaryen.i64;
+  theStructGet.type = type = binaryen.Type.i64;
   theStructGet.finalize();
   assert(theStructGet.type === type);
 
@@ -2389,11 +2389,11 @@ console.log("# StructSet");
 (function testStructSet() {
   const builder = new binaryen.TypeBuilder(2);
   builder.setStructType(0, [
-    { type: binaryen.i32, packedType: binaryen.notPacked, mutable: true },
+    { type: binaryen.Type.i32, packedType: binaryen.PackedType.notPacked, mutable: true },
   ]);
   builder.setStructType(1, [
-    { type: binaryen.i32, packedType: binaryen.i16, mutable: true },
-    { type: binaryen.i64, packedType: binaryen.notPacked, mutable: true }
+    { type: binaryen.Type.i32, packedType: binaryen.PackedType.i16, mutable: true },
+    { type: binaryen.Type.i64, packedType: binaryen.PackedType.notPacked, mutable: true }
   ]);
   var [
     struct0Type,
@@ -2404,14 +2404,14 @@ console.log("# StructSet");
 
   var index = 0;
   var ref = module.local.get(0, struct0Type);
-  var value = module.local.get(1, binaryen.i32);
+  var value = module.local.get(1, binaryen.Type.i32);
   const theStructSet = binaryen.StructSet(module.struct.set(index, ref, value));
   assert(theStructSet instanceof binaryen.StructSet);
   assert(theStructSet instanceof binaryen.Expression);
   assert(theStructSet.index === index);
   assert(theStructSet.ref === ref);
   assert(theStructSet.value === value);
-  assert(theStructSet.type === binaryen.none);
+  assert(theStructSet.type === binaryen.Type.none);
 
   var info = binaryen.getExpressionInfo(theStructSet);
   assert(info.id === theStructSet.id);
@@ -2424,11 +2424,11 @@ console.log("# StructSet");
   assert(theStructSet.index === index);
   theStructSet.ref = ref = module.local.get(2, struct1Type);
   assert(theStructSet.ref === ref);
-  theStructSet.value = value = module.local.get(3, binaryen.i64);
+  theStructSet.value = value = module.local.get(3, binaryen.Type.i64);
   assert(theStructSet.value === value);
-  theStructSet.type = binaryen.f64;
+  theStructSet.type = binaryen.Type.f64;
   theStructSet.finalize();
-  assert(theStructSet.type === binaryen.none);
+  assert(theStructSet.type === binaryen.Type.none);
 
   info = binaryen.getExpressionInfo(theStructSet);
   assert(info.type === theStructSet.type);
@@ -2450,7 +2450,7 @@ console.log("# StructWait");
 (function testStructWait() {
   const builder = new binaryen.TypeBuilder(1);
   builder.setStructType(0, [
-    { type: binaryen.i32, packedType: binaryen.notPacked, mutable: true },
+    { type: binaryen.Type.i32, packedType: binaryen.PackedType.notPacked, mutable: true },
   ]);
   var [
     struct0Type
@@ -2460,9 +2460,9 @@ console.log("# StructWait");
 
   var ref = module.local.get(0, struct0Type);
   var index = 0;
-  var expected = module.local.get(1, binaryen.i32);
-  var timeout = module.local.get(2, binaryen.i64);
-  var waitqueue = module.local.get(3, binaryen.anyref);
+  var expected = module.local.get(1, binaryen.Type.i32);
+  var timeout = module.local.get(2, binaryen.Type.i64);
+  var waitqueue = module.local.get(3, binaryen.Type.anyref);
   const theStructWait = binaryen.StructWait(module.struct.wait(ref, index, expected, timeout, waitqueue));
   assert(theStructWait instanceof binaryen.StructWait);
   assert(theStructWait instanceof binaryen.Expression);
@@ -2471,7 +2471,7 @@ console.log("# StructWait");
   assert(theStructWait.expected === expected);
   assert(theStructWait.timeout === timeout);
   assert(theStructWait.waitqueue === waitqueue);
-  assert(theStructWait.type === binaryen.i32);
+  assert(theStructWait.type === binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theStructWait);
   assert(info.id === theStructWait.id);
@@ -2508,8 +2508,8 @@ console.log("# WaitqueueNotify");
 (function testWaitqueueNotify() {
   const module = new binaryen.Module();
 
-  var waitqueue = module.local.get(0, binaryen.anyref);
-  var count = module.local.get(1, binaryen.i32);
+  var waitqueue = module.local.get(0, binaryen.Type.anyref);
+  var count = module.local.get(1, binaryen.Type.i32);
   const theWaitqueueNotify = binaryen.WaitqueueNotify(module.waitqueue.notify(waitqueue, count));
   assert(theWaitqueueNotify instanceof binaryen.WaitqueueNotify);
   assert(theWaitqueueNotify instanceof binaryen.Expression);
@@ -2530,8 +2530,8 @@ console.log("# WaitqueueNotify");
 console.log("# ArrayNew");
 (function testArrayNew() {
   const builder = new binaryen.TypeBuilder(2);
-  builder.setArrayType(0, binaryen.i32, binaryen.i16, true);
-  builder.setArrayType(1, binaryen.i32, binaryen.notPacked, true);
+  builder.setArrayType(0, binaryen.Type.i32, binaryen.PackedType.i16, true);
+  builder.setArrayType(1, binaryen.Type.i32, binaryen.PackedType.notPacked, true);
   var [
     array0Type,
     array1Type
@@ -2582,8 +2582,8 @@ console.log("# ArrayNew");
 console.log("# ArrayNewFixed");
 (function testArrayNewFixed() {
   const builder = new binaryen.TypeBuilder(2);
-  builder.setArrayType(0, binaryen.i32, binaryen.i16, true);
-  builder.setArrayType(1, binaryen.i32, binaryen.notPacked, true);
+  builder.setArrayType(0, binaryen.Type.i32, binaryen.PackedType.i16, true);
+  builder.setArrayType(1, binaryen.Type.i32, binaryen.PackedType.notPacked, true);
   var [
     array0Type,
     array1Type
@@ -2644,8 +2644,8 @@ console.log("# ArrayNewFixed");
 console.log("# ArrayNewData");
 (function testArrayNewData() {
   const builder = new binaryen.TypeBuilder(2);
-  builder.setArrayType(0, binaryen.i32, binaryen.i16, true);
-  builder.setArrayType(1, binaryen.i32, binaryen.notPacked, true);
+  builder.setArrayType(0, binaryen.Type.i32, binaryen.PackedType.i16, true);
+  builder.setArrayType(1, binaryen.Type.i32, binaryen.PackedType.notPacked, true);
   var [
     array0Type,
     array1Type
@@ -2702,8 +2702,8 @@ console.log("# ArrayNewData");
 console.log("# ArrayNewElem");
 (function testArrayNewElem() {
   const builder = new binaryen.TypeBuilder(2);
-  builder.setArrayType(0, binaryen.i32, binaryen.i16, true);
-  builder.setArrayType(1, binaryen.i32, binaryen.notPacked, true);
+  builder.setArrayType(0, binaryen.Type.i32, binaryen.PackedType.i16, true);
+  builder.setArrayType(1, binaryen.Type.i32, binaryen.PackedType.notPacked, true);
   var [
     array0Type,
     array1Type
@@ -2761,8 +2761,8 @@ console.log("# ArrayNewElem");
 console.log("# ArrayGet");
 (function testArrayGet() {
   const builder = new binaryen.TypeBuilder(2);
-  builder.setArrayType(0, binaryen.i32, binaryen.i16, true);
-  builder.setArrayType(1, binaryen.i64, binaryen.notPacked, true);
+  builder.setArrayType(0, binaryen.Type.i32, binaryen.PackedType.i16, true);
+  builder.setArrayType(1, binaryen.Type.i64, binaryen.PackedType.notPacked, true);
   var [
     array0Type,
     array1Type
@@ -2772,7 +2772,7 @@ console.log("# ArrayGet");
 
   var ref = module.local.get(0, array0Type);
   var index = module.i32.const(0);
-  var type = binaryen.i32;
+  var type = binaryen.Type.i32;
   var signed = false;
   const theArrayGet = binaryen.ArrayGet(module.array.get(ref, index, type, signed));
   assert(theArrayGet instanceof binaryen.ArrayGet);
@@ -2795,7 +2795,7 @@ console.log("# ArrayGet");
   assert(theArrayGet.index === index);
   theArrayGet.signed = signed = true;
   assert(theArrayGet.signed === signed);
-  theArrayGet.type = type = binaryen.i64;
+  theArrayGet.type = type = binaryen.Type.i64;
   theArrayGet.finalize();
   assert(theArrayGet.type === type);
 
@@ -2818,8 +2818,8 @@ console.log("# ArrayGet");
 console.log("# ArraySet");
 (function testArraySet() {
   const builder = new binaryen.TypeBuilder(2);
-  builder.setArrayType(0, binaryen.i32, binaryen.i16, true);
-  builder.setArrayType(1, binaryen.i64, binaryen.notPacked, true);
+  builder.setArrayType(0, binaryen.Type.i32, binaryen.PackedType.i16, true);
+  builder.setArrayType(1, binaryen.Type.i64, binaryen.PackedType.notPacked, true);
   var [
     array0Type,
     array1Type
@@ -2829,14 +2829,14 @@ console.log("# ArraySet");
 
   var ref = module.local.get(0, array0Type);
   var index = module.i32.const(0);
-  var value = module.local.get(1, binaryen.i32);
+  var value = module.local.get(1, binaryen.Type.i32);
   const theArraySet = binaryen.ArraySet(module.array.set(ref, index, value));
   assert(theArraySet instanceof binaryen.ArraySet);
   assert(theArraySet instanceof binaryen.Expression);
   assert(theArraySet.ref === ref);
   assert(theArraySet.index === index);
   assert(theArraySet.value === value);
-  assert(theArraySet.type === binaryen.none);
+  assert(theArraySet.type === binaryen.Type.none);
 
   var info = binaryen.getExpressionInfo(theArraySet);
   assert(info.id === theArraySet.id);
@@ -2849,11 +2849,11 @@ console.log("# ArraySet");
   assert(theArraySet.ref === ref);
   theArraySet.index = index = module.i32.const(1);
   assert(theArraySet.index === index);
-  theArraySet.value = value = module.local.get(3, binaryen.i64);
+  theArraySet.value = value = module.local.get(3, binaryen.Type.i64);
   assert(theArraySet.value === value);
-  theArraySet.type = binaryen.i64;
+  theArraySet.type = binaryen.Type.i64;
   theArraySet.finalize();
-  assert(theArraySet.type === binaryen.none);
+  assert(theArraySet.type === binaryen.Type.none);
 
   info = binaryen.getExpressionInfo(theArraySet);
   assert(info.type === theArraySet.type);
@@ -2874,8 +2874,8 @@ console.log("# ArraySet");
 console.log("# ArrayLen");
 (function testArrayLen() {
   const builder = new binaryen.TypeBuilder(2);
-  builder.setArrayType(0, binaryen.i32, binaryen.i16, true);
-  builder.setArrayType(1, binaryen.i64, binaryen.notPacked, true);
+  builder.setArrayType(0, binaryen.Type.i32, binaryen.PackedType.i16, true);
+  builder.setArrayType(1, binaryen.Type.i64, binaryen.PackedType.notPacked, true);
   var [
     array0Type,
     array1Type
@@ -2888,7 +2888,7 @@ console.log("# ArrayLen");
   assert(theArrayLen instanceof binaryen.ArrayLen);
   assert(theArrayLen instanceof binaryen.Expression);
   assert(theArrayLen.ref === ref);
-  assert(theArrayLen.type === binaryen.i32);
+  assert(theArrayLen.type === binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theArrayLen);
   assert(info.id === theArrayLen.id);
@@ -2897,9 +2897,9 @@ console.log("# ArrayLen");
 
   theArrayLen.ref = ref = module.local.get(1, array1Type);
   assert(theArrayLen.ref === ref);
-  theArrayLen.type = binaryen.i64;
+  theArrayLen.type = binaryen.Type.i64;
   theArrayLen.finalize();
-  assert(theArrayLen.type === binaryen.i32);
+  assert(theArrayLen.type === binaryen.Type.i32);
 
   info = binaryen.getExpressionInfo(theArrayLen);
   assert(info.type === theArrayLen.type);
@@ -2918,8 +2918,8 @@ console.log("# ArrayLen");
 console.log("# ArrayFill");
 (function testArrayFill() {
   const builder = new binaryen.TypeBuilder(2);
-  builder.setArrayType(0, binaryen.i32, binaryen.i16, true);
-  builder.setArrayType(1, binaryen.i64, binaryen.notPacked, true);
+  builder.setArrayType(0, binaryen.Type.i32, binaryen.PackedType.i16, true);
+  builder.setArrayType(1, binaryen.Type.i64, binaryen.PackedType.notPacked, true);
   var [
     array0Type,
     array1Type
@@ -2929,7 +2929,7 @@ console.log("# ArrayFill");
 
   var ref = module.local.get(0, array0Type);
   var index = module.i32.const(0);
-  var value = module.local.get(1, binaryen.i32);
+  var value = module.local.get(1, binaryen.Type.i32);
   var size = module.i32.const(1);
   const theArrayFill = binaryen.ArrayFill(module.array.fill(ref, index, value, size));
   assert(theArrayFill instanceof binaryen.ArrayFill);
@@ -2938,7 +2938,7 @@ console.log("# ArrayFill");
   assert(theArrayFill.index === index);
   assert(theArrayFill.value === value);
   assert(theArrayFill.size === size);
-  assert(theArrayFill.type === binaryen.none);
+  assert(theArrayFill.type === binaryen.Type.none);
 
   var info = binaryen.getExpressionInfo(theArrayFill);
   assert(info.id === theArrayFill.id);
@@ -2952,13 +2952,13 @@ console.log("# ArrayFill");
   assert(theArrayFill.ref === ref);
   theArrayFill.index = index = module.i32.const(2);
   assert(theArrayFill.index === index);
-  theArrayFill.value = value = module.local.get(3, binaryen.i64);
+  theArrayFill.value = value = module.local.get(3, binaryen.Type.i64);
   assert(theArrayFill.value = value);
   theArrayFill.size = size = module.i32.const(3);
   assert(theArrayFill.size === size);
-  theArrayFill.type = binaryen.i64;
+  theArrayFill.type = binaryen.Type.i64;
   theArrayFill.finalize();
-  assert(theArrayFill.type === binaryen.none);
+  assert(theArrayFill.type === binaryen.Type.none);
 
   info = binaryen.getExpressionInfo(theArrayFill);
   assert(info.type === theArrayFill.type);
@@ -2980,8 +2980,8 @@ console.log("# ArrayFill");
 console.log("# ArrayCopy");
 (function testArrayCopy() {
   const builder = new binaryen.TypeBuilder(2);
-  builder.setArrayType(0, binaryen.i32, binaryen.i16, true);
-  builder.setArrayType(1, binaryen.i64, binaryen.notPacked, true);
+  builder.setArrayType(0, binaryen.Type.i32, binaryen.PackedType.i16, true);
+  builder.setArrayType(1, binaryen.Type.i64, binaryen.PackedType.notPacked, true);
   var [
     array0Type,
     array1Type
@@ -3002,7 +3002,7 @@ console.log("# ArrayCopy");
   assert(theArrayCopy.srcRef === srcRef);
   assert(theArrayCopy.srcIndex === srcIndex);
   assert(theArrayCopy.length === length);
-  assert(theArrayCopy.type === binaryen.none);
+  assert(theArrayCopy.type === binaryen.Type.none);
 
   var info = binaryen.getExpressionInfo(theArrayCopy);
   assert(info.id === theArrayCopy.id);
@@ -3023,9 +3023,9 @@ console.log("# ArrayCopy");
   assert(theArrayCopy.srcIndex === srcIndex);
   theArrayCopy.length = length = module.i32.const(2);
   assert(theArrayCopy.length === length);
-  theArrayCopy.type = binaryen.i64;
+  theArrayCopy.type = binaryen.Type.i64;
   theArrayCopy.finalize();
-  assert(theArrayCopy.type === binaryen.none);
+  assert(theArrayCopy.type === binaryen.Type.none);
 
   info = binaryen.getExpressionInfo(theArrayCopy);
   assert(info.type === theArrayCopy.type);
@@ -3048,8 +3048,8 @@ console.log("# ArrayCopy");
 console.log("# ArrayInitData");
 (function testArrayInitData() {
   const builder = new binaryen.TypeBuilder(2);
-  builder.setArrayType(0, binaryen.i32, binaryen.i16, true);
-  builder.setArrayType(1, binaryen.i32, binaryen.notPacked, true);
+  builder.setArrayType(0, binaryen.Type.i32, binaryen.PackedType.i16, true);
+  builder.setArrayType(1, binaryen.Type.i32, binaryen.PackedType.notPacked, true);
   var [
     array0Type,
     array1Type
@@ -3070,7 +3070,7 @@ console.log("# ArrayInitData");
   assert(theArrayInitData.index === index);
   assert(theArrayInitData.offset === offset);
   assert(theArrayInitData.size === size);
-  assert(theArrayInitData.type === binaryen.none);
+  assert(theArrayInitData.type === binaryen.Type.none);
   
   var info = binaryen.getExpressionInfo(theArrayInitData);
   assert(info.id === theArrayInitData.id);
@@ -3091,9 +3091,9 @@ console.log("# ArrayInitData");
   assert(theArrayInitData.offset === offset);
   theArrayInitData.size = size = module.i32.const(5);
   assert(theArrayInitData.size === size);
-  theArrayInitData.type = binaryen.i64;
+  theArrayInitData.type = binaryen.Type.i64;
   theArrayInitData.finalize();
-  assert(theArrayInitData.type === binaryen.none);
+  assert(theArrayInitData.type === binaryen.Type.none);
 
   info = binaryen.getExpressionInfo(theArrayInitData);
   assert(info.type === theArrayInitData.type);
@@ -3116,8 +3116,8 @@ console.log("# ArrayInitData");
 console.log("# ArrayInitElem");
 (function testArrayInitElem() {
   const builder = new binaryen.TypeBuilder(2);
-  builder.setArrayType(0, binaryen.i32, binaryen.i16, true);
-  builder.setArrayType(1, binaryen.i32, binaryen.notPacked, true);
+  builder.setArrayType(0, binaryen.Type.i32, binaryen.PackedType.i16, true);
+  builder.setArrayType(1, binaryen.Type.i32, binaryen.PackedType.notPacked, true);
   var [
     array0Type,
     array1Type
@@ -3138,7 +3138,7 @@ console.log("# ArrayInitElem");
   assert(theArrayInitElem.index === index);
   assert(theArrayInitElem.offset === offset);
   assert(theArrayInitElem.size === size);
-  assert(theArrayInitElem.type === binaryen.none);
+  assert(theArrayInitElem.type === binaryen.Type.none);
 
   var info = binaryen.getExpressionInfo(theArrayInitElem);
   assert(info.id === theArrayInitElem.id);
@@ -3159,9 +3159,9 @@ console.log("# ArrayInitElem");
   assert(theArrayInitElem.offset === offset);
   theArrayInitElem.size = size = module.i32.const(5);
   assert(theArrayInitElem.size === size);
-  theArrayInitElem.type = binaryen.i64;
+  theArrayInitElem.type = binaryen.Type.i64;
   theArrayInitElem.finalize();
-  assert(theArrayInitElem.type === binaryen.none);
+  assert(theArrayInitElem.type === binaryen.Type.none);
 
   info = binaryen.getExpressionInfo(theArrayInitElem);
   assert(info.type === theArrayInitElem.type);
@@ -3184,9 +3184,9 @@ console.log("# ArrayInitElem");
 console.log("# Try");
 (function testTry() {
   const module = new binaryen.Module();
-  module.addTag("tag1", 0, binaryen.none, binaryen.none);
-  module.addTag("tag2", 0, binaryen.none, binaryen.none);
-  module.addTag("tag3", 0, binaryen.none, binaryen.none);
+  module.addTag("tag1", 0, binaryen.Type.none, binaryen.Type.none);
+  module.addTag("tag2", 0, binaryen.Type.none, binaryen.Type.none);
+  module.addTag("tag3", 0, binaryen.Type.none, binaryen.Type.none);
 
   var body = module.i32.const(1);
   var catchBodies = [
@@ -3198,7 +3198,7 @@ console.log("# Try");
   assert(theTry instanceof binaryen.Expression);
   assert(theTry.body === body);
   assertDeepEqual(theTry.catchBodies, catchBodies);
-  assert(theTry.type === binaryen.i32);
+  assert(theTry.type === binaryen.Type.i32);
   assert(theTry.getNumCatchTags() == 1);
   assert(theTry.getNumCatchBodies() == 2);
   assert(theTry.hasCatchAll() == 1);
@@ -3253,9 +3253,9 @@ console.log("# Try");
   assert(theTry.getCatchTagAt(1) == "tag1");
   console.log(theTry.toText());
 
-  theTry.type = binaryen.f64;
+  theTry.type = binaryen.Type.f64;
   theTry.finalize();
-  assert(theTry.type === binaryen.i32);
+  assert(theTry.type === binaryen.Type.i32);
 
   info = binaryen.getExpressionInfo(theTry);
   assert(info.id === theTry.id);
@@ -3299,7 +3299,7 @@ console.log("# Throw");
   assert(theThrow instanceof binaryen.Expression);
   assert(theThrow.tag === tag);
   assertDeepEqual(theThrow.operands, operands);
-  assert(theThrow.type === binaryen.unreachable);
+  assert(theThrow.type === binaryen.Type.unreachable);
 
   var info = binaryen.getExpressionInfo(theThrow);
   assert(info.id === theThrow.id);
@@ -3324,9 +3324,9 @@ console.log("# Throw");
   theThrow.setOperands(operands);
   assertDeepEqual(theThrow.operands, operands);
   theThrow.insertOperandAt(1, module.i32.const(7));
-  theThrow.type = binaryen.f64;
+  theThrow.type = binaryen.Type.f64;
   theThrow.finalize();
-  assert(theThrow.type === binaryen.unreachable);
+  assert(theThrow.type === binaryen.Type.unreachable);
 
   info = binaryen.getExpressionInfo(theThrow);
   assert(info.type === theThrow.type);
@@ -3351,7 +3351,7 @@ console.log("# Rethrow");
   assert(theRethrow instanceof binaryen.Rethrow);
   assert(theRethrow instanceof binaryen.Expression);
   assert(theRethrow.target === "l0");
-  assert(theRethrow.type === binaryen.unreachable);
+  assert(theRethrow.type === binaryen.Type.unreachable);
 
   var info = binaryen.getExpressionInfo(theRethrow);
   assert(info.id === theRethrow.id);
@@ -3360,9 +3360,9 @@ console.log("# Rethrow");
 
   theRethrow.target = "l1";
   assert(theRethrow.target === "l1");
-  theRethrow.type = binaryen.f64;
+  theRethrow.type = binaryen.Type.f64;
   theRethrow.finalize();
-  assert(theRethrow.type === binaryen.unreachable);
+  assert(theRethrow.type === binaryen.Type.unreachable);
 
   info = binaryen.getExpressionInfo(theRethrow);
   assert(info.type === theRethrow.type);
@@ -3386,7 +3386,7 @@ console.log("# TupleMake");
     module.i32.const(1),
     module.i32.const(2)
   ];
-  var type = binaryen.createType([ binaryen.i32, binaryen.i32 ]);
+  var type = binaryen.createType([ binaryen.Type.i32, binaryen.Type.i32 ]);
   const theTupleMake = binaryen.TupleMake(module.tuple.make(operands));
   assert(theTupleMake instanceof binaryen.TupleMake);
   assert(theTupleMake instanceof binaryen.Expression);
@@ -3413,7 +3413,7 @@ console.log("# TupleMake");
   assertDeepEqual(theTupleMake.operands, operands);
   assertDeepEqual(theTupleMake.getOperands(), operands);
   theTupleMake.insertOperandAt(1, module.i32.const(7));
-  theTupleMake.type = binaryen.f64;
+  theTupleMake.type = binaryen.Type.f64;
   theTupleMake.finalize();
   assert(theTupleMake.type === type);
 
@@ -3445,7 +3445,7 @@ console.log("# TupleExtract");
   assert(theTupleExtract instanceof binaryen.Expression);
   assert(theTupleExtract.tuple === tuple);
   assert(theTupleExtract.index === index);
-  assert(theTupleExtract.type === binaryen.i32);
+  assert(theTupleExtract.type === binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theTupleExtract);
   assert(info.id === theTupleExtract.id);
@@ -3460,9 +3460,9 @@ console.log("# TupleExtract");
   assert(theTupleExtract.tuple === tuple);
   theTupleExtract.index = index = 0;
   assert(theTupleExtract.index === index);
-  theTupleExtract.type = binaryen.i32;
+  theTupleExtract.type = binaryen.Type.i32;
   theTupleExtract.finalize();
-  assert(theTupleExtract.type === binaryen.f64);
+  assert(theTupleExtract.type === binaryen.Type.f64);
 
   info = binaryen.getExpressionInfo(theTupleExtract);
   assert(info.type === theTupleExtract.type);
@@ -3483,7 +3483,7 @@ console.log("# RefI31");
 (function testRefI31() {
   const module = new binaryen.Module();
 
-  var value = module.local.get(1, binaryen.i32);
+  var value = module.local.get(1, binaryen.Type.i32);
   const theRefI31 = binaryen.RefI31(module.ref.i31(value));
   assert(theRefI31 instanceof binaryen.RefI31);
   assert(theRefI31 instanceof binaryen.Expression);
@@ -3495,7 +3495,7 @@ console.log("# RefI31");
   assert(info.type === theRefI31.type);
   assert(info.value === theRefI31.value);
 
-  theRefI31.value = value = module.local.get(2, binaryen.i32);
+  theRefI31.value = value = module.local.get(2, binaryen.Type.i32);
   assert(theRefI31.value === value);
 
   info = binaryen.getExpressionInfo(theRefI31);
@@ -3515,13 +3515,13 @@ console.log("# I31Get");
 (function testI31Get() {
   const module = new binaryen.Module();
 
-  var i31 = module.local.get(1, binaryen.i31ref);
+  var i31 = module.local.get(1, binaryen.Type.i31ref);
   const theI31Get = binaryen.I31Get(module.i31.get_s(i31));
   assert(theI31Get instanceof binaryen.I31Get);
   assert(theI31Get instanceof binaryen.Expression);
   assert(theI31Get.i31 === i31);
   assert(theI31Get.signed === true);
-  assert(theI31Get.type === binaryen.i32);
+  assert(theI31Get.type === binaryen.Type.i32);
 
   var info = binaryen.getExpressionInfo(theI31Get);
   assert(info.id === theI31Get.id);
@@ -3529,13 +3529,13 @@ console.log("# I31Get");
   assert(info.i31 === theI31Get.i31);
   assert(info.isSigned === theI31Get.signed);
 
-  theI31Get.i31 = i31 = module.local.get(2, binaryen.i31ref);
+  theI31Get.i31 = i31 = module.local.get(2, binaryen.Type.i31ref);
   assert(theI31Get.i31 === i31);
   theI31Get.signed = false;
   assert(theI31Get.signed === false);
-  theI31Get.type = binaryen.f64;
+  theI31Get.type = binaryen.Type.f64;
   theI31Get.finalize();
-  assert(theI31Get.type === binaryen.i32);
+  assert(theI31Get.type === binaryen.Type.i32);
 
   info = binaryen.getExpressionInfo(theI31Get);
   assert(info.type === theI31Get.type);
@@ -3557,7 +3557,7 @@ console.log("# CallRef");
   const module = new binaryen.Module();
 
   const funcName = "tiny";
-  module.addFunction(funcName, binaryen.createType([binaryen.i32, binaryen.i32]), binaryen.none, [], module.nop());
+  module.addFunction(funcName, binaryen.createType([binaryen.Type.i32, binaryen.Type.i32]), binaryen.Type.none, [], module.nop());
   const funcType = binaryen.Function(module.getFunction(funcName)).type;
   const funcRef = binaryen.RefFunc(module.ref.func(funcName, funcType));
 
@@ -3566,11 +3566,11 @@ console.log("# CallRef");
     module.i32.const(7)
   ];
 
-  const theCallRef = binaryen.CallRef(module.call_ref(funcRef, operands, binaryen.none));
+  const theCallRef = binaryen.CallRef(module.call_ref(funcRef, operands, binaryen.Type.none));
   assert(theCallRef instanceof binaryen.CallRef);
   assert(theCallRef instanceof binaryen.Expression);
   assert(theCallRef.numOperands === operands.length);
-  assert(theCallRef.type === binaryen.none);
+  assert(theCallRef.type === binaryen.Type.none);
   assert(binaryen.RefFunc(theCallRef.target).func === funcName);
 
   const info = binaryen.getExpressionInfo(theCallRef);
@@ -3616,7 +3616,7 @@ console.log("# CallRef");
   theCallRef.setReturn(false);
   assert(theCallRef.isReturn() === false);
 
-  const theReturnCallRef = binaryen.CallRef(module.return_call_ref(funcRef, operands, binaryen.none));
+  const theReturnCallRef = binaryen.CallRef(module.return_call_ref(funcRef, operands, binaryen.Type.none));
   assert(theReturnCallRef instanceof binaryen.CallRef);
   assert(theReturnCallRef instanceof binaryen.Expression);
   assert(theReturnCallRef.numOperands === operands.length);
diff --git a/test/binaryen.js/functions.js b/test/binaryen.js/functions.js
index 84f59350bf1..45252162a4f 100644
--- a/test/binaryen.js/functions.js
+++ b/test/binaryen.js/functions.js
@@ -10,7 +10,7 @@ function cleanInfo(info) {
 
 var module = new binaryen.Module();
 
-var func = module.addFunction("a-function", binaryen.none, binaryen.i32, [],
+var func = module.addFunction("a-function", binaryen.Type.none, binaryen.Type.i32, [],
   module.i32.add(
     module.i32.const(1),
     module.i32.const(2)
@@ -36,15 +36,15 @@ console.log(module.emitText());
 // Test wrapper
 
 func = module.addFunction("b-function",
-  binaryen.createType([binaryen.i32, binaryen.i32]),
-  binaryen.i32,
-  [ binaryen.i32, binaryen.f64 ],
+  binaryen.createType([binaryen.Type.i32, binaryen.Type.i32]),
+  binaryen.Type.i32,
+  [ binaryen.Type.i32, binaryen.Type.f64 ],
   module.local.tee(2,
     module.i32.add(
-      module.local.get(0, binaryen.i32),
-      module.local.get(1, binaryen.i32)
+      module.local.get(0, binaryen.Type.i32),
+      module.local.get(1, binaryen.Type.i32)
     ),
-    binaryen.i32
+    binaryen.Type.i32
   )
 );
 binaryen.Function.setLocalName(func, 0, "a");
@@ -54,11 +54,11 @@ binaryen.Function.setLocalName(func, 3, "unused");
 
 var theFunc = binaryen.Function(func);
 assert(theFunc.name === "b-function");
-assert(theFunc.params === binaryen.createType([binaryen.i32, binaryen.i32]));
-assert(theFunc.results === binaryen.i32);
+assert(theFunc.params === binaryen.createType([binaryen.Type.i32, binaryen.Type.i32]));
+assert(theFunc.results === binaryen.Type.i32);
 assert(theFunc.numVars === 2);
-assert(theFunc.getVar(0) === binaryen.i32);
-assert(theFunc.getVar(1) === binaryen.f64);
+assert(theFunc.getVar(0) === binaryen.Type.i32);
+assert(theFunc.getVar(1) === binaryen.Type.f64);
 assert(theFunc.numLocals === 4);
 assert(theFunc.getLocalName(0) === "a");
 assert(theFunc.getLocalName(1) === "b");
diff --git a/test/binaryen.js/gc.js b/test/binaryen.js/gc.js
index cf3c8ab4009..9bb5df54506 100644
--- a/test/binaryen.js/gc.js
+++ b/test/binaryen.js/gc.js
@@ -1,11 +1,11 @@
 var builder = new binaryen.TypeBuilder(4);
-builder.setSignatureType(0, binaryen.createType([binaryen.i32]), binaryen.none);
+builder.setSignatureType(0, binaryen.createType([binaryen.Type.i32]), binaryen.Type.none);
 builder.setStructType(1, [
-  { type: binaryen.i32, packedType: binaryen.i16, mutable: true },
-  { type: binaryen.f64, packedType: binaryen.notPacked, mutable: true }
+  { type: binaryen.Type.i32, packedType: binaryen.PackedType.i16, mutable: true },
+  { type: binaryen.Type.f64, packedType: binaryen.PackedType.notPacked, mutable: true }
 ]);
-builder.setArrayType(2, binaryen.i32, binaryen.i8, true);
-builder.setArrayType(3, binaryen.funcref, binaryen.notPacked, true);
+builder.setArrayType(2, binaryen.Type.i32, binaryen.PackedType.i8, true);
+builder.setArrayType(3, binaryen.Type.funcref, binaryen.PackedType.notPacked, true);
 var [
   signatureHeapType,
   structHeapType,
@@ -21,10 +21,10 @@ var funcArrayType = binaryen.getTypeFromHeapType(funcArrayHeapType, true);
 var module = new binaryen.Module();
 module.setFeatures(binaryen.Features.ReferenceTypes | binaryen.Features.BulkMemory | binaryen.Features.GC | binaryen.Features.Strings);
 
-module.addFunction("add", binaryen.createType([binaryen.i32, binaryen.i32]), binaryen.i32, [],
+module.addFunction("add", binaryen.createType([binaryen.Type.i32, binaryen.Type.i32]), binaryen.Type.i32, [],
   module.i32.add(
-    module.local.get("0", binaryen.i32),
-    module.local.get("1", binaryen.i32)
+    module.local.get("0", binaryen.Type.i32),
+    module.local.get("1", binaryen.Type.i32)
   )
 );
 
@@ -78,7 +78,7 @@ var valueList = [
   module.struct.get(
     0,
     module.global.get("struct-global", structType),
-    binaryen.i32,
+    binaryen.Type.i32,
     true
   ),
   module.struct.set(
@@ -120,7 +120,7 @@ var valueList = [
   module.array.get(
     module.global.get("array-global", arrayType),
     module.i32.const(0),
-    binaryen.i32,
+    binaryen.Type.i32,
     true
   ),
   module.array.set(
@@ -162,17 +162,17 @@ var valueList = [
   // string
   module.string.const("hello 🌎"),
 ];
-module.addFunction("main", binaryen.none, binaryen.none, [],
+module.addFunction("main", binaryen.Type.none, binaryen.Type.none, [],
   module.block(
     null,
     valueList.map(value => {
       var type = binaryen.getExpressionType(value);
-      if (type === binaryen.none || type === binaryen.unreachable)
+      if (type === binaryen.Type.none || type === binaryen.Type.unreachable)
         return value;
       else
         return module.drop(value);
     }),
-    binaryen.none
+    binaryen.Type.none
   )
 );
 
diff --git a/test/binaryen.js/global.js b/test/binaryen.js/global.js
index b0baf25999d..0f07aae9f08 100644
--- a/test/binaryen.js/global.js
+++ b/test/binaryen.js/global.js
@@ -12,7 +12,7 @@ var module = new binaryen.Module();
 module.setFeatures(binaryen.Features.MVP | binaryen.Features.MutableGlobals);
 
 var initExpr = module.i32.const(1);
-var global = module.addGlobal("a-global", binaryen.i32, false, initExpr);
+var global = module.addGlobal("a-global", binaryen.Type.i32, false, initExpr);
 
 console.log("GetGlobal is equal: " + (global === module.getGlobal("a-global")));
 
@@ -24,8 +24,8 @@ console.log("getExpressionInfo(init)=" + JSON.stringify(cleanInfo(initExpInfo)))
 console.log(binaryen.emitText(globalInfo.init));
 
 module.addGlobalExport("a-global", "a-global-exp");
-module.addGlobalImport("a-global-imp", "module", "base", binaryen.i32, false);
-module.addGlobalImport("a-mut-global-imp", "module", "base", binaryen.i32, true);
+module.addGlobalImport("a-global-imp", "module", "base", binaryen.Type.i32, false);
+module.addGlobalImport("a-mut-global-imp", "module", "base", binaryen.Type.i32, true);
 
 assert(module.validate());
 console.log(module.emitText());
diff --git a/test/binaryen.js/hello-world.js b/test/binaryen.js/hello-world.js
index d82de61162d..47a6b5bf5e3 100644
--- a/test/binaryen.js/hello-world.js
+++ b/test/binaryen.js/hello-world.js
@@ -6,15 +6,15 @@ var module = new binaryen.Module();
 
 // Start to create the function, starting with the contents: Get the 0 and
 // 1 arguments, and add them, then return them
-var left = module.local.get(0, binaryen.i32);
-var right = module.local.get(1, binaryen.i32);
+var left = module.local.get(0, binaryen.Type.i32);
+var right = module.local.get(1, binaryen.Type.i32);
 var add = module.i32.add(left, right);
 var ret = module.return(add);
 
 // Create the add function
 // Note: no additional local variables (that's the [])
-var ii = binaryen.createType([binaryen.i32, binaryen.i32])
-module.addFunction('adder', ii, binaryen.i32, [], ret);
+var ii = binaryen.createType([binaryen.Type.i32, binaryen.Type.i32])
+module.addFunction('adder', ii, binaryen.Type.i32, [], ret);
 
 // Export the function, so we can call it later (for simplicity we
 // export it as the same name as it has internally)
diff --git a/test/binaryen.js/kitchen-sink.js b/test/binaryen.js/kitchen-sink.js
index 327abb34dab..8607d402adb 100644
--- a/test/binaryen.js/kitchen-sink.js
+++ b/test/binaryen.js/kitchen-sink.js
@@ -47,38 +47,38 @@ function makeDroppedInt32(x) {
 // tests
 
 function test_types() {
-  console.log("  // BinaryenTypeNone: " + binaryen.none);
-  console.log("  //", binaryen.expandType(binaryen.none).join(","));
+  console.log("  // BinaryenTypeNone: " + binaryen.Type.none);
+  console.log("  //", binaryen.expandType(binaryen.Type.none).join(","));
 
-  console.log("  // BinaryenTypeUnreachable: " + binaryen.unreachable);
-  console.log("  //", binaryen.expandType(binaryen.unreachable).join(","));
+  console.log("  // BinaryenTypeUnreachable: " + binaryen.Type.unreachable);
+  console.log("  //", binaryen.expandType(binaryen.Type.unreachable).join(","));
 
-  console.log("  // BinaryenTypeInt32: " + binaryen.i32);
-  console.log("  //", binaryen.expandType(binaryen.i32).join(","));
+  console.log("  // BinaryenTypeInt32: " + binaryen.Type.i32);
+  console.log("  //", binaryen.expandType(binaryen.Type.i32).join(","));
 
-  console.log("  // BinaryenTypeInt64: " + binaryen.i64);
-  console.log("  //", binaryen.expandType(binaryen.i64).join(","));
+  console.log("  // BinaryenTypeInt64: " + binaryen.Type.i64);
+  console.log("  //", binaryen.expandType(binaryen.Type.i64).join(","));
 
-  console.log("  // BinaryenTypeFloat32: " + binaryen.f32);
-  console.log("  //", binaryen.expandType(binaryen.f32).join(","));
+  console.log("  // BinaryenTypeFloat32: " + binaryen.Type.f32);
+  console.log("  //", binaryen.expandType(binaryen.Type.f32).join(","));
 
-  console.log("  // BinaryenTypeFloat64: " + binaryen.f64);
-  console.log("  //", binaryen.expandType(binaryen.f64).join(","));
+  console.log("  // BinaryenTypeFloat64: " + binaryen.Type.f64);
+  console.log("  //", binaryen.expandType(binaryen.Type.f64).join(","));
 
-  console.log("  // BinaryenTypeVec128: " + binaryen.v128);
-  console.log("  //", binaryen.expandType(binaryen.v128).join(","));
+  console.log("  // BinaryenTypeVec128: " + binaryen.Type.v128);
+  console.log("  //", binaryen.expandType(binaryen.Type.v128).join(","));
 
-  console.log("  // BinaryenTypeAuto: " + binaryen.auto);
+  console.log("  // BinaryenTypeAuto: " + binaryen.Type.auto);
 
-  var i32_pair = binaryen.createType([binaryen.i32, binaryen.i32]);
+  var i32_pair = binaryen.createType([binaryen.Type.i32, binaryen.Type.i32]);
   console.log("  //", binaryen.expandType(i32_pair).join(","));
 
-  var duplicate_pair = binaryen.createType([binaryen.i32, binaryen.i32]);
+  var duplicate_pair = binaryen.createType([binaryen.Type.i32, binaryen.Type.i32]);
   console.log("  //", binaryen.expandType(duplicate_pair).join(","));
 
   assert(i32_pair == duplicate_pair);
 
-  var f32_pair = binaryen.createType([binaryen.f32, binaryen.f32]);
+  var f32_pair = binaryen.createType([binaryen.Type.f32, binaryen.Type.f32]);
   console.log("  //", binaryen.expandType(f32_pair).join(","));
 }
 
@@ -210,7 +210,7 @@ function test_core() {
   ], true);
 
   // Create a tag
-  var tag = module.addTag("a-tag", binaryen.i32, binaryen.none);
+  var tag = module.addTag("a-tag", binaryen.Type.i32, binaryen.Type.none);
 
   // Literals and consts
 
@@ -221,7 +221,7 @@ function test_core() {
       constF32Bits = module.f32.const_bits(0xffff1234),
       constF64Bits = module.f64.const_bits(0xffff1234_5678abcdn);
 
-  var iIfF = binaryen.createType([binaryen.i32, binaryen.i64, binaryen.f32, binaryen.f64])
+  var iIfF = binaryen.createType([binaryen.Type.i32, binaryen.Type.i64, binaryen.Type.f32, binaryen.Type.f64])
 
   var temp1 = makeInt32(1), temp2 = makeInt32(2), temp3 = makeInt32(3),
       temp4 = makeInt32(4), temp5 = makeInt32(5),
@@ -232,7 +232,7 @@ function test_core() {
       temp15 = makeInt32(110), temp16 = makeInt64(111);
 
   // Create a function to reference.
-  module.addFunction("foobar", iIfF, binaryen.i32, [], module.i32.const(0));
+  module.addFunction("foobar", iIfF, binaryen.Type.i32, [], module.i32.const(0));
   var foobarType = binaryen.Function(module.getFunction("foobar")).getType();
 
   var valueList = [
@@ -578,19 +578,19 @@ function test_core() {
     module.switch([ "the-value" ], "the-value", temp8, temp9),
     module.switch([ "the-nothing" ], "the-nothing", makeInt32(2)),
     module.i32.eqz( // check the output type of the call node
-      module.call("kitchen()sinker", [ makeInt32(13), makeInt64(37, 0), makeFloat32(1.3), makeFloat64(3.7) ], binaryen.i32)
+      module.call("kitchen()sinker", [ makeInt32(13), makeInt64(37, 0), makeFloat32(1.3), makeFloat64(3.7) ], binaryen.Type.i32)
     ),
     module.i32.eqz( // check the output type of the call node
       module.i32.trunc_s.f32(
-        module.call("an-imported", [ makeInt32(13), makeFloat64(3.7) ], binaryen.f32)
+        module.call("an-imported", [ makeInt32(13), makeFloat64(3.7) ], binaryen.Type.f32)
       )
     ),
     module.i32.eqz( // check the output type of the call node
-      module.call_indirect("t0", makeInt32(2449), [ makeInt32(13), makeInt64(37, 0), makeFloat32(1.3), makeFloat64(3.7) ], iIfF, binaryen.i32)
+      module.call_indirect("t0", makeInt32(2449), [ makeInt32(13), makeInt64(37, 0), makeFloat32(1.3), makeFloat64(3.7) ], iIfF, binaryen.Type.i32)
     ),
-    module.drop(module.local.get(0, binaryen.i32)),
+    module.drop(module.local.get(0, binaryen.Type.i32)),
     module.local.set(0, makeInt32(101)),
-    module.drop(module.local.tee(0, makeInt32(102), binaryen.i32)),
+    module.drop(module.local.tee(0, makeInt32(102), binaryen.Type.i32)),
     module.i32.load(0, 0, makeInt32(1)),
     module.i64.load16_s(2, 1, makeInt32(8)),
     module.f32.load(0, 0, makeInt32(2)),
@@ -600,17 +600,17 @@ function test_core() {
     module.select(temp10, temp11, temp12),
     module.return(makeInt32(1337)),
     // Tail Call
-    module.return_call("kitchen()sinker", [ makeInt32(13), makeInt64(37, 0), makeFloat32(1.3), makeFloat64(3.7) ], binaryen.i32),
-    module.return_call_indirect("t0", makeInt32(2449), [ makeInt32(13), makeInt64(37, 0), makeFloat32(1.3), makeFloat64(3.7) ], iIfF, binaryen.i32),
+    module.return_call("kitchen()sinker", [ makeInt32(13), makeInt64(37, 0), makeFloat32(1.3), makeFloat64(3.7) ], binaryen.Type.i32),
+    module.return_call_indirect("t0", makeInt32(2449), [ makeInt32(13), makeInt64(37, 0), makeFloat32(1.3), makeFloat64(3.7) ], iIfF, binaryen.Type.i32),
 
     // Reference types
-    module.ref.is_null(module.ref.null(binaryen.extern)),
-    module.ref.is_null(module.ref.null(binaryen.func)),
+    module.ref.is_null(module.ref.null(binaryen.HeapType.extern)),
+    module.ref.is_null(module.ref.null(binaryen.HeapType.func)),
     module.ref.is_null(module.ref.func("foobar", foobarType)),
-    module.select(temp10, module.ref.null(binaryen.func), module.ref.func("foobar", foobarType)),
+    module.select(temp10, module.ref.null(binaryen.HeapType.func), module.ref.func("foobar", foobarType)),
 
     // GC
-    module.ref.eq(module.ref.null(binaryen.eq), module.ref.null(binaryen.eq)),
+    module.ref.eq(module.ref.null(binaryen.HeapType.eq), module.ref.null(binaryen.HeapType.eq)),
 
     // Exception handling
     module.try(
@@ -709,7 +709,7 @@ function test_core() {
   // Add drops of concrete expressions, except the last.
   for (var i = 0; i < valueList.length - 1; i++) {
     var type = binaryen.Expression.getType(valueList[i]);
-    if (type != binaryen.none && type != binaryen.unreachable) {
+    if (type != binaryen.Type.none && type != binaryen.Type.unreachable) {
       valueList[i] = module.drop(valueList[i]);
     }
   }
@@ -735,25 +735,25 @@ function test_core() {
   }
 
   // Make the main body of the function. and one block with a return value, one without
-  var value = module.block("the-value", valueList, binaryen.i32);
+  var value = module.block("the-value", valueList, binaryen.Type.i32);
   var droppedValue = module.drop(value);
   var nothing = module.block("the-nothing", [ droppedValue ]);
-  var body = module.block("the-body", [ nothing, makeInt32(42) ], binaryen.i32);
+  var body = module.block("the-body", [ nothing, makeInt32(42) ], binaryen.Type.i32);
 
   // Create the function
-  var sinker = module.addFunction("kitchen()sinker", iIfF, binaryen.i32, [ binaryen.i32 ], body);
+  var sinker = module.addFunction("kitchen()sinker", iIfF, binaryen.Type.i32, [ binaryen.Type.i32 ], body);
 
   // Create a global
   var initExpr = module.i32.const(1);
-  var global = module.addGlobal("a-global", binaryen.i32, false, initExpr)
+  var global = module.addGlobal("a-global", binaryen.Type.i32, false, initExpr)
 
   // Imports
 
-  var iF = binaryen.createType([binaryen.i32, binaryen.f64]);
-  module.addFunctionImport("an-imported", "module", "base", iF, binaryen.f32);
-  module.addGlobalImport("a-global-imp", "module", "base", binaryen.i32, false);
-  module.addGlobalImport("a-mut-global-imp", "module", "base", binaryen.i32, true);
-  module.addTagImport("a-tag-imp", "module", "base", binaryen.i32, binaryen.none);
+  var iF = binaryen.createType([binaryen.Type.i32, binaryen.Type.f64]);
+  module.addFunctionImport("an-imported", "module", "base", iF, binaryen.Type.f32);
+  module.addGlobalImport("a-global-imp", "module", "base", binaryen.Type.i32, false);
+  module.addGlobalImport("a-mut-global-imp", "module", "base", binaryen.Type.i32, true);
+  module.addTagImport("a-tag-imp", "module", "base", binaryen.Type.i32, binaryen.Type.none);
 
   // Exports
 
@@ -775,10 +775,10 @@ function test_core() {
   assert(module.getNumTables() === 1);
   assert(module.getNumElementSegments() === 1);
 
-  module.addTable("t2", 1, 1, binaryen.i31ref, module.ref.i31(module.i32.const(1)));
+  module.addTable("t2", 1, 1, binaryen.Type.i31ref, module.ref.i31(module.i32.const(1)));
 
   // Start function. One per module
-  var starter = module.addFunction("starter", binaryen.none, binaryen.none, [], module.nop());
+  var starter = module.addFunction("starter", binaryen.Type.none, binaryen.Type.none, [], module.nop());
   module.setStart(starter);
   assert(module.getStart() == starter);
 
@@ -802,15 +802,15 @@ function makeCallCheck(x) {
 
 function test_relooper() {
   module = new binaryen.Module();
-  var localTypes = [ binaryen.i32 ];
+  var localTypes = [ binaryen.Type.i32 ];
 
-  module.addFunctionImport("check", "module", "check", binaryen.i32, binaryen.none);
+  module.addFunctionImport("check", "module", "check", binaryen.Type.i32, binaryen.Type.none);
 
   { // trivial: just one block
     var relooper = new binaryen.Relooper(module);
     var block = relooper.addBlock(makeCallCheck(1337));
     var body = relooper.renderAndDispose(block, 0, module);
-    module.addFunction("just-one-block", binaryen.none, binaryen.none, localTypes, body);
+    module.addFunction("just-one-block", binaryen.Type.none, binaryen.Type.none, localTypes, body);
   }
   { // two blocks
     var relooper = new binaryen.Relooper(module);
@@ -818,7 +818,7 @@ function test_relooper() {
     var block1 = relooper.addBlock(makeCallCheck(1));
     relooper.addBranch(block0, block1); // no condition, no code on branch
     var body = relooper.renderAndDispose(block0, 0, module);
-    module.addFunction("two-blocks", binaryen.none, binaryen.none, localTypes, body);
+    module.addFunction("two-blocks", binaryen.Type.none, binaryen.Type.none, localTypes, body);
   }
   { // two blocks with code between them
     var relooper = new binaryen.Relooper(module);
@@ -826,7 +826,7 @@ function test_relooper() {
     var block1 = relooper.addBlock(makeCallCheck(1));
     relooper.addBranch(block0, block1, null, makeDroppedInt32(77)); // code on branch
     var body = relooper.renderAndDispose(block0, 0, module);
-    module.addFunction("two-blocks-plus-code", binaryen.none, binaryen.none, localTypes, body);
+    module.addFunction("two-blocks-plus-code", binaryen.Type.none, binaryen.Type.none, localTypes, body);
   }
   { // two blocks in a loop
     var relooper = new binaryen.Relooper(module);
@@ -835,7 +835,7 @@ function test_relooper() {
     relooper.addBranch(block0, block1, null, null);
     relooper.addBranch(block1, block0, null, null);
     var body = relooper.renderAndDispose(block0, 0, module);
-    module.addFunction("loop", binaryen.none, binaryen.none, localTypes, body);
+    module.addFunction("loop", binaryen.Type.none, binaryen.Type.none, localTypes, body);
   }
   { // two blocks in a loop with codes
     var relooper = new binaryen.Relooper(module);
@@ -844,7 +844,7 @@ function test_relooper() {
     relooper.addBranch(block0, block1, null, makeDroppedInt32(33));
     relooper.addBranch(block1, block0, null, makeDroppedInt32(-66));
     var body = relooper.renderAndDispose(block0, 0, module);
-    module.addFunction("loop-plus-code", binaryen.none, binaryen.none, localTypes, body);
+    module.addFunction("loop-plus-code", binaryen.Type.none, binaryen.Type.none, localTypes, body);
   }
   { // split
     var relooper = new binaryen.Relooper(module);
@@ -854,7 +854,7 @@ function test_relooper() {
     relooper.addBranch(block0, block1, makeInt32(55), null);
     relooper.addBranch(block0, block2, null, null);
     var body = relooper.renderAndDispose(block0, 0, module);
-    module.addFunction("split", binaryen.none, binaryen.none, localTypes, body);
+    module.addFunction("split", binaryen.Type.none, binaryen.Type.none, localTypes, body);
   }
   { // split + code
     var relooper = new binaryen.Relooper(module);
@@ -865,7 +865,7 @@ function test_relooper() {
     relooper.addBranch(block0, block1, makeInt32(55), temp);
     relooper.addBranch(block0, block2, null, makeDroppedInt32(20));
     var body = relooper.renderAndDispose(block0, 0, module);
-    module.addFunction("split-plus-code", binaryen.none, binaryen.none, localTypes, body);
+    module.addFunction("split-plus-code", binaryen.Type.none, binaryen.Type.none, localTypes, body);
   }
   { // if
     var relooper = new binaryen.Relooper(module);
@@ -876,7 +876,7 @@ function test_relooper() {
     relooper.addBranch(block0, block2, null, null);
     relooper.addBranch(block1, block2, null, null);
     var body = relooper.renderAndDispose(block0, 0, module);
-    module.addFunction("if", binaryen.none, binaryen.none, localTypes, body);
+    module.addFunction("if", binaryen.Type.none, binaryen.Type.none, localTypes, body);
   }
   { // if + code
     var relooper = new binaryen.Relooper(module);
@@ -888,7 +888,7 @@ function test_relooper() {
     relooper.addBranch(block0, block2, null, makeDroppedInt32(-2));
     relooper.addBranch(block1, block2, null, makeDroppedInt32(-3));
     var body = relooper.renderAndDispose(block0, 0, module);
-    module.addFunction("if-plus-code", binaryen.none, binaryen.none, localTypes, body);
+    module.addFunction("if-plus-code", binaryen.Type.none, binaryen.Type.none, localTypes, body);
   }
   { // if-else
     var relooper = new binaryen.Relooper(module);
@@ -901,7 +901,7 @@ function test_relooper() {
     relooper.addBranch(block1, block3, null, null);
     relooper.addBranch(block2, block3, null, null);
     var body = relooper.renderAndDispose(block0, 0, module);
-    module.addFunction("if-else", binaryen.none, binaryen.none, localTypes, body);
+    module.addFunction("if-else", binaryen.Type.none, binaryen.Type.none, localTypes, body);
   }
   { // loop+tail
     var relooper = new binaryen.Relooper(module);
@@ -912,7 +912,7 @@ function test_relooper() {
     relooper.addBranch(block1, block0, makeInt32(10), null);
     relooper.addBranch(block1, block2, null, null);
     var body = relooper.renderAndDispose(block0, 0, module);
-    module.addFunction("loop-tail", binaryen.none, binaryen.none, localTypes, body);
+    module.addFunction("loop-tail", binaryen.Type.none, binaryen.Type.none, localTypes, body);
   }
   { // nontrivial loop + phi to head
     var relooper = new binaryen.Relooper(module);
@@ -933,7 +933,7 @@ function test_relooper() {
     relooper.addBranch(block4, block5, null, null);
     relooper.addBranch(block5, block6, null, makeDroppedInt32(40));
     var body = relooper.renderAndDispose(block0, 0, module);
-    module.addFunction("nontrivial-loop-plus-phi-to-head", binaryen.none, binaryen.none, localTypes, body);
+    module.addFunction("nontrivial-loop-plus-phi-to-head", binaryen.Type.none, binaryen.Type.none, localTypes, body);
   }
   { // switch
     var relooper = new binaryen.Relooper(module);
@@ -946,7 +946,7 @@ function test_relooper() {
     relooper.addBranchForSwitch(block0, block2, [4], makeDroppedInt32(55));
     relooper.addBranchForSwitch(block0, block3, [], null);
     var body = relooper.renderAndDispose(block0, 0, module);
-    module.addFunction("switch", binaryen.none, binaryen.none, localTypes, body);
+    module.addFunction("switch", binaryen.Type.none, binaryen.Type.none, localTypes, body);
   }
   { // duff's device
     var relooper = new binaryen.Relooper(module);
@@ -958,7 +958,7 @@ function test_relooper() {
     relooper.addBranch(block1, block2, null, null);
     relooper.addBranch(block2, block1, null, null);
     var body = relooper.renderAndDispose(block0, 3, module); // use $3 as the helper var
-    module.addFunction("duffs-device", binaryen.none, binaryen.none, [ binaryen.i32, binaryen.i32, binaryen.i64, binaryen.i32, binaryen.f32, binaryen.f64, binaryen.i32 ], body);
+    module.addFunction("duffs-device", binaryen.Type.none, binaryen.Type.none, [ binaryen.Type.i32, binaryen.Type.i32, binaryen.Type.i64, binaryen.Type.i32, binaryen.Type.f32, binaryen.Type.f64, binaryen.Type.i32 ], body);
   }
 
   { // return in a block
@@ -966,7 +966,7 @@ function test_relooper() {
     var list = module.block("the-list", [ makeCallCheck(42), module.return(makeInt32(1337)) ]);
     var block = relooper.addBlock(list);
     var body = relooper.renderAndDispose(block, 0, module);
-    module.addFunction("return", binaryen.none, binaryen.i32, localTypes, body);
+    module.addFunction("return", binaryen.Type.none, binaryen.Type.i32, localTypes, body);
   }
 
   console.log("raw:");
@@ -994,14 +994,14 @@ function test_binaries() {
   { // create a module and write it to binary
     module = new binaryen.Module();
     module.setFeatures(binaryen.Features.All);
-    var ii = binaryen.createType([binaryen.i32, binaryen.i32]);
-    var x = module.local.get(0, binaryen.i32),
-        y = module.local.get(1, binaryen.i32);
+    var ii = binaryen.createType([binaryen.Type.i32, binaryen.Type.i32]);
+    var x = module.local.get(0, binaryen.Type.i32),
+        y = module.local.get(1, binaryen.Type.i32);
     var add = module.i32.add(x, y);
-    var adder = module.addFunction("adder", ii, binaryen.i32, [], add);
+    var adder = module.addFunction("adder", ii, binaryen.Type.i32, [], add);
     var initExpr = module.i32.const(3);
-    var global = module.addGlobal("a-global", binaryen.i32, false, initExpr)
-    var tag = module.addTag("a-tag", binaryen.createType([binaryen.i32, binaryen.i32]), binaryen.none);
+    var global = module.addGlobal("a-global", binaryen.Type.i32, false, initExpr)
+    var tag = module.addTag("a-tag", binaryen.createType([binaryen.Type.i32, binaryen.Type.i32]), binaryen.Type.none);
     binaryen.setDebugInfo(true); // include names section
     buffer = module.emitBinary();
     binaryen.setDebugInfo(false);
@@ -1026,8 +1026,8 @@ function test_binaries() {
 function test_binaries_with_features() {
   var builder = new binaryen.TypeBuilder(1);
   builder.setStructType(0, [
-    { type: binaryen.i32, packedType: binaryen.notPacked, mutable: true },
-    { type: binaryen.f64, packedType: binaryen.notPacked, mutable: true }
+    { type: binaryen.Type.i32, packedType: binaryen.PackedType.notPacked, mutable: true },
+    { type: binaryen.Type.f64, packedType: binaryen.PackedType.notPacked, mutable: true }
   ]);
   var [structHeapType] = builder.buildAndDispose();
   var structType = binaryen.getTypeFromHeapType(structHeapType, true);
@@ -1045,11 +1045,11 @@ function test_binaries_with_features() {
     )
   );
 
-  module.addFunction("get-field", binaryen.none, binaryen.i32, [],
+  module.addFunction("get-field", binaryen.Type.none, binaryen.Type.i32, [],
     module.struct.get(
       0,
       module.global.get("struct-global", structType),
-      binaryen.i32,
+      binaryen.Type.i32,
       false
     )
   );
@@ -1076,9 +1076,9 @@ function test_interpret() {
   // create a simple module with a start method that prints a number, and interpret it, printing that number.
   module = new binaryen.Module();
 
-  module.addFunctionImport("print-i32", "spectest", "print", binaryen.i32, binaryen.none);
+  module.addFunctionImport("print-i32", "spectest", "print", binaryen.Type.i32, binaryen.Type.none);
   var call = module.call("print-i32", [ makeInt32(1234) ], binaryen.None);
-  var starter = module.addFunction("starter", binaryen.none, binaryen.none, [], call);
+  var starter = module.addFunction("starter", binaryen.Type.none, binaryen.Type.none, [], call);
   module.setStart(starter);
 
   console.log(module.emitText());
@@ -1091,7 +1091,7 @@ function test_nonvalid() {
   // create a module that fails to validate
   module = new binaryen.Module();
 
-  var func = module.addFunction("func", binaryen.none, binaryen.none, [ binaryen.i32 ],
+  var func = module.addFunction("func", binaryen.Type.none, binaryen.Type.none, [ binaryen.Type.i32 ],
     module.local.set(0, makeInt64(1234, 0)) // wrong type!
   );
 
@@ -1108,14 +1108,14 @@ function test_parsing() {
   module = new binaryen.Module();
   module.setFeatures(binaryen.Features.All);
 
-  var ii = binaryen.createType([binaryen.i32, binaryen.i32]);
-  var x = module.local.get(0, binaryen.i32),
-      y = module.local.get(1, binaryen.i32);
+  var ii = binaryen.createType([binaryen.Type.i32, binaryen.Type.i32]);
+  var x = module.local.get(0, binaryen.Type.i32),
+      y = module.local.get(1, binaryen.Type.i32);
   var add = module.i32.add(x, y);
-  var adder = module.addFunction("adder", ii, binaryen.i32, [], add);
+  var adder = module.addFunction("adder", ii, binaryen.Type.i32, [], add);
   var initExpr = module.i32.const(3);
-  var global = module.addGlobal("a-global", binaryen.i32, false, initExpr)
-  var tag = module.addTag("a-tag", binaryen.i32, binaryen.none);
+  var global = module.addGlobal("a-global", binaryen.Type.i32, false, initExpr)
+  var tag = module.addTag("a-tag", binaryen.Type.i32, binaryen.Type.none);
   text = module.emitText();
   module.dispose();
   module = null;
@@ -1158,9 +1158,9 @@ function test_for_each() {
   var funcNames = [ "fn0", "fn1", "fn2" ];
 
   var fns = [
-    module.addFunction(funcNames[0], binaryen.none, binaryen.none, [], module.nop()),
-    module.addFunction(funcNames[1], binaryen.none, binaryen.none, [], module.nop()),
-    module.addFunction(funcNames[2], binaryen.none, binaryen.none, [], module.nop())
+    module.addFunction(funcNames[0], binaryen.Type.none, binaryen.Type.none, [], module.nop()),
+    module.addFunction(funcNames[1], binaryen.Type.none, binaryen.Type.none, [], module.nop()),
+    module.addFunction(funcNames[2], binaryen.Type.none, binaryen.Type.none, [], module.nop())
   ];
 
   var i;
@@ -1184,9 +1184,9 @@ function test_for_each() {
   var expected_passive = [false, false, true];
 
   var glos = [
-    module.addGlobal("a-global", binaryen.i32, false, module.i32.const(expected_offsets[1])),
-    module.addGlobal("a-global2", binaryen.i32, false, module.i32.const(2)),
-    module.addGlobal("a-global3", binaryen.i32, false, module.i32.const(3))
+    module.addGlobal("a-global", binaryen.Type.i32, false, module.i32.const(expected_offsets[1])),
+    module.addGlobal("a-global2", binaryen.Type.i32, false, module.i32.const(2)),
+    module.addGlobal("a-global3", binaryen.Type.i32, false, module.i32.const(3))
   ];
 
   for (i = 0; i < module.getNumGlobals(); i++) {
@@ -1294,9 +1294,9 @@ function test_relaxed_atomics() {
     module.drop(rmw),
     module.drop(cmpxchg),
     fence,
-  ], binaryen.auto);
+  ], binaryen.Type.auto);
 
-  module.addFunction("acquire-release-atomics", binaryen.none, binaryen.none, [], body);
+  module.addFunction("acquire-release-atomics", binaryen.Type.none, binaryen.Type.none, [], body);
 
   console.log(module.emitText());
   module.dispose();
diff --git a/test/binaryen.js/reloc.js b/test/binaryen.js/reloc.js
index cd63fb5a45d..1ea6d9764a2 100644
--- a/test/binaryen.js/reloc.js
+++ b/test/binaryen.js/reloc.js
@@ -2,21 +2,21 @@ var module = new binaryen.Module();
 
 // memory with offset
 
-module.addGlobalImport("memory_base", "env", "memory_base", binaryen.i32, false);
+module.addGlobalImport("memory_base", "env", "memory_base", binaryen.Type.i32, false);
 module.setMemory(1, -1, null, [
   {
     name: "x0",
-    offset: module.global.get("memory_base", binaryen.i32),
+    offset: module.global.get("memory_base", binaryen.Type.i32),
     data: "data data".split('').map(function(x) { return x.charCodeAt(0) })
   }
 ]);
 
 // table with offset
 
-var func = module.addFunction("func", binaryen.none, binaryen.none, [], module.nop());
+var func = module.addFunction("func", binaryen.Type.none, binaryen.Type.none, [], module.nop());
 
-module.addGlobalImport("table_base", "env", "table_base", binaryen.i32, false);
-module.addTable("0", 1, -1, binaryen.funcref);
-module.addActiveElementSegment("0", "0", [ "func", "func" ], module.global.get("table_base", binaryen.i32));
+module.addGlobalImport("table_base", "env", "table_base", binaryen.Type.i32, false);
+module.addTable("0", 1, -1, binaryen.Type.funcref);
+module.addActiveElementSegment("0", "0", [ "func", "func" ], module.global.get("table_base", binaryen.Type.i32));
 assert(module.validate());
 console.log(module.emitText());
diff --git a/test/binaryen.js/sideffects.js b/test/binaryen.js/sideffects.js
index 050918e369c..1b76ba98197 100644
--- a/test/binaryen.js/sideffects.js
+++ b/test/binaryen.js/sideffects.js
@@ -37,7 +37,7 @@ assert(
 );
 assert(
   binaryen.getSideEffects(
-    module.call("test", [], binaryen.i32),
+    module.call("test", [], binaryen.Type.i32),
     module
   )
   ==
@@ -45,7 +45,7 @@ assert(
 );
 assert(
   binaryen.getSideEffects(
-    module.local.get("test", binaryen.i32),
+    module.local.get("test", binaryen.Type.i32),
     module
   )
   ==
@@ -63,11 +63,11 @@ assert(
 );
 
 // Add a global for the test, as computing side effects will look for it.
-module.addGlobal('test', binaryen.i32, true, module.i32.const(42));
+module.addGlobal('test', binaryen.Type.i32, true, module.i32.const(42));
 
 assert(
   binaryen.getSideEffects(
-    module.global.get("test", binaryen.i32),
+    module.global.get("test", binaryen.Type.i32),
     module
   )
   ==
@@ -118,7 +118,7 @@ assert(
 module.setFeatures(binaryen.Features.ExceptionHandling);
 assert(
   binaryen.getSideEffects(
-    module.call("test", [], binaryen.i32),
+    module.call("test", [], binaryen.Type.i32),
     module
   )
   ==
@@ -129,7 +129,7 @@ assert(
 module.setFeatures(binaryen.Features.StackSwitching);
 assert(
   binaryen.getSideEffects(
-    module.call("test", [], binaryen.i32),
+    module.call("test", [], binaryen.Type.i32),
     module
   )
   ==
@@ -140,7 +140,7 @@ assert(
 module.setFeatures(binaryen.Features.All);
 assert(
   binaryen.getSideEffects(
-    module.call("test", [], binaryen.i32),
+    module.call("test", [], binaryen.Type.i32),
     module
   )
   ==
diff --git a/test/binaryen.js/sieve.js b/test/binaryen.js/sieve.js
index 4ba61a43492..a315038b700 100644
--- a/test/binaryen.js/sieve.js
+++ b/test/binaryen.js/sieve.js
@@ -14,14 +14,14 @@ var body = module.block(
           module.memory.size(),
           module.i32.const(65536)
         ),
-        module.local.get(0, binaryen.i32)
+        module.local.get(0, binaryen.Type.i32)
       ),
       module.drop(
         module.memory.grow(
           module.i32.sub(
             module.i32.div_u(
               module.i32.add(
-                module.local.get(0, binaryen.i32),
+                module.local.get(0, binaryen.Type.i32),
                 module.i32.const(65535)
               ),
               module.i32.const(65536)
@@ -35,28 +35,28 @@ var body = module.block(
     module.local.set(1, module.i32.const(0)),
     module.loop('clear', module.block(null, [
       module.i32.store8(0, 1,
-        module.local.get(1, binaryen.i32),
+        module.local.get(1, binaryen.Type.i32),
         module.i32.const(0)
       ),
       module.local.set(1, module.i32.add(
-        module.local.get(1, binaryen.i32),
+        module.local.get(1, binaryen.Type.i32),
         module.i32.const(1)
       )),
       module.br_if('clear', module.i32.eq(
-        module.local.get(1, binaryen.i32),
-        module.local.get(0, binaryen.i32)
+        module.local.get(1, binaryen.Type.i32),
+        module.local.get(0, binaryen.Type.i32)
       ))
     ])),
     // perform the sieve TODO
     // calculate how many primes there are
-    module.return(module.local.get(0, binaryen.i32))
+    module.return(module.local.get(0, binaryen.Type.i32))
   ],
-  binaryen.none
+  binaryen.Type.none
 );
 
 // Create the add function
 // Note: no additional local variables (that's the [])
-module.addFunction('sieve', binaryen.i32, binaryen.i32, [binaryen.i32], body);
+module.addFunction('sieve', binaryen.Type.i32, binaryen.Type.i32, [binaryen.Type.i32], body);
 
 // Export the function, so we can call it later (for simplicity we
 // export it as the same name as it has internally)
diff --git a/test/binaryen.js/sourcemap.js b/test/binaryen.js/sourcemap.js
index 90f41c72099..a3e5e57b9e3 100644
--- a/test/binaryen.js/sourcemap.js
+++ b/test/binaryen.js/sourcemap.js
@@ -8,9 +8,9 @@ console.log();
 var expr = module.i32.const(1);
 var body = module.block("", [
   expr
-], binaryen.i32);
+], binaryen.Type.i32);
 
-var func = module.addFunction("main", binaryen.none, binaryen.i32, [], body);
+var func = module.addFunction("main", binaryen.Type.none, binaryen.Type.i32, [], body);
 
 module.setDebugLocation(func, expr, fileIndex, 1, 2);
 module.setDebugLocation(func, body, fileIndex, 0, 3);
diff --git a/test/binaryen.js/tables.js b/test/binaryen.js/tables.js
index f711d0d054c..b3834818a25 100644
--- a/test/binaryen.js/tables.js
+++ b/test/binaryen.js/tables.js
@@ -34,16 +34,16 @@ assert(binaryen.Table.getMax(tablePtr) === 20);
 binaryen.Table.setMax(tablePtr, tableMax);
 
 // get/set type
-assert(binaryen.Table.getType(tablePtr) === binaryen.funcref);
-binaryen.Table.setType(tablePtr, binaryen.anyref);
-assert(binaryen.Table.getType(tablePtr) === binaryen.anyref);
-binaryen.Table.setType(tablePtr, binaryen.funcref);
+assert(binaryen.Table.getType(tablePtr) === binaryen.Type.funcref);
+binaryen.Table.setType(tablePtr, binaryen.Type.anyref);
+assert(binaryen.Table.getType(tablePtr) === binaryen.Type.anyref);
+binaryen.Table.setType(tablePtr, binaryen.Type.funcref);
 
 const tableRef = binaryen.Table(tablePtr);
 assert(tableRef.name === tableName);
 assert(tableRef.initial === tableMin);
 assert(tableRef.max === tableMax);
-assert(tableRef.type === binaryen.funcref);
+assert(tableRef.type === binaryen.Type.funcref);
 
 // Cleanup
 assert(module.validate());
diff --git a/test/binaryen.js/tag.js b/test/binaryen.js/tag.js
index 88783fe5511..833ed2a022f 100644
--- a/test/binaryen.js/tag.js
+++ b/test/binaryen.js/tag.js
@@ -11,9 +11,9 @@ module.setFeatures(binaryen.Features.ReferenceTypes |
                    binaryen.Features.ExceptionHandling |
                    binaryen.Features.Multivalue);
 
-var pairType = binaryen.createType([binaryen.i32, binaryen.f32]);
+var pairType = binaryen.createType([binaryen.Type.i32, binaryen.Type.f32]);
 
-var tag = module.addTag("a-tag", binaryen.i32, binaryen.none);
+var tag = module.addTag("a-tag", binaryen.Type.i32, binaryen.Type.none);
 
 console.log("GetTag is equal: " + (tag === module.getTag("a-tag")));
 
@@ -21,7 +21,7 @@ var tagInfo = binaryen.getTagInfo(tag);
 console.log("getTagInfo=" + JSON.stringify(cleanInfo(tagInfo)));
 
 module.addTagExport("a-tag", "a-tag-exp");
-module.addTagImport("a-tag-imp", "module", "base", pairType, binaryen.none);
+module.addTagImport("a-tag-imp", "module", "base", pairType, binaryen.Type.none);
 
 assert(module.validate());
 console.log(module.emitText());
diff --git a/test/binaryen.js/tail_calls.js b/test/binaryen.js/tail_calls.js
index 61fe5d829fb..2bde4834b2e 100644
--- a/test/binaryen.js/tail_calls.js
+++ b/test/binaryen.js/tail_calls.js
@@ -6,23 +6,23 @@ module.addTableImport("0", "env", "table");
 
 var foo = module.addFunction(
   "foo",
-  binaryen.none,
-  binaryen.none,
+  binaryen.Type.none,
+  binaryen.Type.none,
   [],
-  module.return_call("foo", [], binaryen.none, binaryen.none)
+  module.return_call("foo", [], binaryen.Type.none, binaryen.Type.none)
 );
 
 var bar = module.addFunction(
   "bar",
-  binaryen.none,
-  binaryen.none,
+  binaryen.Type.none,
+  binaryen.Type.none,
   [],
   module.return_call_indirect(
     "0",
     module.i32.const(0),
     [],
-    binaryen.none,
-    binaryen.none
+    binaryen.Type.none,
+    binaryen.Type.none
   )
 );
 
diff --git a/test/binaryen.js/validation_errors.js b/test/binaryen.js/validation_errors.js
index b7ee5d00ea8..b22112f589b 100644
--- a/test/binaryen.js/validation_errors.js
+++ b/test/binaryen.js/validation_errors.js
@@ -1,9 +1,9 @@
 (function() {
   var mod = new binaryen.Module();
-  var func = mod.addFunction("test", binaryen.none, binaryen.none, [],
+  var func = mod.addFunction("test", binaryen.Type.none, binaryen.Type.none, [],
     mod.block("", [
       mod.drop(
-        mod.global.get("missing", binaryen.i32)
+        mod.global.get("missing", binaryen.Type.i32)
       )
     ])
   );
@@ -13,10 +13,10 @@
 
 (function() {
   var mod = new binaryen.Module();
-  var func = mod.addFunction("test", binaryen.none, binaryen.none, [],
+  var func = mod.addFunction("test", binaryen.Type.none, binaryen.Type.none, [],
     mod.block("", [
       mod.drop(
-        mod.local.get(0, binaryen.i32)
+        mod.local.get(0, binaryen.Type.i32)
       )
     ])
   );