porffor 0.2.0-fde989a → 0.14.0-032e4ad08

package/compiler/prefs.js

@@ -0,0 +1,31 @@
+const onByDefault = [ 'bytestring', 'treeshakeWasmImports', 'alwaysMemory', 'indirectCalls', 'optUnused' ];
+
+let cache = {};
+const obj = new Proxy({}, {
+  get(_, p) {
+    // intentionally misses with undefined values cached
+    if (cache[p]) return cache[p];
+
+    const ret = (() => {
+      // fooBar -> foo-bar
+      const name = p[0] === '_' ? p : p.replace(/[A-Z]/g, c => `-${c.toLowerCase()}`);
+      const prefix = name.length === 1 ? '-' : '--';
+      if (process.argv.includes(prefix + name)) return true;
+      if (process.argv.includes(prefix + 'no-' + name)) return false;
+
+      const valArg = process.argv.find(x => x.startsWith(`${prefix}${name}=`));
+      if (valArg) return valArg.slice(name.length + 1 + prefix.length);
+
+      if (onByDefault.includes(p)) return true;
+      return undefined;
+    })();
+
+    // do not cache in web demo as args are changed live
+    if (!globalThis.document) cache[p] = ret;
+    return ret;
+  }
+});
+
+obj.uncache = () => cache = {};
+
+export default obj;

package/compiler/prototype.js

@@ -1,36 +1,22 @@
-import { Opcodes, Blocktype, Valtype, ValtypeSize, PageSize } from "./wasmSpec.js";
-import { number } from "./embedding.js";
-import { unsignedLEB128 } from "./encoding.js";
-import { UNDEFINED } from "./builtins.js";
-
-// todo: do not duplicate this
-const TYPES = {
-  number: 0x00,
-  boolean: 0x01,
-  string: 0x02,
-  undefined: 0x03,
-  object: 0x04,
-  function: 0x05,
-  symbol: 0x06,
-  bigint: 0x07,
-
-  // these are not "typeof" types but tracked internally
-  _array: 0x10,
-  _regexp: 0x11,
-  _bytestring: 0x12
-};
+import { Opcodes, Blocktype, Valtype, ValtypeSize } from './wasmSpec.js';
+import { number } from './embedding.js';
+import { unsignedLEB128 } from './encoding.js';
+import { UNDEFINED } from './builtins.js';
+import { TYPES } from './types.js';
+import Prefs from './prefs.js';
 
 // todo: turn these into built-ins once arrays and these become less hacky
 
 export const PrototypeFuncs = function() {
-  const noUnlikelyChecks = process.argv.includes('-funsafe-no-unlikely-proto-checks');
-  let zeroChecks = process.argv.find(x => x.startsWith('-funsafe-zero-proto-checks='));
-  if (zeroChecks) zeroChecks = zeroChecks.split('=')[1].split(',').reduce((acc, x) => { acc[x.toLowerCase()] = true; return acc; }, {});
+  const noUnlikelyChecks = Prefs.funsafeNoUnlikelyProtoChecks;
+
+  let zeroChecks;
+  if (Prefs.zeroChecks) zeroChecks = Prefs.zeroChecks.split('=')[1].split(',').reduce((acc, x) => { acc[x.toLowerCase()] = true; return acc; }, {});
     else zeroChecks = {};
 
-  this[TYPES._array] = {
+  this[TYPES.array] = {
     // lX = local accessor of X ({ get, set }), iX = local index of X, wX = wasm ops of X
-    at: (pointer, length, wIndex, iTmp) => [
+    at: (pointer, length, wIndex, wType, iTmp) => [
       ...wIndex,
       Opcodes.i32_to,
       [ Opcodes.local_tee, iTmp ],
@@ -61,31 +47,39 @@ export const PrototypeFuncs = function() {
       [ Opcodes.end ],
 
       [ Opcodes.local_get, iTmp ],
-      ...number(ValtypeSize[valtype], Valtype.i32),
+      ...number(ValtypeSize[valtype] + 1, Valtype.i32),
       [ Opcodes.i32_mul ],
-
       ...pointer,
       [ Opcodes.i32_add ],
+      [ Opcodes.local_set, iTmp ],
 
       // read from memory
-      [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(ValtypeSize.i32) ]
+      [ Opcodes.local_get, iTmp ],
+      [ Opcodes.load, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+
+      [ Opcodes.local_get, iTmp ],
+      [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32 + ValtypeSize[valtype]) ]
     ],
 
     // todo: only for 1 argument
-    push: (pointer, length, wNewMember, _1, _2, _3, unusedValue) => [
+    push: (pointer, length, wNewMember, wType, iTmp, _2, _3, unusedValue) => [
       // get memory offset of array at last index (length)
       ...length.getCachedI32(),
-      ...number(ValtypeSize[valtype], Valtype.i32),
+      ...number(ValtypeSize[valtype] + 1, Valtype.i32),
       [ Opcodes.i32_mul ],
-
       ...pointer,
       [ Opcodes.i32_add ],
+      [ Opcodes.local_set, iTmp ],
 
-      // generated wasm for new member
+      // store value
+      [ Opcodes.local_get, iTmp ],
       ...wNewMember,
+      [ Opcodes.store, 0, ...unsignedLEB128(ValtypeSize.i32) ],
 
-      // store in memory
-      [ Opcodes.store, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
+      // store type
+      [ Opcodes.local_get, iTmp ],
+      ...wType,
+      [ Opcodes.i32_store8, 0, ...unsignedLEB128(ValtypeSize.i32 + ValtypeSize[valtype]) ],
 
       // bump array length by 1 and return it
       ...length.setI32([
@@ -107,7 +101,7 @@ export const PrototypeFuncs = function() {
       // ...length.get()
     ],
 
-    pop: (pointer, length, _1, _2, _3, _4, unusedValue) => [
+    pop: (pointer, length, _1, _2, iTmp, _3, _4, unusedValue) => [
       // if length == 0, noop
       ...length.getCachedI32(),
       [ Opcodes.i32_eqz ],
@@ -135,20 +129,25 @@ export const PrototypeFuncs = function() {
       // load last element
       ...(unusedValue() ? [] : [
         ...length.getCachedI32(),
-        ...number(ValtypeSize[valtype], Valtype.i32),
+        ...number(ValtypeSize[valtype] + 1, Valtype.i32),
         [ Opcodes.i32_mul ],
 
         ...pointer,
         [ Opcodes.i32_add ],
+        [ Opcodes.local_set, iTmp ],
 
-        [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(ValtypeSize.i32) ]
+        [ Opcodes.local_get, iTmp ],
+        [ Opcodes.load, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+
+        [ Opcodes.local_get, iTmp ],
+        [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32 + ValtypeSize[valtype]) ]
       ])
     ],
 
     shift: (pointer, length) => [
       // if length == 0, noop
       ...length.getCachedI32(),
-      Opcodes.i32_eqz,
+      [ Opcodes.i32_eqz ],
       [ Opcodes.if, Blocktype.void ],
       ...number(UNDEFINED),
       [ Opcodes.br, 1 ],
@@ -167,8 +166,12 @@ export const PrototypeFuncs = function() {
       ]),
 
       // load first element
+      // todo/perf: unusedValue opt
+      ...pointer,
+      [ Opcodes.load, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+
       ...pointer,
-      [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
+      [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32 + ValtypeSize[valtype]) ],
 
       // offset page by -1 ind
       // ...number(pointer + ValtypeSize.i32, Valtype.i32), // dst = base array index + length size
@@ -184,13 +187,13 @@ export const PrototypeFuncs = function() {
       [ Opcodes.i32_add ],
 
       // src = base array index + length size + an index
-      ...number(ValtypeSize.i32 + ValtypeSize[valtype], Valtype.i32),
+      ...number(ValtypeSize.i32 + ValtypeSize[valtype] + 1, Valtype.i32),
       ...pointer,
       [ Opcodes.i32_add ],
 
       // size = new length * sizeof element
       ...length.getCachedI32(),
-      ...number(ValtypeSize[valtype], Valtype.i32),
+      ...number(ValtypeSize[valtype] + 1, Valtype.i32),
       [ Opcodes.i32_mul ],
       [ ...Opcodes.memory_copy, 0x00, 0x00 ]
 
@@ -208,7 +211,7 @@ export const PrototypeFuncs = function() {
       // ]),
     ],
 
-    fill: (pointer, length, wElement, iTmp) => [
+    fill: (pointer, length, wElement, wType, iTmp, iTmp2) => [
       ...wElement,
       [ Opcodes.local_set, iTmp ],
 
@@ -220,7 +223,7 @@ export const PrototypeFuncs = function() {
       [ Opcodes.i32_sub ],
 
       // * sizeof value
-      ...number(ValtypeSize[valtype], Valtype.i32),
+      ...number(ValtypeSize[valtype] + 1, Valtype.i32),
       [ Opcodes.i32_mul ],
 
       ...length.setCachedI32(),
@@ -238,17 +241,25 @@ export const PrototypeFuncs = function() {
 
       [ Opcodes.loop, Blocktype.void ],
 
-      // set element using pointer
+      // calculate offset
       ...length.getCachedI32(),
       ...pointer,
       [ Opcodes.i32_add ],
+      [ Opcodes.local_set, iTmp2 ],
 
+      // store value
+      [ Opcodes.local_get, iTmp2 ],
       [ Opcodes.local_get, iTmp ],
-      [ Opcodes.store, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128( ValtypeSize.i32) ],
+      [ Opcodes.store, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+
+      // store type
+      [ Opcodes.local_get, iTmp2 ],
+      ...wType,
+      [ Opcodes.i32_store8, 0, ...unsignedLEB128(ValtypeSize.i32 + ValtypeSize[valtype]) ],
 
       // pointer - sizeof value
       ...length.getCachedI32(),
-      ...number(ValtypeSize[valtype], Valtype.i32),
+      ...number(ValtypeSize[valtype] + 1, Valtype.i32),
       [ Opcodes.i32_sub ],
 
       ...length.setCachedI32(),
@@ -267,13 +278,17 @@ export const PrototypeFuncs = function() {
     ]
   };
 
-  this[TYPES._array].at.local = Valtype.i32;
-  this[TYPES._array].push.noArgRetLength = true;
-  this[TYPES._array].fill.local = valtypeBinary;
-  this[TYPES._array].fill.returnType = TYPES._array;
+  this[TYPES.array].at.local = Valtype.i32;
+  this[TYPES.array].push.returnType = TYPES.number;
+  this[TYPES.array].push.noArgRetLength = true;
+  this[TYPES.array].push.local = Valtype.i32;
+  this[TYPES.array].pop.local = Valtype.i32;
+  this[TYPES.array].fill.local = valtypeBinary;
+  this[TYPES.array].fill.local2 = Valtype.i32;
+  this[TYPES.array].fill.returnType = TYPES.array;
 
   this[TYPES.string] = {
-    at: (pointer, length, wIndex, iTmp, _, arrayShell) => {
+    at: (pointer, length, wIndex, wType, iTmp, _, arrayShell) => {
       const [ newOut, newPointer ] = arrayShell(1, 'i16');
 
       return [
@@ -331,7 +346,7 @@ export const PrototypeFuncs = function() {
     },
 
     // todo: out of bounds properly
-    charAt: (pointer, length, wIndex, _1, _2, arrayShell) => {
+    charAt: (pointer, length, wIndex, wType, _1, _2, arrayShell) => {
       const [ newOut, newPointer ] = arrayShell(1, 'i16');
 
       return [
@@ -342,8 +357,8 @@ export const PrototypeFuncs = function() {
         ...number(0, Valtype.i32), // base 0 for store later
 
         ...wIndex,
-
         Opcodes.i32_to,
+
         ...number(ValtypeSize.i16, Valtype.i32),
         [ Opcodes.i32_mul ],
 
@@ -361,127 +376,124 @@ export const PrototypeFuncs = function() {
       ];
     },
 
-    charCodeAt: (pointer, length, wIndex, iTmp) => {
-      return [
-        ...wIndex,
-        Opcodes.i32_to,
-
-        ...(zeroChecks.charcodeat ? [] : [
-          [ Opcodes.local_set, iTmp ],
+    charCodeAt: (pointer, length, wIndex, wType, iTmp) => [
+      ...wIndex,
+      Opcodes.i32_to,
 
-          // index < 0
-          ...(noUnlikelyChecks ? [] : [
-            [ Opcodes.local_get, iTmp ],
-            ...number(0, Valtype.i32),
-            [ Opcodes.i32_lt_s ],
-          ]),
+      ...(zeroChecks.charcodeat ? [] : [
+        [ Opcodes.local_set, iTmp ],
 
-          // index >= length
+        // index < 0
+        ...(noUnlikelyChecks ? [] : [
           [ Opcodes.local_get, iTmp ],
-          ...length.getCachedI32(),
-          [ Opcodes.i32_ge_s ],
+          ...number(0, Valtype.i32),
+          [ Opcodes.i32_lt_s ],
+        ]),
 
-          ...(noUnlikelyChecks ? [] : [ [ Opcodes.i32_or ] ]),
-          [ Opcodes.if, Blocktype.void ],
-          ...number(NaN),
-          [ Opcodes.br, 1 ],
-          [ Opcodes.end ],
+        // index >= length
+        [ Opcodes.local_get, iTmp ],
+        ...length.getCachedI32(),
+        [ Opcodes.i32_ge_s ],
 
-          [ Opcodes.local_get, iTmp ],
-        ]),
+        ...(noUnlikelyChecks ? [] : [ [ Opcodes.i32_or ] ]),
+        [ Opcodes.if, Blocktype.void ],
+        ...number(valtype === 'i32' ? -1 : NaN),
+        [ Opcodes.br, 1 ],
+        [ Opcodes.end ],
 
-        ...number(ValtypeSize.i16, Valtype.i32),
-        [ Opcodes.i32_mul ],
+        [ Opcodes.local_get, iTmp ],
+      ]),
 
-        ...pointer,
-        [ Opcodes.i32_add ],
+      ...number(ValtypeSize.i16, Valtype.i32),
+      [ Opcodes.i32_mul ],
 
-        // load current string ind {arg}
-        [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
-        Opcodes.i32_from_u
-      ];
-    },
+      ...pointer,
+      [ Opcodes.i32_add ],
 
-    isWellFormed: (pointer, length, wIndex, iTmp, iTmp2) => {
-      return [
-        // note: we cannot presume it begins as 0 in case it was used previously
-        ...pointer,
-        [ Opcodes.local_set, iTmp ],
+      // load current string ind {arg}
+      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
+      Opcodes.i32_from_u
+    ],
 
-        // use cached length as end pointer
-        ...length.getCachedI32(),
-        ...number(ValtypeSize.i16, Valtype.i32),
-        [ Opcodes.i32_mul ],
-        ...pointer,
-        [ Opcodes.i32_add ],
-        ...length.setCachedI32(),
+    isWellFormed: (pointer, length, _1, _2, iTmp, iTmp2) => [
+      // note: we cannot presume it begins as 0 in case it was used previously
+      ...pointer,
+      [ Opcodes.local_set, iTmp ],
 
-        [ Opcodes.loop, Blocktype.void ],
+      // use cached length as end pointer
+      ...length.getCachedI32(),
+      ...number(ValtypeSize.i16, Valtype.i32),
+      [ Opcodes.i32_mul ],
+      ...pointer,
+      [ Opcodes.i32_add ],
+      ...length.setCachedI32(),
 
-        [ Opcodes.block, Blocktype.void ],
+      [ Opcodes.loop, Blocktype.void ],
 
-        [ Opcodes.local_get, iTmp ],
-        [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
-        [ Opcodes.local_set, iTmp2 ],
-
-        // if not surrogate, continue
-        [ Opcodes.local_get, iTmp2 ],
-        ...number(0xF800, Valtype.i32),
-        [ Opcodes.i32_and ],
-        ...number(0xD800, Valtype.i32),
-        [ Opcodes.i32_ne ],
-        [ Opcodes.br_if, 0 ],
-
-        // if not leading surrogate, return false
-        [ Opcodes.local_get, iTmp2 ],
-        ...number(0xDC00, Valtype.i32),
-        [ Opcodes.i32_ge_s ],
-        [ Opcodes.if, Blocktype.void ],
-        ...number(0),
-        [ Opcodes.br, 3 ],
-        [ Opcodes.end ],
+      [ Opcodes.block, Blocktype.void ],
 
-        // if not followed by trailing surrogate, return false
-        [ Opcodes.local_get, iTmp ],
-        [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32 + ValtypeSize.i16) ],
-        ...number(0xFC00, Valtype.i32),
-        [ Opcodes.i32_and ],
-        ...number(0xDC00, Valtype.i32),
-        [ Opcodes.i32_ne ],
-        [ Opcodes.if, Blocktype.void ],
-        ...number(0),
-        [ Opcodes.br, 3 ],
-        [ Opcodes.end ],
+      [ Opcodes.local_get, iTmp ],
+      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
+      [ Opcodes.local_set, iTmp2 ],
+
+      // if not surrogate, continue
+      [ Opcodes.local_get, iTmp2 ],
+      ...number(0xF800, Valtype.i32),
+      [ Opcodes.i32_and ],
+      ...number(0xD800, Valtype.i32),
+      [ Opcodes.i32_ne ],
+      [ Opcodes.br_if, 0 ],
 
-        // bump index again since gone through two valid chars
-        [ Opcodes.local_get, iTmp ],
-        ...number(ValtypeSize.i16, Valtype.i32),
-        [ Opcodes.i32_add ],
-        [ Opcodes.local_set, iTmp ],
+      // if not leading surrogate, return false
+      [ Opcodes.local_get, iTmp2 ],
+      ...number(0xDC00, Valtype.i32),
+      [ Opcodes.i32_ge_s ],
+      [ Opcodes.if, Blocktype.void ],
+      ...number(0),
+      [ Opcodes.br, 3 ],
+      [ Opcodes.end ],
 
-        [ Opcodes.end ],
+      // if not followed by trailing surrogate, return false
+      [ Opcodes.local_get, iTmp ],
+      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32 + ValtypeSize.i16) ],
+      ...number(0xFC00, Valtype.i32),
+      [ Opcodes.i32_and ],
+      ...number(0xDC00, Valtype.i32),
+      [ Opcodes.i32_ne ],
+      [ Opcodes.if, Blocktype.void ],
+      ...number(0),
+      [ Opcodes.br, 3 ],
+      [ Opcodes.end ],
 
-        // bump pointer and loop if not at the end
-        [ Opcodes.local_get, iTmp ],
-        ...number(ValtypeSize.i16, Valtype.i32),
-        [ Opcodes.i32_add ],
-        [ Opcodes.local_tee, iTmp ],
+      // bump index again since gone through two valid chars
+      [ Opcodes.local_get, iTmp ],
+      ...number(ValtypeSize.i16, Valtype.i32),
+      [ Opcodes.i32_add ],
+      [ Opcodes.local_set, iTmp ],
+
+      [ Opcodes.end ],
 
-        ...length.getCachedI32(), // end pointer
-        [ Opcodes.i32_ne ],
-        [ Opcodes.br_if, 0 ],
+      // bump pointer and loop if not at the end
+      [ Opcodes.local_get, iTmp ],
+      ...number(ValtypeSize.i16, Valtype.i32),
+      [ Opcodes.i32_add ],
+      [ Opcodes.local_tee, iTmp ],
 
-        [ Opcodes.end ],
+      ...length.getCachedI32(), // end pointer
+      [ Opcodes.i32_ne ],
+      [ Opcodes.br_if, 0 ],
 
-        // return true
-        ...number(1)
-      ]
-    }
+      [ Opcodes.end ],
+
+      // return true
+      ...number(1)
+    ]
   };
 
   this[TYPES.string].at.local = Valtype.i32;
   this[TYPES.string].at.returnType = TYPES.string;
   this[TYPES.string].charAt.returnType = TYPES.string;
+  this[TYPES.string].charCodeAt.returnType = TYPES.number;
   this[TYPES.string].charCodeAt.local = Valtype.i32;
   this[TYPES.string].charCodeAt.noPointerCache = zeroChecks.charcodeat;
 
@@ -489,10 +501,10 @@ export const PrototypeFuncs = function() {
   this[TYPES.string].isWellFormed.local2 = Valtype.i32;
   this[TYPES.string].isWellFormed.returnType = TYPES.boolean;
 
-  if (process.argv.includes('-bytestring')) {
-    this[TYPES._bytestring] = {
-      at: (pointer, length, wIndex, iTmp, _, arrayShell) => {
-        const [ newOut, newPointer ] = arrayShell(1, 'i16');
+  if (Prefs.bytestring) {
+    this[TYPES.bytestring] = {
+      at: (pointer, length, wIndex, wType, iTmp, _, arrayShell) => {
+        const [ newOut, newPointer ] = arrayShell(1, 'i8');
 
         return [
           // setup new/out array
@@ -547,8 +559,8 @@ export const PrototypeFuncs = function() {
       },
 
       // todo: out of bounds properly
-      charAt: (pointer, length, wIndex, _1, _2, arrayShell) => {
-        const [ newOut, newPointer ] = arrayShell(1, 'i16');
+      charAt: (pointer, length, wIndex, wType, _1, _2, arrayShell) => {
+        const [ newOut, newPointer ] = arrayShell(1, 'i8');
 
         return [
           // setup new/out array
@@ -558,7 +570,6 @@ export const PrototypeFuncs = function() {
           ...number(0, Valtype.i32), // base 0 for store later
 
           ...wIndex,
-
           Opcodes.i32_to,
 
           ...pointer,
@@ -575,60 +586,57 @@ export const PrototypeFuncs = function() {
         ];
       },
 
-      charCodeAt: (pointer, length, wIndex, iTmp) => {
-        return [
-          ...wIndex,
-          Opcodes.i32_to,
-
-          ...(zeroChecks.charcodeat ? [] : [
-            [ Opcodes.local_set, iTmp ],
+      charCodeAt: (pointer, length, wIndex, wType, iTmp) => [
+        ...wIndex,
+        Opcodes.i32_to,
 
-            // index < 0
-            ...(noUnlikelyChecks ? [] : [
-              [ Opcodes.local_get, iTmp ],
-              ...number(0, Valtype.i32),
-              [ Opcodes.i32_lt_s ],
-            ]),
+        ...(zeroChecks.charcodeat ? [] : [
+          [ Opcodes.local_set, iTmp ],
 
-            // index >= length
+          // index < 0
+          ...(noUnlikelyChecks ? [] : [
             [ Opcodes.local_get, iTmp ],
-            ...length.getCachedI32(),
-            [ Opcodes.i32_ge_s ],
+            ...number(0, Valtype.i32),
+            [ Opcodes.i32_lt_s ],
+          ]),
 
-            ...(noUnlikelyChecks ? [] : [ [ Opcodes.i32_or ] ]),
-            [ Opcodes.if, Blocktype.void ],
-            ...number(NaN),
-            [ Opcodes.br, 1 ],
-            [ Opcodes.end ],
+          // index >= length
+          [ Opcodes.local_get, iTmp ],
+          ...length.getCachedI32(),
+          [ Opcodes.i32_ge_s ],
 
-            [ Opcodes.local_get, iTmp ],
-          ]),
+          ...(noUnlikelyChecks ? [] : [ [ Opcodes.i32_or ] ]),
+          [ Opcodes.if, Blocktype.void ],
+          ...number(valtype === 'i32' ? -1 : NaN),
+          [ Opcodes.br, 1 ],
+          [ Opcodes.end ],
 
-          ...pointer,
-          [ Opcodes.i32_add ],
+          [ Opcodes.local_get, iTmp ],
+        ]),
 
-          // load current string ind {arg}
-          [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32) ],
-          Opcodes.i32_from_u
-        ];
-      },
+        ...pointer,
+        [ Opcodes.i32_add ],
 
-      isWellFormed: () => {
-        return [
-          // we know it must be true as it is a bytestring lol
-          ...number(1)
-        ]
-      }
+        // load current string ind {arg}
+        [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+        Opcodes.i32_from_u
+      ],
+
+      isWellFormed: () => [
+        // we know it must be true as it is a bytestring lol
+        ...number(1)
+      ]
     };
 
-    this[TYPES._bytestring].at.local = Valtype.i32;
-    this[TYPES._bytestring].at.returnType = TYPES._bytestring;
-    this[TYPES._bytestring].charAt.returnType = TYPES._bytestring;
-    this[TYPES._bytestring].charCodeAt.local = Valtype.i32;
-    this[TYPES._bytestring].charCodeAt.noPointerCache = zeroChecks.charcodeat;
+    this[TYPES.bytestring].at.local = Valtype.i32;
+    this[TYPES.bytestring].at.returnType = TYPES.bytestring;
+    this[TYPES.bytestring].charAt.returnType = TYPES.bytestring;
+    this[TYPES.bytestring].charCodeAt.returnType = TYPES.number;
+    this[TYPES.bytestring].charCodeAt.local = Valtype.i32;
+    this[TYPES.bytestring].charCodeAt.noPointerCache = zeroChecks.charcodeat;
 
-    this[TYPES._bytestring].isWellFormed.local = Valtype.i32;
-    this[TYPES._bytestring].isWellFormed.local2 = Valtype.i32;
-    this[TYPES._bytestring].isWellFormed.returnType = TYPES.boolean;
+    this[TYPES.bytestring].isWellFormed.local = Valtype.i32;
+    this[TYPES.bytestring].isWellFormed.local2 = Valtype.i32;
+    this[TYPES.bytestring].isWellFormed.returnType = TYPES.boolean;
   }
 };

package/compiler/types.js

@@ -0,0 +1,38 @@
+export const TYPES = {
+  number: 0x00,
+  boolean: 0x01,
+  string: 0x02,
+  undefined: 0x03,
+  object: 0x04,
+  function: 0x05,
+  symbol: 0x06,
+  bigint: 0x07
+};
+
+export const TYPE_NAMES = {
+  [TYPES.number]: 'Number',
+  [TYPES.boolean]: 'Boolean',
+  [TYPES.string]: 'String',
+  [TYPES.undefined]: 'undefined',
+  [TYPES.object]: 'Object',
+  [TYPES.function]: 'Function',
+  [TYPES.symbol]: 'Symbol',
+  [TYPES.bigint]: 'BigInt'
+};
+
+export const INTERNAL_TYPE_BASE = 0x10;
+let internalTypeIndex = INTERNAL_TYPE_BASE;
+const registerInternalType = name => {
+  const n = internalTypeIndex++;
+  TYPES[name.toLowerCase()] = n;
+  TYPE_NAMES[n] = name;
+};
+
+// note: when adding a new internal type, please also add a deserializer to wrap.js
+// (it is okay to add a throw todo deserializer for wips)
+
+registerInternalType('Array');
+registerInternalType('RegExp');
+registerInternalType('ByteString');
+registerInternalType('Date');
+registerInternalType('Set');