porffor 0.17.0-bf4206d7b → 0.17.0-c2dd8f88f

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);
 
@@ -120,6 +123,9 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
     case 'EmptyStatement':
       return generateEmpty(scope, decl);
 
+    case 'MetaProperty':
+      return generateMeta(scope, decl);
+
     case 'ConditionalExpression':
       return generateConditional(scope, decl);
 
@@ -264,10 +270,12 @@ const internalThrow = (scope, constructor, message, expectsValue = Prefs.alwaysV
     argument: {
       type: 'NewExpression',
       callee: {
+        type: 'Identifier',
         name: constructor
       },
       arguments: [
         {
+          type: 'Literal',
           value: message
         }
       ]
@@ -289,12 +297,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 +622,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 +985,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,12 +1029,13 @@ 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;
     }
   });
 };
 
-const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes = [], globalInits = [], returns, returnType, localNames = [], globalNames = [], data: _data = [], table = false }) => {
+const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes = [], globalInits = [], returns, returnType, localNames = [], globalNames = [], data: _data = [], table = false, constr = false }) => {
   const existing = funcs.find(x => x.name === name);
   if (existing) return existing;
 
@@ -1022,13 +1062,17 @@ const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes
     returnType,
     internal: true,
     index: currentFuncIndex++,
-    table
+    table,
+    constr
   };
 
   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) {
@@ -1049,15 +1093,35 @@ const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes
 
   if (table) {
     for (const inst of wasm) {
-      if (inst[0] === Opcodes.i32_load16_u && inst.at(-1) === 'read_argc') {
+      if (inst.at(-1) === 'read func lut') {
         inst.splice(2, 99);
-        inst.push(...unsignedLEB128(allocPage({}, 'func argc lut') * pageSize));
+        inst.push(...unsignedLEB128(allocPage({}, 'func lut') * pageSize));
       }
     }
 
     funcs.table = true;
   }
 
+  if (constr) {
+    func.params = [...func.params];
+    func.params.unshift(Valtype.i32);
+
+    // move all locals +1 idx (sigh)
+    func.localInd++;
+    const locals = func.locals;
+    for (const x in locals) {
+      locals[x].idx++;
+    }
+
+    locals['#newtarget'] = { idx: 0, type: Valtype.i32 };
+
+    for (const inst of wasm) {
+      if (inst[0] === Opcodes.local_get || inst[0] === Opcodes.local_set || inst[0] === Opcodes.local_tee) {
+        inst[1]++;
+      }
+    }
+  }
+
   func.wasm = wasm;
 
   return func;
@@ -1184,20 +1248,7 @@ const getNodeType = (scope, node) => {
         return TYPES.number;
       }
 
-      if (node.type === 'NewExpression' && builtinFuncs[name + '$constructor']) {
-        if (builtinFuncs[name + '$constructor'].typedReturns) {
-          if (scope.locals['#last_type']) return getLastType(scope);
-
-          // presume
-          // todo: warn here?
-          return TYPES.number;
-        }
-
-        return builtinFuncs[name + '$constructor'].returnType ?? TYPES.number;
-      }
-
       const func = funcs.find(x => x.name === name);
-
       if (func) {
         if (func.returnType != null) return func.returnType;
       }
@@ -1279,7 +1330,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 +1363,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 +1435,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 +1475,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),
@@ -1483,7 +1546,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     name = func.name;
   }
 
-  if (name === 'eval' && decl.arguments[0]?.type === 'Literal') {
+  if (!decl._new && name === 'eval' && decl.arguments[0]?.type === 'Literal') {
     // literal eval hack
     const code = decl.arguments[0]?.value ?? '';
 
@@ -1526,7 +1589,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
 
   let protoName, target;
   // ident.func()
-  if (name && name.startsWith('__')) {
+  if (!decl._new && name && name.startsWith('__')) {
     const spl = name.slice(2).split('_');
 
     protoName = spl[spl.length - 1];
@@ -1539,12 +1602,12 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
   }
 
   // literal.func()
-  if (!name && decl.callee.type === 'MemberExpression') {
+  if (!decl._new && !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 +1628,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,27 +1637,56 @@ 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++);
+  let out = [];
+  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) {
+      out.push(
+        ...generate(scope, target),
+        [ Opcodes.local_set, localTmp(scope, '#proto_target') ],
+
+        ...getNodeType(scope, target),
+        [ Opcodes.local_set, localTmp(scope, '#proto_target#type', Valtype.i32) ],
+      );
+
       for (const x of builtinProtoCands) {
         const type = TYPES[x.split('_prototype_')[0].slice(2).toLowerCase()];
         if (type == null) continue;
@@ -1604,7 +1696,14 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
             type: 'Identifier',
             name: x
           },
-          arguments: [ target, ...decl.arguments ],
+          arguments: [
+            {
+              type: 'Identifier',
+              name: '#proto_target'
+            },
+
+            ...decl.arguments
+          ],
           _protoInternalCall: true
         });
       }
@@ -1698,29 +1797,37 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     }
 
     if (Object.keys(protoBC).length > 0) {
-      return typeSwitch(scope, getNodeType(scope, target), {
-        ...protoBC,
+      return [
+        ...out,
+
+        ...typeSwitch(scope, builtinProtoCands.length > 0 ? [ [ Opcodes.local_get, localTmp(scope, '#proto_target#type', Valtype.i32) ] ] : getNodeType(scope, target), {
+          ...protoBC,
 
-        // TODO: error better
-        default: internalThrow(scope, 'TypeError', `'${protoName}' proto func tried to be called on a type without an impl`)
-      }, valtypeBinary);
+          // TODO: error better
+          default: internalThrow(scope, 'TypeError', `'${protoName}' proto func tried to be called on a type without an impl`)
+        }, valtypeBinary)
+      ];
     }
   }
 
-  // TODO: only allows callee as literal
-  if (!name) return todo(scope, `only literal callees (got ${decl.callee.type})`);
+  // TODO: only allows callee as identifier
+  if (!name) return todo(scope, `only identifier callees (got ${decl.callee.type})`);
 
   let idx = funcIndex[name] ?? importedFuncs[name];
   if (idx === undefined && builtinFuncs[name]) {
     if (builtinFuncs[name].floatOnly && valtype !== 'f64') throw new Error(`Cannot use built-in ${unhackName(name)} with integer valtype`);
+    if (decl._new && !builtinFuncs[name].constr) return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a constructor`, true);
 
     includeBuiltin(scope, name);
     idx = funcIndex[name];
   }
 
-  if (idx === undefined && internalConstrs[name]) return internalConstrs[name].generate(scope, decl, _global, _name);
+  if (idx === undefined && internalConstrs[name]) {
+    if (decl._new && internalConstrs[name].notConstr) return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a constructor`, true);
+    return internalConstrs[name].generate(scope, decl, _global, _name);
+  }
 
-  if (idx === undefined && name.startsWith('__Porffor_wasm_')) {
+  if (idx === undefined && !decl._new && name.startsWith('__Porffor_wasm_')) {
     const wasmOps = {
       // pointer, align, offset
       i32_load: { imms: 2, args: [ true ], returns: 1 },
@@ -1775,7 +1882,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
 
       const indirectMode = Prefs.indirectCallMode ?? 'vararg';
       // options: vararg, strict
-      // - strict: simpler, smaller size usage, no func argc lut needed.
+      // - strict: simpler, smaller size usage, no func lut needed.
       //   ONLY works when arg count of call == arg count of function being called
       // - vararg: large size usage, cursed.
       //   works when arg count of call != arg count of function being called*
@@ -1785,8 +1892,6 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
       scope.table = true;
 
       let args = decl.arguments;
-      let out = [];
-
       let locals = [];
 
       if (indirectMode === 'vararg') {
@@ -1850,24 +1955,67 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
       // *for argc 0-3, in future (todo:) the max number should be
       // dynamically changed to the max argc of any func in the js file.
 
-      const funcLocal = localTmp(scope, `#indirect_func`, Valtype.i32);
+      const funcLocal = localTmp(scope, '#indirect_func', Valtype.i32);
+      const flags = localTmp(scope, '#indirect_flags', Valtype.i32);
 
       const gen = argc => {
-        const out = [];
+        const argsOut = [];
         for (let i = 0; i < argc; i++) {
-          out.push(
+          argsOut.push(
             [ Opcodes.local_get, locals[i][0] ],
             [ Opcodes.local_get, locals[i][1] ]
           );
         }
 
-        out.push(
-          [ Opcodes.local_get, funcLocal ],
-          [ Opcodes.call_indirect, argc, 0 ],
-          ...setLastType(scope)
-        )
+        const checkFlag = (flag, pass, fail) => [
+          [ Opcodes.local_get, flags ],
+          ...number(flag, Valtype.i32),
+          [ Opcodes.i32_and ],
+          [ Opcodes.if, valtypeBinary ],
+          ...pass,
+          [ Opcodes.else ],
+          ...fail,
+          [ Opcodes.end ]
+        ];
 
-        return out;
+        // pain.
+        // return checkFlag(0b10, [ // constr
+        //   [ Opcodes.i32_const, decl._new ? 1 : 0 ],
+        //   ...argsOut,
+        //   [ Opcodes.local_get, funcLocal ],
+        //   [ Opcodes.call_indirect, argc, 0, 'constr' ],
+        //   ...setLastType(scope),
+        // ], [
+        //   ...argsOut,
+        //   [ Opcodes.local_get, funcLocal ],
+        //   [ Opcodes.call_indirect, argc, 0 ],
+        //   ...setLastType(scope),
+        // ]);
+
+        return checkFlag(0b1, // no type return
+          checkFlag(0b10, [ // no type return & constr
+            [ Opcodes.i32_const, decl._new ? 1 : 0 ],
+            ...argsOut,
+            [ Opcodes.local_get, funcLocal ],
+            [ Opcodes.call_indirect, argc, 0, 'no_type_return', 'constr' ],
+          ], [
+            ...argsOut,
+            [ Opcodes.local_get, funcLocal ],
+            [ Opcodes.call_indirect, argc, 0, 'no_type_return' ]
+          ]),
+          checkFlag(0b10, [ // type return & constr
+            [ Opcodes.i32_const, decl._new ? 1 : 0 ],
+            ...argsOut,
+            [ Opcodes.local_get, funcLocal ],
+            [ Opcodes.call_indirect, argc, 0, 'constr' ],
+            ...setLastType(scope),
+          ], [
+            ...argsOut,
+            [ Opcodes.local_get, funcLocal ],
+            [ Opcodes.call_indirect, argc, 0 ],
+            ...setLastType(scope),
+          ]),
+        );
       };
 
       const tableBc = {};
@@ -1885,13 +2033,32 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
           Opcodes.i32_to_u,
           [ Opcodes.local_set, funcLocal ],
 
+          // get if func we are calling is a constructor or not
+          [ Opcodes.local_get, funcLocal ],
+          ...number(3, Valtype.i32),
+          [ Opcodes.i32_mul ],
+          ...number(2, Valtype.i32),
+          [ Opcodes.i32_add ],
+          [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(allocPage(scope, 'func lut') * pageSize), 'read func lut' ],
+          [ Opcodes.local_set, flags ],
+
+          // check if non-constructor was called with new, if so throw
+          [ Opcodes.local_get, flags ],
+          ...number(0b10, Valtype.i32),
+          [ Opcodes.i32_and ],
+          [ Opcodes.i32_eqz ],
+          [ Opcodes.i32_const, decl._new ? 1 : 0 ],
+          [ Opcodes.i32_and ],
+          [ Opcodes.if, Blocktype.void ],
+            ...internalThrow(scope, 'TypeError', `${unhackName(name)} is not a constructor`),
+          [ Opcodes.end ],
+
           ...brTable([
             // get argc of func we are calling
             [ Opcodes.local_get, funcLocal ],
-            ...number(ValtypeSize.i16, Valtype.i32),
+            ...number(3, Valtype.i32),
             [ Opcodes.i32_mul ],
-
-            [ Opcodes.i32_load16_u, 0, ...unsignedLEB128(allocPage(scope, 'func argc lut') * pageSize), 'read_argc' ]
+            [ Opcodes.i32_load16_u, 0, ...unsignedLEB128(allocPage(scope, 'func lut') * pageSize), 'read func lut' ]
           ], tableBc, valtypeBinary)
         ],
         default: internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, true)
@@ -1905,7 +2072,16 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
   const userFunc = func && !func.internal;
   const typedParams = userFunc || builtinFuncs[name]?.typedParams;
   const typedReturns = (userFunc && func.returnType == null) || builtinFuncs[name]?.typedReturns;
-  const paramCount = func && (typedParams ? func.params.length / 2 : func.params.length);
+  let paramCount = func && (typedParams ? Math.floor(func.params.length / 2) : func.params.length);
+
+  let paramOffset = 0;
+  if (func && func.constr) {
+    // new.target arg
+    if (func.internal) paramOffset = 1;
+    if (!typedParams) paramCount--;
+    out.push([ Opcodes.i32_const, decl._new ? 1 : 0 ]);
+  } else if (decl._new)
+    return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a constructor`, true);
 
   let args = decl.arguments;
   if (func && args.length < paramCount) {
@@ -1920,7 +2096,6 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
 
   if (func && func.throws) scope.throws = true;
 
-  let out = [];
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     out = out.concat(generate(scope, arg));
@@ -1933,13 +2108,13 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     }
 
     if (valtypeBinary !== Valtype.i32 &&
-      (func && func.params[i * (typedParams ? 2 : 1)] === Valtype.i32)
+      (func && func.params[paramOffset + i * (typedParams ? 2 : 1)] === Valtype.i32)
     ) {
       out.push(Opcodes.i32_to);
     }
 
     if (valtypeBinary === Valtype.i32 &&
-      (func && func.params[i * (typedParams ? 2 : 1)] === Valtype.f64)
+      (func && func.params[paramOffset + i * (typedParams ? 2 : 1)] === Valtype.f64)
     ) {
       out.push([ Opcodes.f64_convert_i32_s ]);
     }
@@ -1972,32 +2147,10 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
   return out;
 };
 
-const generateNew = (scope, decl, _global, _name) => {
-  // hack: basically treat this as a normal call for builtins for now
-  const name = mapName(decl.callee.name);
-
-  if (internalConstrs[name] && !internalConstrs[name].notConstr) return internalConstrs[name].generate(scope, decl, _global, _name);
-
-  if (builtinFuncs[name + '$constructor']) {
-    // custom ...$constructor override builtin func
-    return generateCall(scope, {
-      ...decl,
-      callee: {
-        type: 'Identifier',
-        name: name + '$constructor'
-      }
-    }, _global, _name);
-  }
-
-  if (
-    (builtinFuncs[name] && !builtinFuncs[name].constr) ||
-    (internalConstrs[name] && builtinFuncs[name].notConstr)
-  ) return internalThrow(scope, 'TypeError', `${name} is not a constructor`, true);
-
-  if (!builtinFuncs[name]) return todo(scope, `new statement is not supported yet`, true); // return todo(scope, `new statement is not supported yet (new ${unhackName(name)})`);
-
-  return generateCall(scope, decl, _global, _name);
-};
+const generateNew = (scope, decl, _global, _name) => generateCall(scope, {
+  ...decl,
+  _new: true
+}, _global, _name);
 
 // bad hack for undefined and null working without additional logic
 const DEFAULT_VALUE = {
@@ -2005,6 +2158,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 +2175,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 +2462,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 };
@@ -2349,8 +2507,8 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
 
   // arr[i]
   if (decl.left.type === 'MemberExpression' && decl.left.computed) {
-    const newValueTmp = localTmp(scope, '__member_setter_val_tmp');
-    const pointerTmp = op === '=' ? -1 : localTmp(scope, '__member_setter_ptr_tmp', Valtype.i32);
+    const newValueTmp = localTmp(scope, '#member_setter_val_tmp');
+    const pointerTmp = localTmp(scope, '#member_setter_ptr_tmp', Valtype.i32);
 
     return [
       ...typeSwitch(scope, getNodeType(scope, decl.left.object), {
@@ -2362,11 +2520,11 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
           ...generate(scope, decl.left.property),
           Opcodes.i32_to_u,
 
-          // turn into byte offset by * valtypeSize (4 for i32, 8 for i64/f64)
+          // turn into byte offset by * valtypeSize + 1
           ...number(ValtypeSize[valtype] + 1, Valtype.i32),
           [ Opcodes.i32_mul ],
           [ Opcodes.i32_add ],
-          ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
+          [ Opcodes.local_tee, pointerTmp ],
 
           ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
             [ Opcodes.local_get, pointerTmp ],
@@ -2376,10 +2534,164 @@ 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 ],
 
-          [ Opcodes.store, 0, ValtypeSize.i32 ]
+          [ Opcodes.local_get, pointerTmp ],
+          ...getNodeType(scope, decl),
+          [ Opcodes.i32_store8, 0, ValtypeSize.i32 + ValtypeSize[valtype] ],
         ],
 
+        ...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 +3075,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 +3125,7 @@ const generateForOf = (scope, decl) => {
       [ Opcodes.end ],
       [ Opcodes.end ]
     ],
+
     [TYPES.string]: [
       ...setType(scope, leftName, TYPES.string),
 
@@ -2919,6 +3234,7 @@ const generateForOf = (scope, decl) => {
       [ Opcodes.end ],
       [ Opcodes.end ]
     ],
+
     [TYPES.set]: [
       [ Opcodes.loop, Blocktype.void ],
 
@@ -2957,6 +3273,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 +3445,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;
 
-  // 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 ?? '';
+    // 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 (tags.length === 0) tags.push({
-    params: [ Valtype.i32 ],
-    results: [],
-    idx: tags.length
-  });
+  if (exceptionMode === 'stack') {
+    if (tags.length === 0) tags.push({
+      params: [ valtypeBinary, Valtype.i32 ],
+      results: [],
+      idx: tags.length
+    });
+
+    return [
+      ...generate(scope, decl.argument),
+      ...getNodeType(scope, decl.argument),
+      [ Opcodes.throw, tags[0].idx ]
+    ];
+  }
 
-  let exceptId = exceptions.push({ constructor, message }) - 1;
-  let tagIdx = tags[0].idx;
+  if (exceptionMode === 'stackest') {
+    let message = decl.argument, constructor = null;
 
-  scope.exceptions ??= [];
-  scope.exceptions.push(exceptId);
+    // support `throw (new)? Error(...)`
+    if (message.type === 'NewExpression' || message.type === 'CallExpression') {
+      constructor = decl.argument.callee;
+      message = decl.argument.arguments[0];
+    }
 
-  // todo: write a description of how this works lol
+    message ??= DEFAULT_VALUE;
 
-  return [
-    [ Opcodes.i32_const, signedLEB128(exceptId) ],
-    [ Opcodes.throw, tagIdx ]
-  ];
+    if (tags.length === 0) tags.push({
+      params: [ valtypeBinary, valtypeBinary, Valtype.i32 ],
+      results: [],
+      idx: tags.length
+    });
+
+    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) => {
@@ -3090,6 +3576,22 @@ const generateEmpty = (scope, decl) => {
   return [];
 };
 
+const generateMeta = (scope, decl) => {
+  if (decl.meta.name !== 'new') return todo(scope, `meta property object ${decl.meta.name} is not supported yet`, true);
+
+  switch (`${decl.meta.name}.${decl.property.name}`) {
+    case 'new.target': {
+      scope.constr = true;
+
+      return [
+        [ Opcodes.local_get, -1 ],
+        Opcodes.i32_from_u,
+        ...setLastType(scope, TYPES.boolean)
+      ];
+    }
+  }
+};
+
 let pages = new Map();
 const allocPage = (scope, reason, type) => {
   if (pages.has(reason)) return pages.get(reason).ind;
@@ -3407,6 +3909,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;
 
@@ -3429,20 +3944,10 @@ const generateMember = (scope, decl, _global, _name) => {
     const func = funcs.find(x => x.name === name);
     if (func) {
       const typedParams = !func.internal || builtinFuncs[name]?.typedParams;
-      return withType(scope, number(typedParams ? func.params.length / 2 : func.params.length), TYPES.number);
+      return withType(scope, number(typedParams ? Math.floor(func.params.length / 2) : (func.constr ? (func.params.length - 1) : func.params.length)), TYPES.number);
     }
 
-    if (builtinFuncs[name + '$constructor']) {
-      const regularFunc = builtinFuncs[name];
-      const regularParams = regularFunc.typedParams ? (regularFunc.params.length / 2) : regularFunc.params.length;
-
-      const constructorFunc = builtinFuncs[name + '$constructor'];
-      const constructorParams = constructorFunc.typedParams ? (constructorFunc.params.length / 2) : constructorFunc.params.length;
-
-      return withType(scope, number(Math.max(regularParams, constructorParams)), TYPES.number);
-    }
-
-    if (builtinFuncs[name]) return withType(scope, number(builtinFuncs[name].typedParams ? (builtinFuncs[name].params.length / 2) : builtinFuncs[name].params.length), TYPES.number);
+    if (builtinFuncs[name]) return withType(scope, number(builtinFuncs[name].typedParams ? Math.floor(builtinFuncs[name].params.length / 2) : (builtinFuncs[name].constr ? (builtinFuncs[name].params.length - 1) : builtinFuncs[name].params.length)), TYPES.number);
     if (importedFuncs[name]) return withType(scope, number(importedFuncs[name].params.length ?? importedFuncs[name].params), TYPES.number);
     if (internalConstrs[name]) return withType(scope, number(internalConstrs[name].length ?? 0), TYPES.number);
 
@@ -3460,7 +3965,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 +3977,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 +3996,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 +4028,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 +4104,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 +4202,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;
       }
@@ -3670,8 +4255,8 @@ const generateFunc = (scope, decl) => {
 
   if (typedInput && decl.returnType) {
     const { type } = extractTypeAnnotation(decl.returnType);
-    // if (type != null && !Prefs.indirectCalls) {
-    if (type != null) {
+    if (type != null && !Prefs.indirectCalls) {
+    // if (type != null) {
       func.returnType = type;
       func.returns = [ valtypeBinary ];
     }
@@ -3772,7 +4357,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,