porffor 0.17.0-a1f691e30 → 0.17.0-a23029b3a

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';
@@ -123,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);
 
@@ -295,10 +298,10 @@ const generateIdent = (scope, decl) => {
     }
 
     // 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 (!Object.hasOwn(funcIndex, name) && Object.hasOwn(builtinFuncs, name)) {
+      includeBuiltin(scope, name);
+      return number(funcIndex[name] - importedFuncs.length);
+    }
 
     if (isExistingProtoFunc(name) || Object.hasOwn(internalConstrs, name) || Object.hasOwn(builtinFuncs, name)) {
       // todo: return an actual something
@@ -619,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
 
@@ -1023,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;
 
@@ -1055,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) {
@@ -1082,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;
@@ -1217,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;
       }
@@ -1345,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;
         }
 
@@ -1417,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) {
@@ -1528,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 ?? '';
 
@@ -1571,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];
@@ -1584,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);
@@ -1610,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])
       ];
     }
 
@@ -1619,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;
@@ -1649,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
         });
       }
@@ -1743,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,
 
-        // TODO: error better
-        default: internalThrow(scope, 'TypeError', `'${protoName}' proto func tried to be called on a type without an impl`)
-      }, valtypeBinary);
+        ...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: 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 },
@@ -1820,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*
@@ -1830,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') {
@@ -1895,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 = {};
@@ -1930,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)
@@ -1950,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) {
@@ -1965,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));
@@ -1978,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 ]);
     }
@@ -2017,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 = {
@@ -2050,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;
@@ -2057,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) {
@@ -2285,9 +2403,120 @@ const generateVar = (scope, decl) => {
   const global = topLevel || decl._bare;
 
   for (const x of decl.declarations) {
-    const name = mapName(x.id.name);
+    if (x.id.type === 'ArrayPattern') {
+      const decls = [];
+      const tmpName = '#destructure' + randId();
+
+      let i = 0;
+      const elements = [...x.id.elements];
+      for (const e of elements) {
+        switch (e?.type) {
+          case 'RestElement': { // let [ ...foo ] = []
+            if (e.argument.type === 'ArrayPattern') {
+              // let [ ...[a, b, c] ] = []
+              elements.push(...e.argument.elements);
+            } else {
+              decls.push({
+                type: 'VariableDeclarator',
+                id: { type: 'Identifier', name: e.argument.name },
+                init: {
+                  type: 'CallExpression',
+                  callee: {
+                    type: 'Identifier',
+                    name: '__Array_prototype_slice'
+                  },
+                  arguments: [
+                    { type: 'Identifier', name: tmpName },
+                    { type: 'Literal', value: i },
+                    {
+                      type: 'MemberExpression',
+                      object: { type: 'Identifier', name: tmpName, },
+                      property: { type: 'Identifier', name: 'length', }
+                    }
+                  ]
+                }
+              });
+            }
+
+            continue; // skip i++
+          }
 
-    if (!name) return todo(scope, 'destructuring is not supported yet');
+          case 'Identifier': { // let [ foo ] = []
+            decls.push({
+              type: 'VariableDeclarator',
+              id: e,
+              init: {
+                type: 'MemberExpression',
+                object: { type: 'Identifier', name: tmpName },
+                property: { type: 'Literal', value: i }
+              }
+            });
+
+            break;
+          }
+
+          case 'AssignmentPattern': { // let [ foo = defaultValue ] = []
+            decls.push({
+              type: 'VariableDeclarator',
+              id: e.left,
+              init: {
+                type: 'LogicalExpression',
+                operator: '??',
+                left: {
+                  type: 'MemberExpression',
+                  object: { type: 'Identifier', name: tmpName },
+                  property: { type: 'Literal', value: i }
+                },
+                right: e.right
+              }
+            });
+
+            break;
+          }
+
+          case 'ArrayPattern': { // let [ [ foo, bar ] ] = []
+            decls.push({
+              type: 'VariableDeclarator',
+              id: e,
+              init: {
+                type: 'MemberExpression',
+                object: { type: 'Identifier', name: tmpName },
+                property: { type: 'Literal', value: i }
+              }
+            });
+
+            break;
+          }
+
+          case 'ObjectPattern':
+            return todo(scope, 'object destructuring is not supported yet')
+        }
+
+        i++;
+      }
+
+      out = out.concat([
+        ...generateVar(scope, {
+          type: 'VariableDeclaration',
+          declarations: [{
+            type: 'VariableDeclarator',
+            id: { type: 'Identifier', name: tmpName },
+            init: x.init
+          }],
+          kind: decl.kind
+        }),
+        ...generateVar(scope, {
+          type: 'VariableDeclaration',
+          declarations: decls,
+          kind: decl.kind
+        })
+      ]);
+
+      continue;
+    }
+
+    const name = mapName(x.id.name);
+    if (!name) return todo(scope, 'object destructuring is not supported yet')
 
     if (x.init && isFuncType(x.init.type)) {
       // hack for let a = function () { ... }
@@ -2322,7 +2551,9 @@ const generateVar = (scope, decl) => {
         // hack to set local as pointer before
         out.push(...number(scope.arrays.get(name)), [ global ? Opcodes.global_set : Opcodes.local_set, idx ]);
         if (generated.at(-1) == Opcodes.i32_from_u) generated.pop();
-        generated.pop();
+        // generated.pop();
+        generated.push([ Opcodes.drop ]);
+
         out = out.concat(generated);
       } else {
         out = out.concat(generated);
@@ -2389,8 +2620,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), {
@@ -2402,11 +2633,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 ],
@@ -2416,10 +2647,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),
 
@@ -2803,7 +3188,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)
@@ -2851,6 +3238,7 @@ const generateForOf = (scope, decl) => {
       [ Opcodes.end ],
       [ Opcodes.end ]
     ],
+
     [TYPES.string]: [
       ...setType(scope, leftName, TYPES.string),
 
@@ -2959,6 +3347,7 @@ const generateForOf = (scope, decl) => {
       [ Opcodes.end ],
       [ Opcodes.end ]
     ],
+
     [TYPES.set]: [
       [ Opcodes.loop, Blocktype.void ],
 
@@ -2997,6 +3386,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));
 
@@ -3085,13 +3574,14 @@ const generateThrow = (scope, decl) => {
       idx: tags.length
     });
 
-    let exceptId = exceptions.push({ constructor, message }) - 1;
+    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 [
-      [ Opcodes.i32_const, signedLEB128(exceptId) ],
+      ...number(exceptId, Valtype.i32),
       [ Opcodes.throw, tags[0].idx ]
     ];
   }
@@ -3158,7 +3648,7 @@ const generateThrow = (scope, decl) => {
     scope.exceptions.push(exceptId);
 
     return [
-      [ Opcodes.i32_const, signedLEB128(exceptId) ],
+      ...number(exceptId, Valtype.i32),
       ...generate(scope, message),
       ...getNodeType(scope, message),
       [ Opcodes.throw, tags[0].idx ]
@@ -3199,6 +3689,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;
@@ -3516,6 +4022,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;
 
@@ -3538,20 +4057,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);
-    }
-
-    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);
+      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]) 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);
 
@@ -3569,7 +4078,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,
 
@@ -3581,7 +4090,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,
@@ -3598,7 +4109,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'));
 
@@ -3630,7 +4141,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)
@@ -3704,6 +4217,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)
   });
 };
@@ -3726,7 +4315,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;
       }
@@ -3779,8 +4368,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 ];
     }