porffor 0.2.0-536e463 → 0.2.0-5ac7ea0

package/compiler/codeGen.js

@@ -1,5 +1,5 @@
 import { Blocktype, Opcodes, Valtype, PageSize, ValtypeSize } from "./wasmSpec.js";
-import { ieee754_binary64, signedLEB128, unsignedLEB128 } from "./encoding.js";
+import { ieee754_binary64, signedLEB128, unsignedLEB128, encodeVector } from "./encoding.js";
 import { operatorOpcode } from "./expression.js";
 import { BuiltinFuncs, BuiltinVars, importedFuncs, NULL, UNDEFINED } from "./builtins.js";
 import { PrototypeFuncs } from "./prototype.js";
@@ -7,6 +7,7 @@ import { number, i32x4, enforceOneByte, enforceTwoBytes, enforceFourBytes, enfor
 import { log } from "./log.js";
 import parse from "./parse.js";
 import * as Rhemyn from "../rhemyn/compile.js";
+import Prefs from './prefs.js';
 
 let globals = {};
 let globalInd = 0;
@@ -55,7 +56,7 @@ const todo = msg => {
 };
 
 const isFuncType = type => type === 'FunctionDeclaration' || type === 'FunctionExpression' || type === 'ArrowFunctionExpression';
-const generate = (scope, decl, global = false, name = undefined) => {
+const generate = (scope, decl, global = false, name = undefined, valueUnused = false) => {
   switch (decl.type) {
     case 'BinaryExpression':
       return generateBinaryExp(scope, decl, global, name);
@@ -68,7 +69,12 @@ const generate = (scope, decl, global = false, name = undefined) => {
 
     case 'ArrowFunctionExpression':
     case 'FunctionDeclaration':
-      generateFunc(scope, decl);
+      const func = generateFunc(scope, decl);
+
+      if (decl.type.endsWith('Expression')) {
+        return number(func.index);
+      }
+
       return [];
 
     case 'BlockStatement':
@@ -81,7 +87,7 @@ const generate = (scope, decl, global = false, name = undefined) => {
       return generateExp(scope, decl);
 
     case 'CallExpression':
-      return generateCall(scope, decl, global, name);
+      return generateCall(scope, decl, global, name, valueUnused);
 
     case 'NewExpression':
       return generateNew(scope, decl, global, name);
@@ -99,7 +105,7 @@ const generate = (scope, decl, global = false, name = undefined) => {
       return generateUnary(scope, decl);
 
     case 'UpdateExpression':
-      return generateUpdate(scope, decl);
+      return generateUpdate(scope, decl, global, name, valueUnused);
 
     case 'IfStatement':
       return generateIf(scope, decl);
@@ -155,7 +161,7 @@ const generate = (scope, decl, global = false, name = undefined) => {
 
     case 'TaggedTemplateExpression': {
       const funcs = {
-        asm: str => {
+        __Porffor_wasm: str => {
           let out = [];
 
           for (const line of str.split('\n')) {
@@ -163,8 +169,8 @@ const generate = (scope, decl, global = false, name = undefined) => {
             if (asm[0] === '') continue; // blank
 
             if (asm[0] === 'local') {
-              const [ name, idx, type ] = asm.slice(1);
-              scope.locals[name] = { idx: parseInt(idx), type: Valtype[type] };
+              const [ name, type ] = asm.slice(1);
+              scope.locals[name] = { idx: scope.localInd++, type: Valtype[type] };
               continue;
             }
 
@@ -174,7 +180,7 @@ const generate = (scope, decl, global = false, name = undefined) => {
             }
 
             if (asm[0] === 'memory') {
-              allocPage('asm instrinsic');
+              allocPage(scope, 'asm instrinsic');
               // todo: add to store/load offset insts
               continue;
             }
@@ -183,7 +189,11 @@ const generate = (scope, decl, global = false, name = undefined) => {
             if (!inst) throw new Error(`inline asm: inst ${asm[0]} not found`);
 
             if (!Array.isArray(inst)) inst = [ inst ];
-            const immediates = asm.slice(1).map(x => parseInt(x));
+            const immediates = asm.slice(1).map(x => {
+              const int = parseInt(x);
+              if (Number.isNaN(int)) return scope.locals[x]?.idx;
+              return int;
+            });
 
             out.push([ ...inst, ...immediates ]);
           }
@@ -191,29 +201,43 @@ const generate = (scope, decl, global = false, name = undefined) => {
           return out;
         },
 
-        __internal_print_type: str => {
-          const type = getType(scope, str) - TYPES.number;
+        __Porffor_bs: str => [
+          ...makeString(scope, str, undefined, undefined, true),
 
-          return [
-            ...number(type),
-            [ Opcodes.call, importedFuncs.print ],
+          ...number(TYPES._bytestring, Valtype.i32),
+          setLastType(scope)
+        ],
+        __Porffor_s: str => [
+          ...makeString(scope, str, undefined, undefined, false),
 
-            // newline
-            ...number(10),
-            [ Opcodes.call, importedFuncs.printChar ]
-          ];
-        }
-      }
+          ...number(TYPES.string, Valtype.i32),
+          setLastType(scope)
+        ],
+      };
 
       const name = decl.tag.name;
       // hack for inline asm
       if (!funcs[name]) return todo('tagged template expressions not implemented');
 
-      const str = decl.quasi.quasis[0].value.raw;
+      const { quasis, expressions } = decl.quasi;
+      let str = quasis[0].value.raw;
+
+      for (let i = 0; i < expressions.length; i++) {
+        const e = expressions[i];
+        str += lookupName(scope, e.name)[0].idx;
+        str += quasis[i + 1].value.raw;
+      }
+
       return funcs[name](str);
     }
 
     default:
+      // ignore typescript nodes
+      if (decl.type.startsWith('TS') ||
+          decl.type === 'ImportDeclaration' && decl.importKind === 'type') {
+        return [];
+      }
+
       return todo(`no generation for ${decl.type}!`);
   }
 };
@@ -264,25 +288,28 @@ const generateIdent = (scope, decl) => {
     const name = mapName(rawName);
     let local = scope.locals[rawName];
 
-    if (builtinVars[name]) {
+    if (Object.hasOwn(builtinVars, name)) {
       if (builtinVars[name].floatOnly && valtype[0] === 'i') throw new Error(`Cannot use ${unhackName(name)} with integer valtype`);
-      return builtinVars[name];
+
+      let wasm = builtinVars[name];
+      if (typeof wasm === 'function') wasm = asmFuncToAsm(wasm, { name });
+      return wasm;
     }
 
-    if (builtinFuncs[name] || internalConstrs[name]) {
+    if (Object.hasOwn(builtinFuncs, name) || Object.hasOwn(internalConstrs, name)) {
       // todo: return an actual something
       return number(1);
     }
 
-    if (local === undefined) {
+    if (local?.idx === undefined) {
       // no local var with name
-      if (importedFuncs.hasOwnProperty(name)) return number(importedFuncs[name]);
-      if (funcIndex[name] !== undefined) return number(funcIndex[name]);
+      if (Object.hasOwn(importedFuncs, name)) return number(importedFuncs[name]);
+      if (Object.hasOwn(funcIndex, name)) return number(funcIndex[name]);
 
-      if (globals[name] !== undefined) return [ [ Opcodes.global_get, globals[name].idx ] ];
+      if (Object.hasOwn(globals, name)) return [ [ Opcodes.global_get, globals[name].idx ] ];
     }
 
-    if (local === undefined && rawName.startsWith('__')) {
+    if (local?.idx === undefined && rawName.startsWith('__')) {
       // return undefined if unknown key in already known var
       let parent = rawName.slice(2).split('_').slice(0, -1).join('_');
       if (parent.includes('_')) parent = '__' + parent;
@@ -291,7 +318,7 @@ const generateIdent = (scope, decl) => {
       if (!parentLookup[1]) return number(UNDEFINED);
     }
 
-    if (local === undefined) return internalThrow(scope, 'ReferenceError', `${unhackName(name)} is not defined`, true);
+    if (local?.idx === undefined) return internalThrow(scope, 'ReferenceError', `${unhackName(name)} is not defined`, true);
 
     return [ [ Opcodes.local_get, local.idx ] ];
   };
@@ -360,12 +387,12 @@ const performLogicOp = (scope, op, left, right, leftType, rightType) => {
       ...right,
       // note type
       ...rightType,
-      [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ],
+      setLastType(scope),
       [ Opcodes.else ],
       [ Opcodes.local_get, localTmp(scope, 'logictmpi', Valtype.i32) ],
       // note type
       ...leftType,
-      [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ],
+      setLastType(scope),
       [ Opcodes.end ],
       Opcodes.i32_from
     ];
@@ -379,12 +406,12 @@ const performLogicOp = (scope, op, left, right, leftType, rightType) => {
     ...right,
     // note type
     ...rightType,
-    [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ],
+    setLastType(scope),
     [ Opcodes.else ],
     [ Opcodes.local_get, localTmp(scope, 'logictmp') ],
     // note type
     ...leftType,
-    [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ],
+    setLastType(scope),
     [ Opcodes.end ]
   ];
 };
@@ -399,9 +426,6 @@ const concatStrings = (scope, left, right, global, name, assign) => {
   const rightLength = localTmp(scope, 'concat_right_length', Valtype.i32);
   const leftLength = localTmp(scope, 'concat_left_length', Valtype.i32);
 
-  const aotWFA = process.argv.includes('-aot-well-formed-string-approximation');
-  if (aotWFA) addVarMeta(name, { wellFormed: undefined });
-
   if (assign) {
     const pointer = arrays.get(name ?? '$undeclared');
 
@@ -639,11 +663,12 @@ const truthy = (scope, wasm, type, intIn = false, intOut = false) => {
     ...(!intIn && intOut ? [ Opcodes.i32_to_u ] : [])
   ];
 
-  const tmp = localTmp(scope, `$logicinner_tmp${intIn ? '_int' : ''}`, intIn ? Valtype.i32 : valtypeBinary);
+  const useTmp = knownType(scope, type) == null;
+  const tmp = useTmp && localTmp(scope, `$logicinner_tmp${intIn ? '_int' : ''}`, intIn ? Valtype.i32 : valtypeBinary);
 
   const def = [
     // if value != 0
-    [ Opcodes.local_get, tmp ],
+    ...(!useTmp ? [] : [ [ Opcodes.local_get, tmp ] ]),
 
     // ...(intIn ? [ [ Opcodes.i32_eqz ] ] : [ ...Opcodes.eqz ]),
     ...(!intOut || (intIn && intOut) ? [] : [ Opcodes.i32_to_u ]),
@@ -655,7 +680,7 @@ const truthy = (scope, wasm, type, intIn = false, intOut = false) => {
 
   return [
     ...wasm,
-    [ Opcodes.local_set, tmp ],
+    ...(!useTmp ? [] : [ [ Opcodes.local_set, tmp ] ]),
 
     ...typeSwitch(scope, type, {
       // [TYPES.number]: def,
@@ -664,7 +689,7 @@ const truthy = (scope, wasm, type, intIn = false, intOut = false) => {
         ...number(1, intOut ? Valtype.i32 : valtypeBinary)
       ],
       [TYPES.string]: [
-        [ Opcodes.local_get, tmp ],
+        ...(!useTmp ? [] : [ [ Opcodes.local_get, tmp ] ]),
         ...(intIn ? [] : [ Opcodes.i32_to_u ]),
 
         // get length
@@ -675,16 +700,27 @@ const truthy = (scope, wasm, type, intIn = false, intOut = false) => {
         [ Opcodes.i32_eqz ], */
         ...(intOut ? [] : [ Opcodes.i32_from_u ])
       ],
+      [TYPES._bytestring]: [ // duplicate of string
+      ...(!useTmp ? [] : [ [ Opcodes.local_get, tmp ] ]),
+        ...(intIn ? [] : [ Opcodes.i32_to_u ]),
+
+        // get length
+        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
+
+        ...(intOut ? [] : [ Opcodes.i32_from_u ])
+      ],
       default: def
     }, intOut ? Valtype.i32 : valtypeBinary)
   ];
 };
 
 const falsy = (scope, wasm, type, intIn = false, intOut = false) => {
-  const tmp = localTmp(scope, `$logicinner_tmp${intIn ? '_int' : ''}`, intIn ? Valtype.i32 : valtypeBinary);
+  const useTmp = knownType(scope, type) == null;
+  const tmp = useTmp && localTmp(scope, `$logicinner_tmp${intIn ? '_int' : ''}`, intIn ? Valtype.i32 : valtypeBinary);
+
   return [
     ...wasm,
-    [ Opcodes.local_set, tmp ],
+    ...(!useTmp ? [] : [ [ Opcodes.local_set, tmp ] ]),
 
     ...typeSwitch(scope, type, {
       [TYPES._array]: [
@@ -692,7 +728,18 @@ const falsy = (scope, wasm, type, intIn = false, intOut = false) => {
         ...number(0, intOut ? Valtype.i32 : valtypeBinary)
       ],
       [TYPES.string]: [
-        [ Opcodes.local_get, tmp ],
+        ...(!useTmp ? [] : [ [ Opcodes.local_get, tmp ] ]),
+        ...(intIn ? [] : [ Opcodes.i32_to_u ]),
+
+        // get length
+        [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
+
+        // if length == 0
+        [ Opcodes.i32_eqz ],
+        ...(intOut ? [] : [ Opcodes.i32_from_u ])
+      ],
+      [TYPES._bytestring]: [ // duplicate of string
+        ...(!useTmp ? [] : [ [ Opcodes.local_get, tmp ] ]),
         ...(intIn ? [] : [ Opcodes.i32_to_u ]),
 
         // get length
@@ -704,7 +751,7 @@ const falsy = (scope, wasm, type, intIn = false, intOut = false) => {
       ],
       default: [
         // if value == 0
-        [ Opcodes.local_get, tmp ],
+        ...(!useTmp ? [] : [ [ Opcodes.local_get, tmp ] ]),
 
         ...(intIn ? [ [ Opcodes.i32_eqz ] ] : [ ...Opcodes.eqz ]),
         ...(intOut ? [] : [ Opcodes.i32_from_u ])
@@ -714,10 +761,12 @@ const falsy = (scope, wasm, type, intIn = false, intOut = false) => {
 };
 
 const nullish = (scope, wasm, type, intIn = false, intOut = false) => {
-  const tmp = localTmp(scope, `$logicinner_tmp${intIn ? '_int' : ''}`, intIn ? Valtype.i32 : valtypeBinary);
+  const useTmp = knownType(scope, type) == null;
+  const tmp = useTmp && localTmp(scope, `$logicinner_tmp${intIn ? '_int' : ''}`, intIn ? Valtype.i32 : valtypeBinary);
+
   return [
     ...wasm,
-    [ Opcodes.local_set, tmp ],
+    ...(!useTmp ? [] : [ [ Opcodes.local_set, tmp ] ]),
 
     ...typeSwitch(scope, type, {
       [TYPES.undefined]: [
@@ -726,7 +775,7 @@ const nullish = (scope, wasm, type, intIn = false, intOut = false) => {
       ],
       [TYPES.object]: [
         // object, null if == 0
-        [ Opcodes.local_get, tmp ],
+        ...(!useTmp ? [] : [ [ Opcodes.local_get, tmp ] ]),
 
         ...(intIn ? [ [ Opcodes.i32_eqz ] ] : [ ...Opcodes.eqz ]),
         ...(intOut ? [] : [ Opcodes.i32_from_u ])
@@ -755,11 +804,14 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
     return performLogicOp(scope, op, left, right, leftType, rightType);
   }
 
+  const knownLeft = knownType(scope, leftType);
+  const knownRight = knownType(scope, rightType);
+
   const eqOp = ['==', '===', '!=', '!==', '>', '>=', '<', '<='].includes(op);
   const strictOp = op === '===' || op === '!==';
 
   const startOut = [], endOut = [];
-  const finalise = out => startOut.concat(out, endOut);
+  const finalize = out => startOut.concat(out, endOut);
 
   // if strict (in)equal check types match
   if (strictOp) {
@@ -804,31 +856,32 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
   // todo: if equality op and an operand is undefined, return false
   // todo: niche null hell with 0
 
-  // if (leftType === TYPES.string || rightType === TYPES.string) {
-  //   if (op === '+') {
-  //     // string concat (a + b)
-  //     return finalise(concatStrings(scope, left, right, _global, _name, assign));
-  //   }
-
-  //   // not an equality op, NaN
-  //   if (!eqOp) return finalise(number(NaN));
-
-  //   // else leave bool ops
-  //   // todo: convert string to number if string and number/bool
-  //   // todo: string (>|>=|<|<=) string
-
-  //   // string comparison
-  //   if (op === '===' || op === '==') {
-  //     return finalise(compareStrings(scope, left, right));
-  //   }
-
-  //   if (op === '!==' || op === '!=') {
-  //     return finalise([
-  //       ...compareStrings(scope, left, right),
-  //       [ Opcodes.i32_eqz ]
-  //     ]);
-  //   }
-  // }
+  // todo: this should be dynamic but for now only static
+  if (knownLeft === TYPES.string || knownRight === TYPES.string) {
+    if (op === '+') {
+      // string concat (a + b)
+      return concatStrings(scope, left, right, _global, _name, assign);
+    }
+
+    // not an equality op, NaN
+    if (!eqOp) return number(NaN);
+
+    // else leave bool ops
+    // todo: convert string to number if string and number/bool
+    // todo: string (>|>=|<|<=) string
+
+    // string comparison
+    if (op === '===' || op === '==') {
+      return compareStrings(scope, left, right);
+    }
+
+    if (op === '!==' || op === '!=') {
+      return [
+        ...compareStrings(scope, left, right),
+        [ Opcodes.i32_eqz ]
+      ];
+    }
+  }
 
   let ops = operatorOpcode[valtype][op];
 
@@ -838,7 +891,7 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
     includeBuiltin(scope, builtinName);
     const idx = funcIndex[builtinName];
 
-    return finalise([
+    return finalize([
       ...left,
       ...right,
       [ Opcodes.call, idx ]
@@ -852,7 +905,13 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
 
   let tmpLeft, tmpRight;
   // if equal op, check if strings for compareStrings
-  if (op === '===' || op === '==' || op === '!==' || op === '!=') {
+  if (op === '===' || op === '==' || op === '!==' || op === '!=') (() => {
+    // todo: intelligent partial skip later
+    // if neither known are string, stop this madness
+    if ((knownLeft != null && knownLeft !== TYPES.string) && (knownRight != null && knownRight !== TYPES.string)) {
+      return;
+    }
+
     tmpLeft = localTmp(scope, '__tmpop_left');
     tmpRight = localTmp(scope, '__tmpop_right');
 
@@ -886,7 +945,7 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
       [ Opcodes.i32_or ],
       [ Opcodes.if, Blocktype.void ],
       ...number(0, Valtype.i32),
-      [ Opcodes.br, 1 ],
+      [ Opcodes.br, 2 ],
       [ Opcodes.end ],
 
       ...compareStrings(scope, [ [ Opcodes.local_get, tmpLeft ] ], [ [ Opcodes.local_get, tmpRight ] ]),
@@ -902,9 +961,9 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
       // endOut.push(stringOnly([ Opcodes.end ]));
       endOut.unshift(stringOnly([ Opcodes.end ]));
     // }
-  }
+  })();
 
-  return finalise([
+  return finalize([
     ...left,
     ...(tmpLeft != null ? stringOnly([ [ Opcodes.local_tee, tmpLeft ] ]) : []),
     ...right,
@@ -921,7 +980,22 @@ const generateBinaryExp = (scope, decl, _global, _name) => {
   return out;
 };
 
-const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes = [], globalInits, returns, returnType, localNames = [], globalNames = [] }) => {
+const asmFuncToAsm = (func, { name = '#unknown_asm_func', params = [], locals = [], returns = [], localInd = 0 }) => {
+  return func({ name, params, locals, returns, localInd }, {
+    TYPES, TYPE_NAMES, typeSwitch, makeArray, makeString, allocPage,
+    builtin: name => {
+      let idx = funcIndex[name] ?? importedFuncs[name];
+      if (idx === undefined && builtinFuncs[name]) {
+        includeBuiltin(null, name);
+        idx = funcIndex[name];
+      }
+
+      return idx;
+    }
+  });
+};
+
+const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes = [], globalInits, returns, returnType, localNames = [], globalNames = [], data: _data = [] }) => {
   const existing = funcs.find(x => x.name === name);
   if (existing) return existing;
 
@@ -933,6 +1007,14 @@ const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes
     locals[nameParam(i)] = { idx: i, type: allLocals[i] };
   }
 
+  for (const x of _data) {
+    const copy = { ...x };
+    copy.offset += pages.size * pageSize;
+    data.push(copy);
+  }
+
+  if (typeof wasm === 'function') wasm = asmFuncToAsm(wasm, { name, params, locals, returns, localInd: allLocals.length });
+
   let baseGlobalIdx, i = 0;
   for (const type of globalTypes) {
     if (baseGlobalIdx === undefined) baseGlobalIdx = globalInd;
@@ -1013,7 +1095,8 @@ const TYPES = {
 
   // these are not "typeof" types but tracked internally
   _array: 0x10,
-  _regexp: 0x11
+  _regexp: 0x11,
+  _bytestring: 0x12
 };
 
 const TYPE_NAMES = {
@@ -1027,13 +1110,17 @@ const TYPE_NAMES = {
   [TYPES.bigint]: 'BigInt',
 
   [TYPES._array]: 'Array',
-  [TYPES._regexp]: 'RegExp'
+  [TYPES._regexp]: 'RegExp',
+  [TYPES._bytestring]: 'ByteString'
 };
 
 const getType = (scope, _name) => {
   const name = mapName(_name);
 
+  if (typedInput && scope.locals[name]?.metadata?.type != null) return number(scope.locals[name].metadata.type, Valtype.i32);
   if (scope.locals[name]) return [ [ Opcodes.local_get, scope.locals[name + '#type'].idx ] ];
+
+  if (typedInput && globals[name]?.metadata?.type != null) return number(globals[name].metadata.type, Valtype.i32);
   if (globals[name]) return [ [ Opcodes.global_get, globals[name + '#type'].idx ] ];
 
   let type = TYPES.undefined;
@@ -1051,11 +1138,13 @@ const setType = (scope, _name, type) => {
 
   const out = typeof type === 'number' ? number(type, Valtype.i32) : type;
 
+  if (typedInput && scope.locals[name]?.metadata?.type != null) return [];
   if (scope.locals[name]) return [
     ...out,
     [ Opcodes.local_set, scope.locals[name + '#type'].idx ]
   ];
 
+  if (typedInput && globals[name]?.metadata?.type != null) return [];
   if (globals[name]) return [
     ...out,
     [ Opcodes.global_set, globals[name + '#type'].idx ]
@@ -1064,11 +1153,22 @@ const setType = (scope, _name, type) => {
   // throw new Error('could not find var');
 };
 
+const getLastType = scope => {
+  scope.gotLastType = true;
+  return [ Opcodes.local_get, localTmp(scope, '#last_type', Valtype.i32) ];
+};
+
+const setLastType = scope => {
+  return [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ];
+};
+
 const getNodeType = (scope, node) => {
   const inner = () => {
     if (node.type === 'Literal') {
       if (node.regex) return TYPES._regexp;
 
+      if (typeof node.value === 'string' && byteStringable(node.value)) return TYPES._bytestring;
+
       return TYPES[typeof node.value];
     }
 
@@ -1082,6 +1182,15 @@ const getNodeType = (scope, node) => {
 
     if (node.type === 'CallExpression' || node.type === 'NewExpression') {
       const name = node.callee.name;
+      if (!name) {
+        // iife
+        if (scope.locals['#last_type']) return [ getLastType(scope) ];
+
+        // presume
+        // todo: warn here?
+        return TYPES.number;
+      }
+
       const func = funcs.find(x => x.name === name);
 
       if (func) {
@@ -1089,10 +1198,27 @@ const getNodeType = (scope, node) => {
         if (func.returnType) return func.returnType;
       }
 
-      if (builtinFuncs[name]) return TYPES[builtinFuncs[name].returnType ?? 'number'];
+      if (builtinFuncs[name] && !builtinFuncs[name].typedReturns) return TYPES[builtinFuncs[name].returnType ?? 'number'];
       if (internalConstrs[name]) return internalConstrs[name].type;
 
-      if (scope.locals['#last_type']) return [ [ Opcodes.local_get, localTmp(scope, '#last_type', Valtype.i32) ] ];
+      // check if this is a prototype function
+      // if so and there is only one impl (eg charCodeAt)
+      // use that return type as that is the only possibility
+      // (if non-matching type it would error out)
+      if (name.startsWith('__')) {
+        const spl = name.slice(2).split('_');
+
+        const func = spl[spl.length - 1];
+        const protoFuncs = Object.keys(prototypeFuncs).filter(x => x != TYPES._bytestring && prototypeFuncs[x][func] != null);
+        if (protoFuncs.length === 1) return protoFuncs[0].returnType ?? TYPES.number;
+      }
+
+      if (name.startsWith('__Porffor_wasm_')) {
+        // todo: return undefined for non-returning ops
+        return TYPES.number;
+      }
+
+      if (scope.locals['#last_type']) return [ getLastType(scope) ];
 
       // presume
       // todo: warn here?
@@ -1140,6 +1266,14 @@ const getNodeType = (scope, node) => {
 
     if (node.type === 'BinaryExpression') {
       if (['==', '===', '!=', '!==', '>', '>=', '<', '<='].includes(node.operator)) return TYPES.boolean;
+      if (node.operator !== '+') return TYPES.number;
+
+      const knownLeft = knownType(scope, getNodeType(scope, node.left));
+      const knownRight = knownType(scope, getNodeType(scope, node.right));
+
+      // todo: this should be dynamic but for now only static
+      if (knownLeft === TYPES.string || knownRight === TYPES.string) return TYPES.string;
+
       return TYPES.number;
 
       // todo: string concat types
@@ -1164,7 +1298,7 @@ const getNodeType = (scope, node) => {
       if (node.operator === '!') return TYPES.boolean;
       if (node.operator === 'void') return TYPES.undefined;
       if (node.operator === 'delete') return TYPES.boolean;
-      if (node.operator === 'typeof') return TYPES.string;
+      if (node.operator === 'typeof') return Prefs.bytestring ? TYPES._bytestring : TYPES.string;
 
       return TYPES.number;
     }
@@ -1173,11 +1307,17 @@ const getNodeType = (scope, node) => {
       // hack: if something.length, number type
       if (node.property.name === 'length') return TYPES.number;
 
-      // we cannot guess
+      // ts hack
+      if (scope.locals[node.object.name]?.metadata?.type === TYPES.string) return TYPES.string;
+      if (scope.locals[node.object.name]?.metadata?.type === TYPES._array) return TYPES.number;
+
+      if (scope.locals['#last_type']) return [ getLastType(scope) ];
+
+      // presume
       return TYPES.number;
     }
 
-    if (scope.locals['#last_type']) return [ [ Opcodes.local_get, localTmp(scope, '#last_type', Valtype.i32) ] ];
+    if (scope.locals['#last_type']) return [ getLastType(scope) ];
 
     // presume
     // todo: warn here?
@@ -1193,8 +1333,8 @@ const getNodeType = (scope, node) => {
 const generateLiteral = (scope, decl, global, name) => {
   if (decl.value === null) return number(NULL);
 
+  // hack: just return 1 for regex literals
   if (decl.regex) {
-    scope.regex[name] = decl.regex;
     return number(1);
   }
 
@@ -1207,16 +1347,7 @@ const generateLiteral = (scope, decl, global, name) => {
       return number(decl.value ? 1 : 0);
 
     case 'string':
-      const str = decl.value;
-      const rawElements = new Array(str.length);
-      let j = 0;
-      for (let i = 0; i < str.length; i++) {
-        rawElements[i] = str.charCodeAt(i);
-      }
-
-      return makeArray(scope, {
-        rawElements
-      }, global, name, false, 'i16')[0];
+      return makeString(scope, decl.value, global, name);
 
     default:
       return todo(`cannot generate literal of type ${typeof decl.value}`);
@@ -1236,10 +1367,10 @@ const countLeftover = wasm => {
     if (inst[0] === Opcodes.end) depth--;
 
     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.memory_grow].includes(inst[0]) && (inst[0] !== 0xfc || inst[1] < 0x0a)) {}
+      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] < 0x0a)) {}
         else if ([Opcodes.local_get, Opcodes.global_get, Opcodes.f64_const, Opcodes.i32_const, Opcodes.i64_const, Opcodes.v128_const].includes(inst[0])) count++;
-        else if ([Opcodes.i32_store, Opcodes.i64_store, Opcodes.f64_store, Opcodes.i32_store16].includes(inst[0])) count -= 2;
+        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.memory_copy[0] === inst[0] && Opcodes.memory_copy[1] === inst[1]) count -= 3;
         else if (inst[0] === Opcodes.return) count = 0;
         else if (inst[0] === Opcodes.call) {
@@ -1265,7 +1396,7 @@ const disposeLeftover = wasm => {
 const generateExp = (scope, decl) => {
   const expression = decl.expression;
 
-  const out = generate(scope, expression);
+  const out = generate(scope, expression, undefined, undefined, true);
   disposeLeftover(out);
 
   return out;
@@ -1323,7 +1454,7 @@ const RTArrayUtil = {
   ]
 };
 
-const generateCall = (scope, decl, _global, _name) => {
+const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
   /* const callee = decl.callee;
   const args = decl.arguments;
 
@@ -1356,13 +1487,13 @@ const generateCall = (scope, decl, _global, _name) => {
       const finalStatement = parsed.body[parsed.body.length - 1];
       out.push(
         ...getNodeType(scope, finalStatement),
-        [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ]
+        setLastType(scope)
       );
     } else if (countLeftover(out) === 0) {
       out.push(...number(UNDEFINED));
       out.push(
         ...number(TYPES.undefined, Valtype.i32),
-        [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ]
+        setLastType(scope)
       );
     }
 
@@ -1380,8 +1511,7 @@ const generateCall = (scope, decl, _global, _name) => {
   if (name && name.startsWith('__')) {
     const spl = name.slice(2).split('_');
 
-    const func = spl[spl.length - 1];
-    protoName = func;
+    protoName = spl[spl.length - 1];
 
     target = { ...decl.callee };
     target.name = spl.slice(0, -1).join('_');
@@ -1390,8 +1520,8 @@ const generateCall = (scope, decl, _global, _name) => {
   // literal.func()
   if (!name && decl.callee.type === 'MemberExpression') {
     // megahack for /regex/.func()
-    if (decl.callee.object.regex) {
-      const funcName = decl.callee.property.name;
+    const funcName = decl.callee.property.name;
+    if (decl.callee.object.regex && Object.hasOwn(Rhemyn, funcName)) {
       const func = Rhemyn[funcName](decl.callee.object.regex.pattern, currentFuncIndex++);
 
       funcIndex[func.name] = func.index;
@@ -1407,12 +1537,11 @@ const generateCall = (scope, decl, _global, _name) => {
         Opcodes.i32_from_u,
 
         ...number(TYPES.boolean, Valtype.i32),
-        [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ]
+        setLastType(scope)
       ];
     }
 
-    const func = decl.callee.property.name;
-    protoName = func;
+    protoName = decl.callee.property.name;
 
     target = decl.callee.object;
   }
@@ -1434,8 +1563,7 @@ const generateCall = (scope, decl, _global, _name) => {
 
   if (protoName) {
     const protoCands = Object.keys(prototypeFuncs).reduce((acc, x) => {
-      const f = prototypeFuncs[x][protoName];
-      if (f) acc[x] = f;
+      if (Object.hasOwn(prototypeFuncs[x], protoName)) acc[x] = prototypeFuncs[x][protoName];
       return acc;
     }, {});
 
@@ -1444,10 +1572,18 @@ const generateCall = (scope, decl, _global, _name) => {
       // use local for cached i32 length as commonly used
       const lengthLocal = localTmp(scope, '__proto_length_cache', Valtype.i32);
       const pointerLocal = localTmp(scope, '__proto_pointer_cache', Valtype.i32);
-      const getPointer = [ [ Opcodes.local_get, pointerLocal ] ];
 
       // TODO: long-term, prototypes should be their individual separate funcs
 
+      const rawPointer = [
+        ...generate(scope, target),
+        Opcodes.i32_to_u
+      ];
+
+      const usePointerCache = !Object.values(protoCands).every(x => x.noPointerCache === true);
+      const getPointer = usePointerCache ? [ [ Opcodes.local_get, pointerLocal ] ] : rawPointer;
+
+      let allOptUnused = true;
       let lengthI32CacheUsed = false;
       const protoBC = {};
       for (const x in protoCands) {
@@ -1457,7 +1593,7 @@ const generateCall = (scope, decl, _global, _name) => {
             ...RTArrayUtil.getLength(getPointer),
 
             ...number(TYPES.number, Valtype.i32),
-            [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ],
+            setLastType(scope)
           ];
           continue;
         }
@@ -1467,6 +1603,7 @@ const generateCall = (scope, decl, _global, _name) => {
         const protoLocal = protoFunc.local ? localTmp(scope, `__${protoName}_tmp`, protoFunc.local) : -1;
         const protoLocal2 = protoFunc.local2 ? localTmp(scope, `__${protoName}_tmp2`, protoFunc.local2) : -1;
 
+        let optUnused = false;
         const protoOut = protoFunc(getPointer, {
           getCachedI32: () => {
             lengthI32CacheUsed = true;
@@ -1481,23 +1618,30 @@ const generateCall = (scope, decl, _global, _name) => {
           return makeArray(scope, {
             rawElements: new Array(length)
           }, _global, _name, true, itemType);
+        }, () => {
+          optUnused = true;
+          return unusedValue;
         });
 
+        if (!optUnused) allOptUnused = false;
+
         protoBC[x] = [
-          [ Opcodes.block, valtypeBinary ],
+          [ Opcodes.block, unusedValue && optUnused ? Blocktype.void : valtypeBinary ],
           ...protoOut,
 
           ...number(protoFunc.returnType ?? TYPES.number, Valtype.i32),
-          [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ],
+          setLastType(scope),
           [ Opcodes.end ]
         ];
       }
 
-      return [
-        ...generate(scope, target),
+      // todo: if some cands use optUnused and some don't, we will probably crash
 
-        Opcodes.i32_to_u,
-        [ Opcodes.local_set, pointerLocal ],
+      return [
+        ...(usePointerCache ? [
+          ...rawPointer,
+          [ Opcodes.local_set, pointerLocal ],
+        ] : []),
 
         ...(!lengthI32CacheUsed ? [] : [
           ...RTArrayUtil.getLengthI32(getPointer),
@@ -1509,7 +1653,7 @@ const generateCall = (scope, decl, _global, _name) => {
 
           // TODO: error better
           default: internalThrow(scope, 'TypeError', `'${protoName}' proto func tried to be called on a type without an impl`)
-        }, valtypeBinary),
+        }, allOptUnused && unusedValue ? Blocktype.void : valtypeBinary),
       ];
     }
   }
@@ -1548,6 +1692,32 @@ const generateCall = (scope, decl, _global, _name) => {
     idx = -1;
   }
 
+  if (idx === undefined && name.startsWith('__Porffor_wasm_')) {
+    const wasmOps = {
+      // pointer, align, offset
+      i32_load8_u: { imms: 2, args: 1 },
+      // pointer, value, align, offset
+      i32_store8: { imms: 2, args: 2 },
+    };
+
+    const opName = name.slice('__Porffor_wasm_'.length);
+
+    if (wasmOps[opName]) {
+      const op = wasmOps[opName];
+
+      const argOut = [];
+      for (let i = 0; i < op.args; i++) argOut.push(...generate(scope, decl.arguments[i]));
+
+      // literals only
+      const imms = decl.arguments.slice(op.args).map(x => x.value);
+
+      return [
+        ...argOut,
+        [ Opcodes[opName], ...imms ]
+      ];
+    }
+  }
+
   if (idx === undefined) {
     if (scope.locals[name] !== undefined || globals[name] !== undefined || builtinVars[name] !== undefined) return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`);
     return internalThrow(scope, 'ReferenceError', `${unhackName(name)} is not defined`);
@@ -1556,7 +1726,9 @@ const generateCall = (scope, decl, _global, _name) => {
   const func = funcs.find(x => x.index === idx);
 
   const userFunc = (funcIndex[name] && !importedFuncs[name] && !builtinFuncs[name] && !internalConstrs[name]) || idx === -1;
-  const paramCount = func && (userFunc ? func.params.length / 2 : func.params.length);
+  const typedParams = userFunc || builtinFuncs[name]?.typedParams;
+  const typedReturns = userFunc || builtinFuncs[name]?.typedReturns;
+  const paramCount = func && (typedParams ? func.params.length / 2 : func.params.length);
 
   let args = decl.arguments;
   if (func && args.length < paramCount) {
@@ -1572,14 +1744,20 @@ const generateCall = (scope, decl, _global, _name) => {
   if (func && func.throws) scope.throws = true;
 
   let out = [];
-  for (const arg of args) {
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
     out = out.concat(generate(scope, arg));
-    if (userFunc) out = out.concat(getNodeType(scope, arg));
+
+    if (builtinFuncs[name] && builtinFuncs[name].params[i] === Valtype.i32 && valtypeBinary !== Valtype.i32) {
+      out.push(Opcodes.i32_to);
+    }
+
+    if (typedParams) out = out.concat(getNodeType(scope, arg));
   }
 
   out.push([ Opcodes.call, idx ]);
 
-  if (!userFunc) {
+  if (!typedReturns) {
     // let type;
     // if (builtinFuncs[name]) type = TYPES[builtinFuncs[name].returnType ?? 'number'];
     // if (internalConstrs[name]) type = internalConstrs[name].type;
@@ -1589,7 +1767,11 @@ const generateCall = (scope, decl, _global, _name) => {
     //   ...number(type, Valtype.i32),
     //   [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ]
     // );
-  } else out.push([ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ]);
+  } else out.push(setLastType(scope));
+
+  if (builtinFuncs[name] && builtinFuncs[name].returns[0] === Valtype.i32 && valtypeBinary !== Valtype.i32) {
+    out.push(Opcodes.i32_from);
+  }
 
   return out;
 };
@@ -1614,9 +1796,118 @@ const unhackName = name => {
   return name;
 };
 
+const knownType = (scope, type) => {
+  if (type.length === 1 && type[0][0] === Opcodes.i32_const) {
+    return type[0][1];
+  }
+
+  if (typedInput && type.length === 1 && type[0][0] === Opcodes.local_get) {
+    const idx = type[0][1];
+
+    // type idx = var idx + 1
+    const v = Object.values(scope.locals).find(x => x.idx === idx - 1);
+    if (v.metadata?.type != null) return v.metadata.type;
+  }
+
+  return null;
+};
+
+const brTable = (input, bc, returns) => {
+  const out = [];
+  const keys = Object.keys(bc);
+  const count = keys.length;
+
+  if (count === 1) {
+    // return [
+    //   ...input,
+    //   ...bc[keys[0]]
+    // ];
+    return bc[keys[0]];
+  }
+
+  if (count === 2) {
+    // just use if else
+    const other = keys.find(x => x !== 'default');
+    return [
+      ...input,
+      ...number(other, Valtype.i32),
+      [ Opcodes.i32_eq ],
+      [ Opcodes.if, returns ],
+      ...bc[other],
+      [ Opcodes.else ],
+      ...bc.default,
+      [ Opcodes.end ]
+    ];
+  }
+
+  for (let i = 0; i < count; i++) {
+    if (i === 0) out.push([ Opcodes.block, returns, 'br table start' ]);
+      else out.push([ Opcodes.block, Blocktype.void ]);
+  }
+
+  const nums = keys.filter(x => +x);
+  const offset = Math.min(...nums);
+  const max = Math.max(...nums);
+
+  const table = [];
+  let br = 1;
+
+  for (let i = offset; i <= max; i++) {
+    // if branch for this num, go to that block
+    if (bc[i]) {
+      table.push(br);
+      br++;
+      continue;
+    }
+
+    // else default
+    table.push(0);
+  }
+
+  out.push(
+    [ Opcodes.block, Blocktype.void ],
+    ...input,
+    ...(offset > 0 ? [
+      ...number(offset, Valtype.i32),
+      [ Opcodes.i32_sub ]
+    ] : []),
+    [ Opcodes.br_table, ...encodeVector(table), 0 ]
+  );
+
+  // if you can guess why we sort the wrong way and then reverse
+  // (instead of just sorting the correct way)
+  // dm me and if you are correct and the first person
+  // I will somehow shout you out or something
+  const orderedBc = keys.sort((a, b) => b - a).reverse();
+
+  br = count - 1;
+  for (const x of orderedBc) {
+    out.push(
+      [ Opcodes.end ],
+      ...bc[x],
+      ...(br === 0 ? [] : [ [ Opcodes.br, br ] ])
+    );
+    br--;
+  }
+
+  return [
+    ...out,
+    [ Opcodes.end, 'br table end' ]
+  ];
+};
+
 const typeSwitch = (scope, type, bc, returns = valtypeBinary) => {
-  const tmp = localTmp(scope, '#typeswitch_tmp', Valtype.i32);
+  if (!Prefs.bytestring) delete bc[TYPES._bytestring];
 
+  const known = knownType(scope, type);
+  if (known != null) {
+    return bc[known] ?? bc.default;
+  }
+
+  if (Prefs.typeswitchUseBrtable)
+    return brTable(type, bc, returns);
+
+  const tmp = localTmp(scope, '#typeswitch_tmp', Valtype.i32);
   const out = [
     ...type,
     [ Opcodes.local_set, tmp ],
@@ -1648,7 +1939,7 @@ const typeSwitch = (scope, type, bc, returns = valtypeBinary) => {
   return out;
 };
 
-const allocVar = (scope, name, global = false) => {
+const allocVar = (scope, name, global = false, type = true) => {
   const target = global ? globals : scope.locals;
 
   // already declared
@@ -1662,12 +1953,60 @@ const allocVar = (scope, name, global = false) => {
   let idx = global ? globalInd++ : scope.localInd++;
   target[name] = { idx, type: valtypeBinary };
 
-  let typeIdx = global ? globalInd++ : scope.localInd++;
-  target[name + '#type'] = { idx: typeIdx, type: Valtype.i32 };
+  if (type) {
+    let typeIdx = global ? globalInd++ : scope.localInd++;
+    target[name + '#type'] = { idx: typeIdx, type: Valtype.i32 };
+  }
 
   return idx;
 };
 
+const addVarMetadata = (scope, name, global = false, metadata = {}) => {
+  const target = global ? globals : scope.locals;
+
+  target[name].metadata ??= {};
+  for (const x in metadata) {
+    if (metadata[x] != null) target[name].metadata[x] = metadata[x];
+  }
+};
+
+const typeAnnoToPorfType = x => {
+  if (TYPES[x]) return TYPES[x];
+  if (TYPES['_' + x]) return TYPES['_' + x];
+
+  switch (x) {
+    case 'i32':
+    case 'i64':
+      return TYPES.number;
+  }
+
+  return null;
+};
+
+const extractTypeAnnotation = decl => {
+  let a = decl;
+  while (a.typeAnnotation) a = a.typeAnnotation;
+
+  let type, elementType;
+  if (a.typeName) {
+    type = a.typeName.name;
+  } else if (a.type.endsWith('Keyword')) {
+    type = a.type.slice(2, -7).toLowerCase();
+  } else if (a.type === 'TSArrayType') {
+    type = 'array';
+    elementType = extractTypeAnnotation(a.elementType).type;
+  }
+
+  const typeName = type;
+  type = typeAnnoToPorfType(type);
+
+  if (type === TYPES._bytestring && !Prefs.bytestring) type = TYPES.string;
+
+  // if (decl.name) console.log(decl.name, { type, elementType });
+
+  return { type, typeName, elementType };
+};
+
 const generateVar = (scope, decl) => {
   let out = [];
 
@@ -1679,6 +2018,8 @@ const generateVar = (scope, decl) => {
   for (const x of decl.declarations) {
     const name = mapName(x.id.name);
 
+    if (!name) return todo('destructuring is not supported yet');
+
     if (x.init && isFuncType(x.init.type)) {
       // hack for let a = function () { ... }
       x.init.id = { name };
@@ -1694,7 +2035,12 @@ const generateVar = (scope, decl) => {
       continue; // always ignore
     }
 
-    let idx = allocVar(scope, name, global);
+    let idx = allocVar(scope, name, global, !x.id.typeAnnotation);
+
+    if (typedInput && x.id.typeAnnotation) {
+      addVarMetadata(scope, name, global, extractTypeAnnotation(x.id));
+    }
+
     if (x.init) {
       out = out.concat(generate(scope, x.init, global, name));
 
@@ -1709,7 +2055,8 @@ const generateVar = (scope, decl) => {
   return out;
 };
 
-const generateAssign = (scope, decl) => {
+// todo: optimize this func for valueUnused
+const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
   const { type, name } = decl.left;
 
   if (type === 'ObjectPattern') {
@@ -1812,6 +2159,8 @@ const generateAssign = (scope, decl) => {
     ];
   }
 
+  if (!name) return todo('destructuring is not supported yet');
+
   const [ local, isGlobal ] = lookupName(scope, name);
 
   if (local === undefined) {
@@ -1858,9 +2207,7 @@ const generateAssign = (scope, decl) => {
       ], getType(scope, name), getNodeType(scope, decl.right), isGlobal, name, true),
       [ isGlobal ? Opcodes.global_get : Opcodes.local_get, local.idx ],
 
-      [ Opcodes.local_get, localTmp(scope, '#last_type', Valtype.i32) ],
-      // hack: type is idx+1
-      [ isGlobal ? Opcodes.global_set : Opcodes.local_set, local.idx + 1 ],
+      ...setType(scope, name, getLastType(scope))
     ];
   }
 
@@ -1871,9 +2218,7 @@ const generateAssign = (scope, decl) => {
 
     // todo: string concat types
 
-    // hack: type is idx+1
-    ...number(TYPES.number, Valtype.i32),
-    [ isGlobal ? Opcodes.global_set : Opcodes.local_set, local.idx + 1 ],
+    ...setType(scope, name, TYPES.number)
   ];
 };
 
@@ -1950,6 +2295,8 @@ const generateUnary = (scope, decl) => {
         [TYPES.undefined]: makeString(scope, 'undefined', false, '#typeof_result'),
         [TYPES.function]: makeString(scope, 'function', false, '#typeof_result'),
 
+        [TYPES._bytestring]: makeString(scope, 'string', false, '#typeof_result'),
+
         // object and internal types
         default: makeString(scope, 'object', false, '#typeof_result'),
       });
@@ -1959,7 +2306,7 @@ const generateUnary = (scope, decl) => {
   }
 };
 
-const generateUpdate = (scope, decl) => {
+const generateUpdate = (scope, decl, _global, _name, valueUnused = false) => {
   const { name } = decl.argument;
 
   const [ local, isGlobal ] = lookupName(scope, name);
@@ -1972,7 +2319,7 @@ const generateUpdate = (scope, decl) => {
   const out = [];
 
   out.push([ isGlobal ? Opcodes.global_get : Opcodes.local_get, idx ]);
-  if (!decl.prefix) out.push([ isGlobal ? Opcodes.global_get : Opcodes.local_get, idx ]);
+  if (!decl.prefix && !valueUnused) out.push([ isGlobal ? Opcodes.global_get : Opcodes.local_get, idx ]);
 
   switch (decl.operator) {
     case '++':
@@ -1985,7 +2332,7 @@ const generateUpdate = (scope, decl) => {
   }
 
   out.push([ isGlobal ? Opcodes.global_set : Opcodes.local_set, idx ]);
-  if (decl.prefix) out.push([ isGlobal ? Opcodes.global_get : Opcodes.local_get, idx ]);
+  if (decl.prefix && !valueUnused) out.push([ isGlobal ? Opcodes.global_get : Opcodes.local_get, idx ]);
 
   return out;
 };
@@ -2025,7 +2372,7 @@ const generateConditional = (scope, decl) => {
   // note type
   out.push(
     ...getNodeType(scope, decl.consequent),
-    [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ]
+    setLastType(scope)
   );
 
   out.push([ Opcodes.else ]);
@@ -2034,7 +2381,7 @@ const generateConditional = (scope, decl) => {
   // note type
   out.push(
     ...getNodeType(scope, decl.alternate),
-    [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ]
+    setLastType(scope)
   );
 
   out.push([ Opcodes.end ]);
@@ -2048,15 +2395,17 @@ const generateFor = (scope, decl) => {
   const out = [];
 
   if (decl.init) {
-    out.push(...generate(scope, decl.init));
+    out.push(...generate(scope, decl.init, false, undefined, true));
     disposeLeftover(out);
   }
 
   out.push([ Opcodes.loop, Blocktype.void ]);
   depth.push('for');
 
-  out.push(...generate(scope, decl.test));
-  out.push(Opcodes.i32_to, [ Opcodes.if, Blocktype.void ]);
+  if (decl.test) out.push(...generate(scope, decl.test), Opcodes.i32_to);
+    else out.push(...number(1, Valtype.i32));
+
+  out.push([ Opcodes.if, Blocktype.void ]);
   depth.push('if');
 
   out.push([ Opcodes.block, Blocktype.void ]);
@@ -2064,8 +2413,7 @@ const generateFor = (scope, decl) => {
   out.push(...generate(scope, decl.body));
   out.push([ Opcodes.end ]);
 
-  out.push(...generate(scope, decl.update));
-  depth.pop();
+  if (decl.update) out.push(...generate(scope, decl.update, false, undefined, true));
 
   out.push([ Opcodes.br, 1 ]);
   out.push([ Opcodes.end ], [ Opcodes.end ]);
@@ -2122,7 +2470,13 @@ const generateForOf = (scope, decl) => {
   // setup local for left
   generate(scope, decl.left);
 
-  const leftName = decl.left.declarations[0].id.name;
+  let leftName = decl.left.declarations?.[0]?.id?.name;
+  if (!leftName && decl.left.name) {
+    leftName = decl.left.name;
+
+    generateVar(scope, { kind: 'var', _bare: true, declarations: [ { id: { name: leftName } } ] })
+  }
+
   const [ local, isGlobal ] = lookupName(scope, leftName);
 
   depth.push('block');
@@ -2131,13 +2485,14 @@ 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.f64), newPointer = -1;
-  if (pages.hasString) {
+  if (pages.hasAnyString) {
     0, [ newOut, newPointer ] = makeArray(scope, {
       rawElements: new Array(1)
     }, isGlobal, leftName, true, 'i16');
   }
 
   // set type for local
+  // todo: optimize away counter and use end pointer
   out.push(...typeSwitch(scope, getNodeType(scope, decl.right), {
     [TYPES._array]: [
       ...setType(scope, leftName, TYPES.number),
@@ -2262,7 +2617,7 @@ const generateThrow = (scope, decl) => {
   // 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;
+    message = decl.argument.arguments[0]?.value ?? '';
   }
 
   if (tags.length === 0) tags.push({
@@ -2274,6 +2629,9 @@ const generateThrow = (scope, decl) => {
   let exceptId = exceptions.push({ constructor, message }) - 1;
   let tagIdx = tags[0].idx;
 
+  scope.exceptions ??= [];
+  scope.exceptions.push(exceptId);
+
   // todo: write a description of how this works lol
 
   return [
@@ -2318,25 +2676,31 @@ const generateAssignPat = (scope, decl) => {
 };
 
 let pages = new Map();
-const allocPage = (reason, type) => {
+const allocPage = (scope, reason, type) => {
   if (pages.has(reason)) return pages.get(reason).ind;
 
   if (reason.startsWith('array:')) pages.hasArray = true;
   if (reason.startsWith('string:')) pages.hasString = true;
+  if (reason.startsWith('bytestring:')) pages.hasByteString = true;
+  if (reason.includes('string:')) pages.hasAnyString = true;
 
   const ind = pages.size;
   pages.set(reason, { ind, type });
 
-  if (allocLog) log('alloc', `allocated new page of memory (${ind}) | ${reason} (type: ${type})`);
+  scope.pages ??= new Map();
+  scope.pages.set(reason, { ind, type });
+
+  if (Prefs.allocLog) log('alloc', `allocated new page of memory (${ind}) | ${reason} (type: ${type})`);
 
   return ind;
 };
 
+// todo: add scope.pages
 const freePage = reason => {
   const { ind } = pages.get(reason);
   pages.delete(reason);
 
-  if (allocLog) log('alloc', `freed page of memory (${ind}) | ${reason}`);
+  if (Prefs.allocLog) log('alloc', `freed page of memory (${ind}) | ${reason}`);
 
   return ind;
 };
@@ -2356,25 +2720,34 @@ const StoreOps = {
   f64: Opcodes.f64_store,
 
   // expects i32 input!
-  i16: Opcodes.i32_store16
+  i8: Opcodes.i32_store8,
+  i16: Opcodes.i32_store16,
 };
 
 let data = [];
 
-const compileBytes = (val, itemType, signed = true) => {
+const compileBytes = (val, itemType) => {
   // todo: this is a mess and needs confirming / ????
   switch (itemType) {
     case 'i8': return [ val % 256 ];
-    case 'i16': return [ val % 256, Math.floor(val / 256) ];
-
-    case 'i32':
-    case 'i64':
-      return enforceFourBytes(signedLEB128(val));
+    case 'i16': return [ val % 256, (val / 256 | 0) % 256 ];
+    case 'i16': return [ val % 256, (val / 256 | 0) % 256 ];
+    case 'i32': return [...new Uint8Array(new Int32Array([ val ]).buffer)];
+    // todo: i64
 
     case 'f64': return ieee754_binary64(val);
   }
 };
 
+const getAllocType = itemType => {
+  switch (itemType) {
+    case 'i8': return 'bytestring';
+    case 'i16': return 'string';
+
+    default: return 'array';
+  }
+};
+
 const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty = false, itemType = valtype) => {
   const out = [];
 
@@ -2384,7 +2757,7 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
 
     // todo: can we just have 1 undeclared array? probably not? but this is not really memory efficient
     const uniqueName = name === '$undeclared' ? name + Math.random().toString().slice(2) : name;
-    arrays.set(name, allocPage(`${itemType === 'i16' ? 'string' : 'array'}: ${uniqueName}`, itemType) * pageSize);
+    arrays.set(name, allocPage(scope, `${getAllocType(itemType)}: ${uniqueName}`, itemType) * pageSize);
   }
 
   const pointer = arrays.get(name);
@@ -2395,19 +2768,25 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
   const valtype = itemTypeToValtype[itemType];
   const length = elements.length;
 
-  if (firstAssign && useRawElements) {
-    let bytes = compileBytes(length, 'i32');
+  if (firstAssign && useRawElements && !Prefs.noData) {
+    // if length is 0 memory/data will just be 0000... anyway
+    if (length !== 0) {
+      let bytes = compileBytes(length, 'i32');
 
-    if (!initEmpty) for (let i = 0; i < length; i++) {
-      if (elements[i] == null) continue;
+      if (!initEmpty) for (let i = 0; i < length; i++) {
+        if (elements[i] == null) continue;
 
-      bytes.push(...compileBytes(elements[i], itemType));
-    }
+        bytes.push(...compileBytes(elements[i], itemType));
+      }
 
-    data.push({
-      offset: pointer,
-      bytes
-    });
+      const ind = data.push({
+        offset: pointer,
+        bytes
+      }) - 1;
+
+      scope.data ??= [];
+      scope.data.push(ind);
+    }
 
     // local value as pointer
     out.push(...number(pointer));
@@ -2430,7 +2809,7 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
     out.push(
       ...number(0, Valtype.i32),
       ...(useRawElements ? number(elements[i], Valtype[valtype]) : generate(scope, elements[i])),
-      [ storeOp, Math.log2(ValtypeSize[itemType]) - 1, ...unsignedLEB128(pointer + ValtypeSize.i32 + i * ValtypeSize[itemType]) ]
+      [ storeOp, (Math.log2(ValtypeSize[itemType]) || 1) - 1, ...unsignedLEB128(pointer + ValtypeSize.i32 + i * ValtypeSize[itemType]) ]
     );
   }
 
@@ -2440,15 +2819,31 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
   return [ out, pointer ];
 };
 
-const makeString = (scope, str, global = false, name = '$undeclared') => {
+const byteStringable = str => {
+  if (!Prefs.bytestring) return false;
+
+  for (let i = 0; i < str.length; i++) {
+    if (str.charCodeAt(i) > 0xFF) return false;
+  }
+
+  return true;
+};
+
+const makeString = (scope, str, global = false, name = '$undeclared', forceBytestring = undefined) => {
   const rawElements = new Array(str.length);
+  let byteStringable = Prefs.bytestring;
   for (let i = 0; i < str.length; i++) {
-    rawElements[i] = str.charCodeAt(i);
+    const c = str.charCodeAt(i);
+    rawElements[i] = c;
+
+    if (byteStringable && c > 0xFF) byteStringable = false;
   }
 
+  if (byteStringable && forceBytestring === false) byteStringable = false;
+
   return makeArray(scope, {
     rawElements
-  }, global, name, false, 'i16')[0];
+  }, global, name, false, byteStringable ? 'i8' : 'i16')[0];
 };
 
 let arrays = new Map();
@@ -2476,10 +2871,13 @@ export const generateMember = (scope, decl, _global, _name) => {
     ];
   }
 
+  const object = generate(scope, decl.object);
+  const property = generate(scope, decl.property);
+
   // // 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.f64), newPointer = -1;
-  if (pages.hasString) {
+  let newOut = number(0, valtypeBinary), newPointer = -1;
+  if (pages.hasAnyString) {
     0, [ newOut, newPointer ] = makeArray(scope, {
       rawElements: new Array(1)
     }, _global, _name, true, 'i16');
@@ -2488,7 +2886,7 @@ export const generateMember = (scope, decl, _global, _name) => {
   return typeSwitch(scope, getNodeType(scope, decl.object), {
     [TYPES._array]: [
       // get index as valtype
-      ...generate(scope, decl.property),
+      ...property,
 
       // convert to i32 and turn into byte offset by * valtypeSize (4 for i32, 8 for i64/f64)
       Opcodes.i32_to_u,
@@ -2496,7 +2894,7 @@ export const generateMember = (scope, decl, _global, _name) => {
       [ Opcodes.i32_mul ],
 
       ...(aotPointer ? [] : [
-        ...generate(scope, decl.object),
+        ...object,
         Opcodes.i32_to_u,
         [ Opcodes.i32_add ]
       ]),
@@ -2505,7 +2903,7 @@ export const generateMember = (scope, decl, _global, _name) => {
       [ Opcodes.load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ],
 
       ...number(TYPES.number, Valtype.i32),
-      [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ]
+      setLastType(scope)
     ],
 
     [TYPES.string]: [
@@ -2515,14 +2913,14 @@ export const generateMember = (scope, decl, _global, _name) => {
 
       ...number(0, Valtype.i32), // base 0 for store later
 
-      ...generate(scope, decl.property),
-
+      ...property,
       Opcodes.i32_to_u,
+
       ...number(ValtypeSize.i16, Valtype.i32),
       [ Opcodes.i32_mul ],
 
       ...(aotPointer ? [] : [
-        ...generate(scope, decl.object),
+        ...object,
         Opcodes.i32_to_u,
         [ Opcodes.i32_add ]
       ]),
@@ -2537,10 +2935,38 @@ export const generateMember = (scope, decl, _global, _name) => {
       ...number(newPointer),
 
       ...number(TYPES.string, Valtype.i32),
-      [ Opcodes.local_set, localTmp(scope, '#last_type', Valtype.i32) ]
+      setLastType(scope)
+    ],
+    [TYPES._bytestring]: [
+      // setup new/out array
+      ...newOut,
+      [ Opcodes.drop ],
+
+      ...number(0, Valtype.i32), // base 0 for store later
+
+      ...property,
+      Opcodes.i32_to_u,
+
+      ...(aotPointer ? [] : [
+        ...object,
+        Opcodes.i32_to_u,
+        [ Opcodes.i32_add ]
+      ]),
+
+      // load current string ind {arg}
+      [ Opcodes.i32_load8_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128((aotPointer ? pointer : 0) + ValtypeSize.i32) ],
+
+      // store to new string ind 0
+      [ Opcodes.i32_store8, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
+
+      // return new string (page)
+      ...number(newPointer),
+
+      ...number(TYPES._bytestring, Valtype.i32),
+      setLastType(scope)
     ],
 
-    default: [ [ Opcodes.unreachable ] ]
+    default: internalThrow(scope, 'TypeError', 'Member expression is not supported for non-string non-array yet')
   });
 };
 
@@ -2557,13 +2983,16 @@ const objectHack = node => {
     // if object is not identifier or another member exp, give up
     if (node.object.type !== 'Identifier' && node.object.type !== 'MemberExpression') return node;
 
-    if (!objectName) objectName = objectHack(node.object).name.slice(2);
+    if (!objectName) objectName = objectHack(node.object)?.name?.slice?.(2);
 
     // if .length, give up (hack within a hack!)
     if (node.property.name === 'length') return node;
 
+    // no object name, give up
+    if (!objectName) return node;
+
     const name = '__' + objectName + '_' + node.property.name;
-    if (codeLog) log('codegen', `object hack! ${node.object.name}.${node.property.name} -> ${name}`);
+    if (Prefs.codeLog) log('codegen', `object hack! ${node.object.name}.${node.property.name} -> ${name}`);
 
     return {
       type: 'Identifier',
@@ -2586,7 +3015,7 @@ const generateFunc = (scope, decl) => {
   if (decl.generator) return todo('generator functions are not supported');
 
   const name = decl.id ? decl.id.name : `anonymous_${randId()}`;
-  const params = decl.params?.map(x => x.name) ?? [];
+  const params = decl.params ?? [];
 
   // const innerScope = { ...scope };
   // TODO: share scope/locals between !!!
@@ -2600,7 +3029,11 @@ const generateFunc = (scope, decl) => {
   };
 
   for (let i = 0; i < params.length; i++) {
-    allocVar(innerScope, params[i], false);
+    allocVar(innerScope, params[i].name, false);
+
+    if (typedInput && params[i].typeAnnotation) {
+      addVarMetadata(innerScope, params[i].name, false, extractTypeAnnotation(params[i]));
+    }
   }
 
   let body = objectHack(decl.body);
@@ -2616,13 +3049,13 @@ const generateFunc = (scope, decl) => {
   const func = {
     name,
     params: Object.values(innerScope.locals).slice(0, params.length * 2).map(x => x.type),
-    returns: innerScope.returns,
-    locals: innerScope.locals,
-    throws: innerScope.throws,
-    index: currentFuncIndex++
+    index: currentFuncIndex++,
+    ...innerScope
   };
   funcIndex[name] = func.index;
 
+  if (name === 'main') func.gotLastType = true;
+
   // quick hack fixes
   for (const inst of wasm) {
     if (inst[0] === Opcodes.call && inst[1] === -1) {
@@ -2639,117 +3072,6 @@ const generateFunc = (scope, decl) => {
     );
   }
 
-  // change v128 params into many <type> (i32x4 -> i32/etc) instead as unsupported param valtype
-  let offset = 0, vecParams = 0;
-  for (let i = 0; i < params.length; i++) {
-    const name = params[i];
-    const local = func.locals[name];
-    if (local.type === Valtype.v128) {
-      vecParams++;
-
-      /* wasm.unshift( // add v128 load for param
-        [ Opcodes.i32_const, 0 ],
-        [ ...Opcodes.v128_load, 0, i * 16 ],
-        [ Opcodes.local_set, local.idx ]
-      ); */
-
-      // using params and replace_lane is noticably faster than just loading from memory (above) somehow
-
-      // extract valtype and lane count from vec type (i32x4 = i32 4, i8x16 = i8 16, etc)
-      const { vecType } = local;
-      let [ type, lanes ] = vecType.split('x');
-      if (!type || !lanes) throw new Error('bad metadata from vec params'); // sanity check
-
-      lanes = parseInt(lanes);
-      type = Valtype[type];
-
-      const name = params[i]; // get original param name
-
-      func.params.splice(offset, 1, ...new Array(lanes).fill(type)); // add new params of {type}, {lanes} times
-
-      // update index of original local
-      // delete func.locals[name];
-
-      // add new locals for params
-      for (let j = 0; j < lanes; j++) {
-        func.locals[name + j] = { idx: offset + j, type, vecParamAutogen: true };
-      }
-
-      // prepend wasm to generate expected v128 locals
-      wasm.splice(i * 2 + offset * 2, 0,
-        ...i32x4(0, 0, 0, 0),
-        ...new Array(lanes).fill(0).flatMap((_, j) => [
-          [ Opcodes.local_get, offset + j ],
-          [ ...Opcodes[vecType + '_replace_lane'], j ]
-        ]),
-        [ Opcodes.local_set, i ]
-      );
-
-      offset += lanes;
-
-      // note: wrapping is disabled for now due to perf/dx concerns (so this will never run)
-      /* if (!func.name.startsWith('#')) func.name = '##' + func.name;
-
-      // add vec type index to hash name prefix for wrapper to know how to wrap
-      const vecTypeIdx = [ 'i8x16', 'i16x8', 'i32x4', 'i64x2', 'f32x4', 'f64x2' ].indexOf(local.vecType);
-      const secondHash = func.name.slice(1).indexOf('#');
-      func.name = '#' + func.name.slice(1, secondHash) + vecTypeIdx + func.name.slice(secondHash); */
-    }
-  }
-
-  if (offset !== 0) {
-    // bump local indexes for all other locals after
-    for (const x in func.locals) {
-      const local = func.locals[x];
-      if (!local.vecParamAutogen) local.idx += offset;
-    }
-
-    // bump local indexes in wasm local.get/set
-    for (let j = 0; j < wasm.length; j++) {
-      const inst = wasm[j];
-      if (j < offset * 2 + vecParams * 2) {
-        if (inst[0] === Opcodes.local_set) inst[1] += offset;
-        continue;
-      }
-
-      if (inst[0] === Opcodes.local_get || inst[0] === Opcodes.local_set) inst[1] += offset;
-    }
-  }
-
-  // change v128 return into many <type> instead as unsupported return valtype
-  const lastReturnLocal = wasm.length > 2 && wasm[wasm.length - 1][0] === Opcodes.return && Object.values(func.locals).find(x => x.idx === wasm[wasm.length - 2][1]);
-  if (lastReturnLocal && lastReturnLocal.type === Valtype.v128) {
-    const name = Object.keys(func.locals)[Object.values(func.locals).indexOf(lastReturnLocal)];
-    // extract valtype and lane count from vec type (i32x4 = i32 4, i8x16 = i8 16, etc)
-    const { vecType } = lastReturnLocal;
-    let [ type, lanes ] = vecType.split('x');
-    if (!type || !lanes) throw new Error('bad metadata from vec params'); // sanity check
-
-    lanes = parseInt(lanes);
-    type = Valtype[type];
-
-    const vecIdx = lastReturnLocal.idx;
-
-    const lastIdx = Math.max(0, ...Object.values(func.locals).map(x => x.idx));
-    const tmpIdx = [];
-    for (let i = 0; i < lanes; i++) {
-      const idx = lastIdx + i + 1;
-      tmpIdx.push(idx);
-      func.locals[name + i] = { idx, type, vecReturnAutogen: true };
-    }
-
-    wasm.splice(wasm.length - 1, 1,
-      ...new Array(lanes).fill(0).flatMap((_, i) => [
-        i === 0 ? null : [ Opcodes.local_get, vecIdx ],
-        [ ...Opcodes[vecType + '_extract_lane'], i ],
-        [ Opcodes.local_set, tmpIdx[i] ],
-      ].filter(x => x !== null)),
-      ...new Array(lanes).fill(0).map((_, i) => [ Opcodes.local_get, tmpIdx[i]])
-    );
-
-    func.returns = new Array(lanes).fill(type);
-  }
-
   func.wasm = wasm;
 
   funcs.push(func);
@@ -2768,6 +3090,16 @@ const generateCode = (scope, decl) => {
 };
 
 const internalConstrs = {
+  Boolean: {
+    generate: (scope, decl) => {
+      if (decl.arguments.length === 0) return number(0);
+
+      // should generate/run all args
+      return truthy(scope, generate(scope, decl.arguments[0]), getNodeType(scope, decl.arguments[0]), false, false);
+    },
+    type: TYPES.boolean
+  },
+
   Array: {
     generate: (scope, decl, global, name) => {
       // new Array(i0, i1, ...)
@@ -2889,7 +3221,7 @@ export default program => {
     body: program.body
   };
 
-  if (process.argv.includes('-ast-log')) console.log(program.body.body);
+  if (Prefs.astLog) console.log(program.body.body);
 
   generateFunc(scope, program);