porffor 0.17.0-bf4206d7b → 0.17.0-c2af76d41

package/compiler/codegen.js

@@ -4,7 +4,7 @@ import { operatorOpcode } from './expression.js';
 import { BuiltinFuncs, BuiltinVars, importedFuncs, NULL, UNDEFINED } from './builtins.js';
 import { PrototypeFuncs } from './prototype.js';
 import { number } from './embedding.js';
-import { TYPES, TYPE_NAMES } from './types.js';
+import { TYPES, TYPE_FLAGS, TYPE_NAMES, typeHasFlag } from './types.js';
 import * as Rhemyn from '../rhemyn/compile.js';
 import parse from './parse.js';
 import { log } from './log.js';
@@ -72,6 +72,9 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
     case 'ExpressionStatement':
       return generateExp(scope, decl);
 
+    case 'SequenceExpression':
+      return generateSequence(scope, decl);
+
     case 'CallExpression':
       return generateCall(scope, decl, global, name, valueUnused);
 
@@ -264,10 +267,12 @@ const internalThrow = (scope, constructor, message, expectsValue = Prefs.alwaysV
     argument: {
       type: 'NewExpression',
       callee: {
+        type: 'Identifier',
         name: constructor
       },
       arguments: [
         {
+          type: 'Literal',
           value: message
         }
       ]
@@ -289,12 +294,13 @@ const generateIdent = (scope, decl) => {
       return wasm.slice();
     }
 
-    if (Object.hasOwn(builtinFuncs, name) || Object.hasOwn(internalConstrs, name)) {
-      // todo: return an actual something
-      return number(1);
-    }
+    // todo: enable this by default in future
+    // if (!Object.hasOwn(funcIndex, name) && Object.hasOwn(builtinFuncs, name)) {
+    //   includeBuiltin(scope, name);
+    //   return number(funcIndex[name] - importedFuncs.length);
+    // }
 
-    if (isExistingProtoFunc(name)) {
+    if (isExistingProtoFunc(name) || Object.hasOwn(internalConstrs, name) || Object.hasOwn(builtinFuncs, name)) {
       // todo: return an actual something
       return number(1);
     }
@@ -613,11 +619,14 @@ const compareStrings = (scope, left, right, bytestrings = false) => {
 };
 
 const truthy = (scope, wasm, type, intIn = false, intOut = false, forceTruthyMode = undefined) => {
-  // if (isIntToFloatOp(wasm[wasm.length - 1])) return [
-  //   ...wasm,
-  //   ...(!intIn && intOut ? [ Opcodes.i32_to_u ] : [])
-  // ];
-  // if (isIntOp(wasm[wasm.length - 1])) return [ ...wasm ];
+  if (isIntToFloatOp(wasm[wasm.length - 1])) return [
+    ...wasm,
+    ...(!intIn && intOut ? [ Opcodes.i32_to_u ] : [])
+  ];
+  if (isIntOp(wasm[wasm.length - 1])) return [
+    ...wasm,
+    ...(intOut ? [] : [ Opcodes.i32_from ]),
+  ];
 
   // todo/perf: use knownType and custom bytecode here instead of typeSwitch
 
@@ -973,6 +982,33 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
 };
 
 const generateBinaryExp = (scope, decl, _global, _name) => {
+  if (decl.operator === 'instanceof') {
+    // very hacky basic instanceof
+    // todo: support dynamic right-hand side
+
+    const out = generate(scope, decl.left);
+    disposeLeftover(out);
+
+    const rightName = decl.right.name;
+    if (!rightName) return todo(scope, 'instanceof dynamic right-hand side is not supported yet', true);
+
+    const checkType = TYPES[rightName.toLowerCase()];
+    if (checkType == null || rightName !== TYPE_NAMES[checkType] || checkType === TYPES.undefined) return todo(scope, 'instanceof right-hand side type unsupported', true);
+
+    if ([TYPES.number, TYPES.boolean, TYPES.string, TYPES.symbol, TYPES.object].includes(checkType)) {
+      out.push(...number(0));
+    } else {
+      out.push(
+        ...getNodeType(scope, decl.left),
+        ...number(checkType, Valtype.i32),
+        [ Opcodes.i32_eq ],
+        Opcodes.i32_from_u
+      );
+    }
+
+    return out;
+  }
+
   const out = performOp(scope, decl.operator, generate(scope, decl.left), generate(scope, decl.right), getNodeType(scope, decl.left), getNodeType(scope, decl.right), _global, _name);
 
   if (valtype !== 'i32' && ['==', '===', '!=', '!==', '>', '>=', '<', '<='].includes(decl.operator)) out.push(Opcodes.i32_from_u);
@@ -990,6 +1026,7 @@ const asmFuncToAsm = (func, scope) => {
         idx = funcIndex[n];
       }
 
+      if (idx == null) throw new Error(`builtin('${n}') failed to find a func (inside ${scope.name})`);
       return idx;
     }
   });
@@ -1028,7 +1065,10 @@ const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes
   funcs.push(func);
   funcIndex[name] = func.index;
 
-  if (typeof wasm === 'function') wasm = asmFuncToAsm(wasm, func);
+  if (typeof wasm === 'function') {
+    if (globalThis.precompile) wasm = [];
+      else wasm = asmFuncToAsm(wasm, func);
+  }
 
   let baseGlobalIdx, i = 0;
   for (const type of globalTypes) {
@@ -1279,7 +1319,7 @@ const getNodeType = (scope, node) => {
     }
 
     if (node.type === 'BinaryExpression') {
-      if (['==', '===', '!=', '!==', '>', '>=', '<', '<='].includes(node.operator)) return TYPES.boolean;
+      if (['==', '===', '!=', '!==', '>', '>=', '<', '<=', 'instanceof'].includes(node.operator)) return TYPES.boolean;
       if (node.operator !== '+') return TYPES.number;
 
       const knownLeft = knownType(scope, getNodeType(scope, node.left));
@@ -1312,7 +1352,7 @@ const getNodeType = (scope, node) => {
       const objectKnownType = knownType(scope, getNodeType(scope, node.object));
       if (objectKnownType != null) {
         if (name === 'length') {
-          if ([ TYPES.string, TYPES.bytestring, TYPES.array ].includes(objectKnownType)) return TYPES.number;
+          if (typeHasFlag(objectKnownType, TYPE_FLAGS.length)) return TYPES.number;
             else return TYPES.undefined;
         }
 
@@ -1384,9 +1424,9 @@ const countLeftover = wasm => {
 
     if (depth === 0)
       if ([Opcodes.throw, Opcodes.drop, Opcodes.local_set, Opcodes.global_set].includes(inst[0])) count--;
-        else if ([null, Opcodes.i32_eqz, Opcodes.i64_eqz, Opcodes.f64_ceil, Opcodes.f64_floor, Opcodes.f64_trunc, Opcodes.f64_nearest, Opcodes.f64_sqrt, Opcodes.local_tee, Opcodes.i32_wrap_i64, Opcodes.i64_extend_i32_s, Opcodes.i64_extend_i32_u, Opcodes.f32_demote_f64, Opcodes.f64_promote_f32, Opcodes.f64_convert_i32_s, Opcodes.f64_convert_i32_u, Opcodes.i32_clz, Opcodes.i32_ctz, Opcodes.i32_popcnt, Opcodes.f64_neg, Opcodes.end, Opcodes.i32_trunc_sat_f64_s[0], Opcodes.i32x4_extract_lane, Opcodes.i16x8_extract_lane, Opcodes.i32_load, Opcodes.i64_load, Opcodes.f64_load, Opcodes.v128_load, Opcodes.i32_load16_u, Opcodes.i32_load16_s, Opcodes.i32_load8_u, Opcodes.i32_load8_s, Opcodes.memory_grow].includes(inst[0]) && (inst[0] !== 0xfc || inst[1] < 0x04)) {}
+        else if ([null, Opcodes.i32_eqz, Opcodes.i64_eqz, Opcodes.f64_ceil, Opcodes.f64_floor, Opcodes.f64_trunc, Opcodes.f64_nearest, Opcodes.f64_sqrt, Opcodes.local_tee, Opcodes.i32_wrap_i64, Opcodes.i64_extend_i32_s, Opcodes.i64_extend_i32_u, Opcodes.f32_demote_f64, Opcodes.f64_promote_f32, Opcodes.f64_convert_i32_s, Opcodes.f64_convert_i32_u, Opcodes.i32_clz, Opcodes.i32_ctz, Opcodes.i32_popcnt, Opcodes.f64_neg, Opcodes.end, Opcodes.i32_trunc_sat_f64_s[0], Opcodes.i32x4_extract_lane, Opcodes.i16x8_extract_lane, Opcodes.i32_load, Opcodes.i64_load, Opcodes.f64_load, Opcodes.f32_load, Opcodes.v128_load, Opcodes.i32_load16_u, Opcodes.i32_load16_s, Opcodes.i32_load8_u, Opcodes.i32_load8_s, Opcodes.memory_grow].includes(inst[0]) && (inst[0] !== 0xfc || inst[1] < 0x04)) {}
         else if ([Opcodes.local_get, Opcodes.global_get, Opcodes.f64_const, Opcodes.i32_const, Opcodes.i64_const, Opcodes.v128_const, Opcodes.memory_size].includes(inst[0])) count++;
-        else if ([Opcodes.i32_store, Opcodes.i64_store, Opcodes.f64_store, Opcodes.i32_store16, Opcodes.i32_store8].includes(inst[0])) count -= 2;
+        else if ([Opcodes.i32_store, Opcodes.i64_store, Opcodes.f64_store, Opcodes.f32_store, Opcodes.i32_store16, Opcodes.i32_store8].includes(inst[0])) count -= 2;
         else if (inst[0] === Opcodes.memory_copy[0] && (inst[1] === Opcodes.memory_copy[1] || inst[1] === Opcodes.memory_init[1])) count -= 3;
         else if (inst[0] === Opcodes.return) count = 0;
         else if (inst[0] === Opcodes.call) {
@@ -1424,6 +1464,18 @@ const generateExp = (scope, decl) => {
   return out;
 };
 
+const generateSequence = (scope, decl) => {
+  let out = [];
+
+  const exprs = decl.expressions;
+  for (let i = 0; i < exprs.length; i++) {
+    if (i > 0) disposeLeftover(out);
+    out.push(...generate(scope, exprs[i]));
+  }
+
+  return out;
+};
+
 const CTArrayUtil = {
   getLengthI32: pointer => [
     ...number(0, Valtype.i32),
@@ -1542,9 +1594,9 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
   if (!name && decl.callee.type === 'MemberExpression') {
     // megahack for /regex/.func()
     const funcName = decl.callee.property.name;
-    if (decl.callee.object.regex && Object.hasOwn(Rhemyn, funcName)) {
+    if (decl.callee.object.regex && ['test'].includes(funcName)) {
       const regex = decl.callee.object.regex.pattern;
-      const rhemynName = `regex_${funcName}_${regex}`;
+      const rhemynName = `regex_${funcName}_${sanitize(regex)}`;
 
       if (!funcIndex[rhemynName]) {
         const func = Rhemyn[funcName](regex, currentFuncIndex++, rhemynName);
@@ -1565,7 +1617,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
         [ Opcodes.call, idx ],
         Opcodes.i32_from_u,
 
-        ...setLastType(scope, TYPES.boolean)
+        ...setLastType(scope, Rhemyn.types[funcName])
       ];
     }
 
@@ -1574,24 +1626,44 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     target = decl.callee.object;
   }
 
-  // if (protoName && baseType === TYPES.string && Rhemyn[protoName]) {
-  //   const func = Rhemyn[protoName](decl.arguments[0].regex.pattern, currentFuncIndex++);
+  if (protoName) {
+    if (['search'].includes(protoName)) {
+      const regex = decl.arguments[0]?.regex?.pattern;
+      if (!regex) return [
+        // no/bad regex arg, return -1/0 for now
+        ...generate(scope, target),
+        [ Opcodes.drop ],
 
-  //   funcIndex[func.name] = func.index;
-  //   funcs.push(func);
+        ...number(Rhemyn.types[protoName] === TYPES.number ? -1 : 0),
+        ...setLastType(scope, Rhemyn.types[protoName])
+      ];
 
-  //   return [
-  //     generate(scope, decl.callee.object)
+      const rhemynName = `regex_${protoName}_${sanitize(regex)}`;
 
-  //     // call regex func
-  //     [ Opcodes.call, func.index ],
-  //     Opcodes.i32_from_u
-  //   ];
-  // }
+      if (!funcIndex[rhemynName]) {
+        const func = Rhemyn[protoName](regex, currentFuncIndex++, rhemynName);
+        func.internal = true;
 
-  if (protoName) {
-    const protoBC = {};
+        funcIndex[func.name] = func.index;
+        funcs.push(func);
+      }
+
+      const idx = funcIndex[rhemynName];
+      return [
+        // make string arg
+        ...generate(scope, target),
+        Opcodes.i32_to_u,
+        ...getNodeType(scope, target),
+
+        // call regex func
+        [ Opcodes.call, idx ],
+        Opcodes.i32_from,
 
+        ...setLastType(scope, Rhemyn.types[protoName])
+      ];
+    }
+
+    const protoBC = {};
     const builtinProtoCands = Object.keys(builtinFuncs).filter(x => x.startsWith('__') && x.endsWith('_prototype_' + protoName));
 
     if (!decl._protoInternalCall && builtinProtoCands.length > 0) {
@@ -2005,6 +2077,16 @@ const DEFAULT_VALUE = {
   name: 'undefined'
 };
 
+const codeToSanitizedStr = code => {
+  let out = '';
+  while (code > 0) {
+    out += String.fromCharCode(97 + code % 26);
+    code -= 26;
+  }
+  return out;
+};
+const sanitize = str => str.replace(/[^0-9a-zA-Z_]/g, _ => codeToSanitizedStr(_.charCodeAt(0)));
+
 const unhackName = name => {
   if (name.startsWith('__')) return name.slice(2).replaceAll('_', '.');
   return name;
@@ -2012,7 +2094,7 @@ const unhackName = name => {
 
 const knownType = (scope, type) => {
   if (type.length === 1 && type[0][0] === Opcodes.i32_const) {
-    return type[0][1];
+    return read_signedLEB128(type[0].slice(1));
   }
 
   if (typedInput && type.length === 1 && type[0][0] === Opcodes.local_get) {
@@ -2299,11 +2381,6 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
   const { type, name } = decl.left;
   const [ local, isGlobal ] = lookupName(scope, name);
 
-  if (type === 'ObjectPattern') {
-    // hack: ignore object parts of `var a = {} = 2`
-    return generate(scope, decl.right);
-  }
-
   if (isFuncType(decl.right.type)) {
     // hack for a = function () { ... }
     decl.right.id = { name };
@@ -2376,10 +2453,160 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
             [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 + ValtypeSize[valtype] ]
           ], getNodeType(scope, decl.right), false, name, true)),
           [ Opcodes.local_tee, newValueTmp ],
-
           [ Opcodes.store, 0, ValtypeSize.i32 ]
         ],
 
+        ...wrapBC({
+          [TYPES.uint8array]: [
+            [ Opcodes.i32_add ],
+            ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
+
+            ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
+              [ Opcodes.local_get, pointerTmp ],
+              [ Opcodes.i32_load8_u, 0, 4 ],
+              Opcodes.i32_from_u
+            ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
+            [ Opcodes.local_tee, newValueTmp ],
+
+            Opcodes.i32_to_u,
+            [ Opcodes.i32_store8, 0, 4 ]
+          ],
+          [TYPES.uint8clampedarray]: [
+            [ Opcodes.i32_add ],
+            ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
+
+            ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
+              [ Opcodes.local_get, pointerTmp ],
+              [ Opcodes.i32_load8_u, 0, 4 ],
+              Opcodes.i32_from_u
+            ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
+            [ Opcodes.local_tee, newValueTmp ],
+
+            ...number(0),
+            [ Opcodes.f64_max ],
+            ...number(255),
+            [ Opcodes.f64_min ],
+            Opcodes.i32_to_u,
+            [ Opcodes.i32_store8, 0, 4 ]
+          ],
+          [TYPES.int8array]: [
+            [ Opcodes.i32_add ],
+            ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
+
+            ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
+              [ Opcodes.local_get, pointerTmp ],
+              [ Opcodes.i32_load8_s, 0, 4 ],
+              Opcodes.i32_from
+            ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
+            [ Opcodes.local_tee, newValueTmp ],
+
+            Opcodes.i32_to,
+            [ Opcodes.i32_store8, 0, 4 ]
+          ],
+          [TYPES.uint16array]: [
+            ...number(2, Valtype.i32),
+            [ Opcodes.i32_mul ],
+            [ Opcodes.i32_add ],
+            ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
+
+            ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
+              [ Opcodes.local_get, pointerTmp ],
+              [ Opcodes.i32_load16_u, 0, 4 ],
+              Opcodes.i32_from_u
+            ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
+            [ Opcodes.local_tee, newValueTmp ],
+
+            Opcodes.i32_to_u,
+            [ Opcodes.i32_store16, 0, 4 ]
+          ],
+          [TYPES.int16array]: [
+            ...number(2, Valtype.i32),
+            [ Opcodes.i32_mul ],
+            [ Opcodes.i32_add ],
+            ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
+
+            ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
+              [ Opcodes.local_get, pointerTmp ],
+              [ Opcodes.i32_load16_s, 0, 4 ],
+              Opcodes.i32_from
+            ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
+            [ Opcodes.local_tee, newValueTmp ],
+
+            Opcodes.i32_to,
+            [ Opcodes.i32_store16, 0, 4 ]
+          ],
+          [TYPES.uint32array]: [
+            ...number(4, Valtype.i32),
+            [ Opcodes.i32_mul ],
+            [ Opcodes.i32_add ],
+            ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
+
+            ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
+              [ Opcodes.local_get, pointerTmp ],
+              [ Opcodes.i32_load, 0, 4 ],
+              Opcodes.i32_from_u
+            ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
+            [ Opcodes.local_tee, newValueTmp ],
+
+            Opcodes.i32_to_u,
+            [ Opcodes.i32_store, 0, 4 ]
+          ],
+          [TYPES.int32array]: [
+            ...number(4, Valtype.i32),
+            [ Opcodes.i32_mul ],
+            [ Opcodes.i32_add ],
+            ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
+
+            ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
+              [ Opcodes.local_get, pointerTmp ],
+              [ Opcodes.i32_load, 0, 4 ],
+              Opcodes.i32_from
+            ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
+            [ Opcodes.local_tee, newValueTmp ],
+
+            Opcodes.i32_to,
+            [ Opcodes.i32_store, 0, 4 ]
+          ],
+          [TYPES.float32array]: [
+            ...number(4, Valtype.i32),
+            [ Opcodes.i32_mul ],
+            [ Opcodes.i32_add ],
+            ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
+
+            ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
+              [ Opcodes.local_get, pointerTmp ],
+              [ Opcodes.f32_load, 0, 4 ],
+              [ Opcodes.f64_promote_f32 ]
+            ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
+            [ Opcodes.local_tee, newValueTmp ],
+
+            [ Opcodes.f32_demote_f64 ],
+            [ Opcodes.f32_store, 0, 4 ]
+          ],
+          [TYPES.float64array]: [
+            ...number(8, Valtype.i32),
+            [ Opcodes.i32_mul ],
+            [ Opcodes.i32_add ],
+            ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
+
+            ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
+              [ Opcodes.local_get, pointerTmp ],
+              [ Opcodes.f64_load, 0, 4 ]
+            ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
+            [ Opcodes.local_tee, newValueTmp ],
+
+            [ Opcodes.f64_store, 0, 4 ]
+          ],
+        }, {
+          prelude: [
+            ...generate(scope, decl.left.object),
+            Opcodes.i32_to_u,
+            ...generate(scope, decl.left.property),
+            Opcodes.i32_to_u,
+          ],
+          postlude: setLastType(scope, TYPES.number)
+        }),
+
         default: internalThrow(scope, 'TypeError', `Cannot assign member with non-array`)
       }, Blocktype.void),
 
@@ -2763,7 +2990,9 @@ const generateForOf = (scope, decl) => {
   // // todo: we should only do this for strings but we don't know at compile-time :(
   // hack: this is naughty and will break things!
   let newOut = number(0, Valtype.i32), newPointer = number(0, Valtype.i32);
-  if (pages.hasAnyString) {
+
+  const known = knownType(scope, getNodeType(scope, decl.right));
+  if ((known === TYPES.string || known === TYPES.bytestring) || (pages.hasAnyString && known == null)) {
     // todo: we use i16 even for bytestrings which should not make a bad thing happen, just be confusing for debugging?
     0, [ newOut, newPointer ] = makeArray(scope, {
       rawElements: new Array(0)
@@ -2811,6 +3040,7 @@ const generateForOf = (scope, decl) => {
       [ Opcodes.end ],
       [ Opcodes.end ]
     ],
+
     [TYPES.string]: [
       ...setType(scope, leftName, TYPES.string),
 
@@ -2919,6 +3149,7 @@ const generateForOf = (scope, decl) => {
       [ Opcodes.end ],
       [ Opcodes.end ]
     ],
+
     [TYPES.set]: [
       [ Opcodes.loop, Blocktype.void ],
 
@@ -2957,6 +3188,106 @@ const generateForOf = (scope, decl) => {
       [ Opcodes.end ],
       [ Opcodes.end ]
     ],
+
+    ...wrapBC({
+      [TYPES.uint8array]: [
+        [ Opcodes.i32_add ],
+
+        [ Opcodes.i32_load8_u, 0, 4 ],
+        Opcodes.i32_from_u
+      ],
+      [TYPES.uint8clampedarray]: [
+        [ Opcodes.i32_add ],
+
+        [ Opcodes.i32_load8_u, 0, 4 ],
+        Opcodes.i32_from_u
+      ],
+      [TYPES.int8array]: [
+        [ Opcodes.i32_add ],
+
+        [ Opcodes.i32_load8_s, 0, 4 ],
+        Opcodes.i32_from
+      ],
+      [TYPES.uint16array]: [
+        ...number(2, Valtype.i32),
+        [ Opcodes.i32_mul ],
+        [ Opcodes.i32_add ],
+
+        [ Opcodes.i32_load16_u, 0, 4 ],
+        Opcodes.i32_from_u
+      ],
+      [TYPES.int16array]: [
+        ...number(2, Valtype.i32),
+        [ Opcodes.i32_mul ],
+        [ Opcodes.i32_add ],
+
+        [ Opcodes.i32_load16_s, 0, 4 ],
+        Opcodes.i32_from
+      ],
+      [TYPES.uint32array]: [
+        ...number(4, Valtype.i32),
+        [ Opcodes.i32_mul ],
+        [ Opcodes.i32_add ],
+
+        [ Opcodes.i32_load, 0, 4 ],
+        Opcodes.i32_from_u
+      ],
+      [TYPES.int32array]: [
+        ...number(4, Valtype.i32),
+        [ Opcodes.i32_mul ],
+        [ Opcodes.i32_add ],
+
+        [ Opcodes.i32_load, 0, 4 ],
+        Opcodes.i32_from
+      ],
+      [TYPES.float32array]: [
+        ...number(4, Valtype.i32),
+        [ Opcodes.i32_mul ],
+        [ Opcodes.i32_add ],
+
+        [ Opcodes.f32_load, 0, 4 ],
+        [ Opcodes.f64_promote_f32 ]
+      ],
+      [TYPES.float64array]: [
+        ...number(8, Valtype.i32),
+        [ Opcodes.i32_mul ],
+        [ Opcodes.i32_add ],
+
+        [ Opcodes.f64_load, 0, 4 ]
+      ],
+    }, {
+      prelude: [
+        ...setType(scope, leftName, TYPES.number),
+
+        [ Opcodes.loop, Blocktype.void ],
+
+        [ Opcodes.local_get, pointer ],
+        [ Opcodes.local_get, counter ]
+      ],
+      postlude: [
+        [ isGlobal ? Opcodes.global_set : Opcodes.local_set, local.idx ],
+
+        [ Opcodes.block, Blocktype.void ],
+        [ Opcodes.block, Blocktype.void ],
+        ...generate(scope, decl.body),
+        [ Opcodes.end ],
+
+        // increment counter by 1
+        [ Opcodes.local_get, counter ],
+        ...number(1, Valtype.i32),
+        [ Opcodes.i32_add ],
+        [ Opcodes.local_tee, counter ],
+
+        // loop if counter != length
+        [ Opcodes.local_get, length ],
+        [ Opcodes.i32_ne ],
+        [ Opcodes.br_if, 1 ],
+
+        [ Opcodes.end ],
+        [ Opcodes.end ]
+      ]
+    }),
+
     default: internalThrow(scope, 'TypeError', `Tried for..of on non-iterable type`)
   }, Blocktype.void));
 
@@ -3029,32 +3360,102 @@ const generateLabel = (scope, decl) => {
 const generateThrow = (scope, decl) => {
   scope.throws = true;
 
-  let message = decl.argument.value, constructor = null;
+  const exceptionMode = Prefs.exceptionMode ?? 'lut';
+  if (exceptionMode === 'lut') {
+    let message = decl.argument.value, constructor = null;
+
+    // support `throw (new)? Error(...)`
+    if (!message && (decl.argument.type === 'NewExpression' || decl.argument.type === 'CallExpression')) {
+      constructor = decl.argument.callee.name;
+      message = decl.argument.arguments[0]?.value ?? '';
+    }
+
+    if (tags.length === 0) tags.push({
+      params: [ Valtype.i32 ],
+      results: [],
+      idx: tags.length
+    });
+
+    let exceptId = exceptions.findIndex(x => x.constructor === constructor && x.message === message);
+    if (exceptId === -1) exceptId = exceptions.push({ constructor, message }) - 1;
+
+    scope.exceptions ??= [];
+    scope.exceptions.push(exceptId);
+
+    return [
+      ...number(exceptId, Valtype.i32),
+      [ Opcodes.throw, tags[0].idx ]
+    ];
+  }
+
+  if (exceptionMode === 'stack') {
+    if (tags.length === 0) tags.push({
+      params: [ valtypeBinary, Valtype.i32 ],
+      results: [],
+      idx: tags.length
+    });
 
-  // hack: throw new X("...") -> throw "..."
-  if (!message && (decl.argument.type === 'NewExpression' || decl.argument.type === 'CallExpression')) {
-    constructor = decl.argument.callee.name;
-    message = decl.argument.arguments[0]?.value ?? '';
+    return [
+      ...generate(scope, decl.argument),
+      ...getNodeType(scope, decl.argument),
+      [ Opcodes.throw, tags[0].idx ]
+    ];
   }
 
-  if (tags.length === 0) tags.push({
-    params: [ Valtype.i32 ],
-    results: [],
-    idx: tags.length
-  });
+  if (exceptionMode === 'stackest') {
+    let message = decl.argument, constructor = null;
 
-  let exceptId = exceptions.push({ constructor, message }) - 1;
-  let tagIdx = tags[0].idx;
+    // support `throw (new)? Error(...)`
+    if (message.type === 'NewExpression' || message.type === 'CallExpression') {
+      constructor = decl.argument.callee;
+      message = decl.argument.arguments[0];
+    }
 
-  scope.exceptions ??= [];
-  scope.exceptions.push(exceptId);
+    message ??= DEFAULT_VALUE;
 
-  // todo: write a description of how this works lol
+    if (tags.length === 0) tags.push({
+      params: [ valtypeBinary, valtypeBinary, Valtype.i32 ],
+      results: [],
+      idx: tags.length
+    });
 
-  return [
-    [ Opcodes.i32_const, signedLEB128(exceptId) ],
-    [ Opcodes.throw, tagIdx ]
-  ];
+    return [
+      ...(constructor == null ? number(-1) : generate(scope, constructor)),
+      ...generate(scope, message),
+      ...getNodeType(scope, message),
+      [ Opcodes.throw, tags[0].idx ]
+    ];
+  }
+
+  if (exceptionMode === 'partial') {
+    let message = decl.argument, constructor = null;
+
+    // support `throw (new)? Error(...)`
+    if (message.type === 'NewExpression' || message.type === 'CallExpression') {
+      constructor = decl.argument.callee.name;
+      message = decl.argument.arguments[0];
+    }
+
+    message ??= DEFAULT_VALUE;
+
+    if (tags.length === 0) tags.push({
+      params: [ Valtype.i32, valtypeBinary, Valtype.i32 ],
+      results: [],
+      idx: tags.length
+    });
+
+    let exceptId = exceptions.push({ constructor }) - 1;
+
+    scope.exceptions ??= [];
+    scope.exceptions.push(exceptId);
+
+    return [
+      ...number(exceptId, Valtype.i32),
+      ...generate(scope, message),
+      ...getNodeType(scope, message),
+      [ Opcodes.throw, tags[0].idx ]
+    ];
+  }
 };
 
 const generateTry = (scope, decl) => {
@@ -3407,6 +3808,19 @@ const withType = (scope, wasm, type) => [
   ...setLastType(scope, type)
 ];
 
+const wrapBC = (bc, { prelude = [], postlude = [] } = {}) => {
+  const out = {};
+  for (const x in bc) {
+    out[x] = [
+      ...prelude,
+      ...bc[x],
+      ...postlude
+    ];
+  }
+
+  return out;
+};
+
 const generateMember = (scope, decl, _global, _name) => {
   const name = decl.object.name;
 
@@ -3460,7 +3874,7 @@ const generateMember = (scope, decl, _global, _name) => {
     const type = getNodeType(scope, decl.object);
     const known = knownType(scope, type);
     if (known != null) {
-      if ([ TYPES.string, TYPES.bytestring, TYPES.array ].includes(known)) return [
+      if (typeHasFlag(known, TYPE_FLAGS.length)) return [
         ...generate(scope, decl.object),
         Opcodes.i32_to_u,
 
@@ -3472,7 +3886,9 @@ const generateMember = (scope, decl, _global, _name) => {
     }
 
     return [
-      ...typeIsOneOf(getNodeType(scope, decl.object), [ TYPES.string, TYPES.bytestring, TYPES.array ]),
+      ...getNodeType(scope, decl.object),
+      ...number(TYPE_FLAGS.length, Valtype.i32),
+      [ Opcodes.i32_and ],
       [ Opcodes.if, valtypeBinary ],
         ...generate(scope, decl.object),
         Opcodes.i32_to_u,
@@ -3489,7 +3905,7 @@ const generateMember = (scope, decl, _global, _name) => {
   }
 
   // todo: generate this array procedurally during builtinFuncs creation
-  if (['size', 'description'].includes(decl.property.name)) {
+  if (['size', 'description', 'byteLength'].includes(decl.property.name)) {
     const bc = {};
     const cands = Object.keys(builtinFuncs).filter(x => x.startsWith('__') && x.endsWith('_prototype_' + decl.property.name + '$get'));
 
@@ -3521,7 +3937,9 @@ const generateMember = (scope, decl, _global, _name) => {
   // // todo: we should only do this for strings but we don't know at compile-time :(
   // hack: this is naughty and will break things!
   let newOut = number(0, Valtype.i32), newPointer = number(0, Valtype.i32);
-  if (pages.hasAnyString && knownType(scope, getNodeType(scope, decl.object)) !== TYPES.array) {
+
+  const known = knownType(scope, getNodeType(scope, decl.object));
+  if ((known === TYPES.string || known === TYPES.bytestring) || (pages.hasAnyString && known == null)) {
     // todo: we use i16 even for bytestrings which should not make a bad thing happen, just be confusing for debugging?
     0, [ newOut, newPointer ] = makeArray(scope, {
       rawElements: new Array(0)
@@ -3595,6 +4013,82 @@ const generateMember = (scope, decl, _global, _name) => {
       ...setLastType(scope, TYPES.bytestring)
     ],
 
+    ...wrapBC({
+      [TYPES.uint8array]: [
+        [ Opcodes.i32_add ],
+
+        [ Opcodes.i32_load8_u, 0, 4 ],
+        Opcodes.i32_from_u
+      ],
+      [TYPES.uint8clampedarray]: [
+        [ Opcodes.i32_add ],
+
+        [ Opcodes.i32_load8_u, 0, 4 ],
+        Opcodes.i32_from_u
+      ],
+      [TYPES.int8array]: [
+        [ Opcodes.i32_add ],
+
+        [ Opcodes.i32_load8_s, 0, 4 ],
+        Opcodes.i32_from
+      ],
+      [TYPES.uint16array]: [
+        ...number(2, Valtype.i32),
+        [ Opcodes.i32_mul ],
+        [ Opcodes.i32_add ],
+
+        [ Opcodes.i32_load16_u, 0, 4 ],
+        Opcodes.i32_from_u
+      ],
+      [TYPES.int16array]: [
+        ...number(2, Valtype.i32),
+        [ Opcodes.i32_mul ],
+        [ Opcodes.i32_add ],
+
+        [ Opcodes.i32_load16_s, 0, 4 ],
+        Opcodes.i32_from
+      ],
+      [TYPES.uint32array]: [
+        ...number(4, Valtype.i32),
+        [ Opcodes.i32_mul ],
+        [ Opcodes.i32_add ],
+
+        [ Opcodes.i32_load, 0, 4 ],
+        Opcodes.i32_from_u
+      ],
+      [TYPES.int32array]: [
+        ...number(4, Valtype.i32),
+        [ Opcodes.i32_mul ],
+        [ Opcodes.i32_add ],
+
+        [ Opcodes.i32_load, 0, 4 ],
+        Opcodes.i32_from
+      ],
+      [TYPES.float32array]: [
+        ...number(4, Valtype.i32),
+        [ Opcodes.i32_mul ],
+        [ Opcodes.i32_add ],
+
+        [ Opcodes.f32_load, 0, 4 ],
+        [ Opcodes.f64_promote_f32 ]
+      ],
+      [TYPES.float64array]: [
+        ...number(8, Valtype.i32),
+        [ Opcodes.i32_mul ],
+        [ Opcodes.i32_add ],
+
+        [ Opcodes.f64_load, 0, 4 ]
+      ],
+    }, {
+      prelude: [
+        ...object,
+        Opcodes.i32_to_u,
+        ...property,
+        Opcodes.i32_to_u
+      ],
+      postlude: setLastType(scope, TYPES.number)
+    }),
+
     default: internalThrow(scope, 'TypeError', 'Member expression is not supported for non-string non-array yet', true)
   });
 };
@@ -3617,7 +4111,7 @@ const objectHack = node => {
       if (!objectName) objectName = objectHack(node.object)?.name?.slice?.(2);
 
       // if .name or .length, give up (hack within a hack!)
-      if (['name', 'length', 'size', 'description'].includes(node.property.name)) {
+      if (['name', 'length', 'size', 'description', 'byteLength'].includes(node.property.name)) {
         node.object = objectHack(node.object);
         return;
       }
@@ -3772,7 +4266,7 @@ const internalConstrs = {
 
       // todo: check in wasm instead of here
       const literalValue = arg.value ?? 0;
-      if (literalValue < 0 || !Number.isFinite(literalValue) || literalValue > 4294967295) return internalThrow(scope, 'RangeThrow', 'Invalid array length', true);
+      if (literalValue < 0 || !Number.isFinite(literalValue) || literalValue > 4294967295) return internalThrow(scope, 'RangeError', 'Invalid array length', true);
 
       return [
         ...out,