porffor 0.20.5 → 0.20.7

package/compiler/assemble.js

@@ -154,7 +154,7 @@ export default (funcs, globals, tags, pages, data, flags, noTreeshake = false) =
     encodeVector([ [
       0x00,
       Opcodes.i32_const, 0, Opcodes.end,
-      ...encodeVector(funcs.map(x => x.index))
+      ...encodeVector(funcs.map(x => unsignedLEB128(x.index)))
     ] ])
   );
 

package/compiler/builtins/array.ts

@@ -36,6 +36,13 @@ export const __Array_from = (arg: any, mapFn: any): any[] => {
   return out;
 };
 
+export const __Porffor_fastPush = (_this: any[], el: any) => {
+  let len: i32 = _this.length;
+  _this[len] = el;
+  _this.length = ++len;
+  return len;
+};
+
 export const __Array_prototype_push = (_this: any[], ...items: any[]) => {
   let len: i32 = _this.length;
   const itemsLen: i32 = items.length;

package/compiler/builtins/object.ts

@@ -1,8 +1,143 @@
 import type {} from './porffor.d.ts';
 
+export const __Object_keys = (obj: any): any[] => {
+  if (obj == null) throw new TypeError('Argument is nullish, expected object');
+
+  const out: any[] = Porffor.allocate();
+
+  const t: i32 = Porffor.rawType(obj);
+  if (t == Porffor.TYPES.object) {
+    const keys: Set = Porffor.wasm.i32.load(obj, 0, 0);
+    const size: i32 = Porffor.wasm.i32.load(keys, 0, 0);
+    out.length = size;
+
+    for (let i: i32 = 0; i < size; i++) {
+      out[i] = Porffor.set.read(keys, i);
+    }
+  } else if (Porffor.fastOr(
+    t == Porffor.TYPES.array,
+    t == Porffor.TYPES.bytestring,
+    t == Porffor.TYPES.string
+  )) {
+    const len: i32 = obj.length;
+    out.length = len;
+
+    for (let i: i32 = 0; i < len; i++) {
+      out[i] = __Number_prototype_toString(i);
+    }
+  }
+
+  return out;
+};
+
+export const __Object_values = (obj: any): any[] => {
+  if (obj == null) throw new TypeError('Argument is nullish, expected object');
+
+  const out: any[] = Porffor.allocate();
+
+  const t: i32 = Porffor.rawType(obj);
+  if (t == Porffor.TYPES.object) {
+    const size: i32 = Porffor.wasm.i32.load(Porffor.wasm.i32.load(obj, 0, 0), 0, 0);
+    const vals: any[] = Porffor.wasm.i32.load(obj, 0, 4);
+
+    out.length = size;
+    for (let i: i32 = 0; i < size; i++) {
+      out[i] = vals[i];
+    }
+  } else if (Porffor.fastOr(
+    t == Porffor.TYPES.array,
+    t == Porffor.TYPES.bytestring,
+    t == Porffor.TYPES.string
+  )) {
+    const len: i32 = obj.length;
+    out.length = len;
+
+    for (let i: i32 = 0; i < len; i++) {
+      out[i] = obj[i];
+    }
+  }
+
+  return out;
+};
+
+export const __Object_entries = (obj: any): any[] => {
+  const out: any[] = Porffor.allocate();
+
+  const keys: any[] = __Object_keys(obj);
+  const vals: any[] = __Object_values(obj);
+
+  const size: i32 = keys.length;
+  out.length = size;
+
+  for (let i: i32 = 0; i < size; i++) {
+    // what is memory efficiency anyway?
+    const entry: any[] = Porffor.allocate();
+
+    entry.length = 2;
+    entry[0] = keys[i];
+    entry[1] = vals[i];
+
+    out[i] = entry;
+  }
+
+  return out;
+};
+
+export const __Object_fromEntries = (iterable: any): object => {
+  const out: object = {};
+
+  for (const x of iterable) {
+    if (Porffor.rawType(x) < 0x06) throw new TypeError('Iterator contains non-object');
+    out[ecma262.ToPropertyKey(x[0])] = x[1];
+  }
+
+  return out;
+};
+
+
+export const __Object_prototype_hasOwnProperty = (_this: any, prop: any) => {
+  const p: any = ecma262.ToPropertyKey(prop);
+
+  const t: i32 = Porffor.rawType(_this);
+  if (t == Porffor.TYPES.object) {
+    const keys: Set = Porffor.wasm.i32.load(_this, 0, 0);
+    return __Set_prototype_has(keys, p);
+  }
+
+  const keys: any[] = __Object_keys(_this);
+  return __Array_prototype_includes(keys, p);
+};
+
+export const __Object_hasOwn = (obj: any, prop: any) => {
+  // todo: not spec compliant lol
+  return __Object_prototype_hasOwnProperty(obj, prop);
+};
+
+
+export const __Object_assign = (target: any, ...sources: any[]) => {
+  if (target == null) throw new TypeError('Argument is nullish, expected object');
+
+  for (const x of sources) {
+    const keys: any[] = __Object_keys(x);
+    const vals: any[] = __Object_values(x);
+
+    const len: i32 = keys.length;
+    for (let i: i32 = 0; i < len; i++) {
+      target[keys[i]] = vals[i];
+    }
+  }
+
+  return target;
+};
+
+
 export const __Object_prototype_toString = (_this: object) => {
   let out: bytestring = '[object Object]';
   return out;
 };
 
-export const __Object_prototype_toLocaleString = (_this: object) => __Object_prototype_toLocaleString(_this);
+export const __Object_prototype_toLocaleString = (_this: object) => __Object_prototype_toLocaleString(_this);
+
+export const __Object_prototype_valueOf = (_this: object) => {
+  return _this;
+};

package/compiler/builtins/porffor.d.ts

@@ -81,6 +81,7 @@ declare global {
   const ecma262: {
     ToIntegerOrInfinity(argument: unknown): number;
     ToString(argument: unknown): bytestring;
+    ToPropertyKey(argument: unknown): any;
   }
 
   const print: (arg: any) => void;

package/compiler/builtins/set.ts

@@ -76,7 +76,7 @@ export const __Set_prototype_values = (_this: Set) => {
   const out: any[] = __Porffor_allocate();
   for (let i: number = 0; i < size; i++) {
     const val: any = __Porffor_set_read(_this, i);
-    out.push(val);
+    Porffor.fastPush(out, val);
   }
 
   return out;
@@ -184,10 +184,7 @@ export const Set = function (iterable: any): Set {
 
   const out: Set = __Porffor_allocate();
 
-  if (Porffor.fastAnd(
-    Porffor.rawType(iterable) != Porffor.TYPES.undefined,
-    iterable !== null
-  )) for (const x of iterable) {
+  if (iterable != null) for (const x of iterable) {
     __Set_prototype_add(out, x);
   }
 

package/compiler/builtins/symbol.ts

@@ -17,12 +17,7 @@ export const Symbol = (description: any): Symbol => {
   }
 
   // 4. Return a new Symbol whose [[Description]] is descString.
-  let len: i32 = descStore.length;
-  descStore[len] = descString;
-  descStore.length = ++len;
-
-  // 1-based so always truthy as numeric value
-  const sym: Symbol = len;
+  const sym: Symbol = Porffor.fastPush(descStore, descString);
   return sym;
 };
 

package/compiler/builtins/weakref.ts

@@ -3,7 +3,7 @@ import type {} from './porffor.d.ts';
 export const WeakRef = function (target: any): WeakRef {
   if (!new.target) throw new TypeError("Constructor WeakRef requires 'new'");
 
-  if (Porffor.rawType(target) < 0x04) throw new TypeError('Target for WeakRef needs to be an object or symbol');
+  if (Porffor.rawType(target) < 0x05) throw new TypeError('Target for WeakRef needs to be an object or symbol');
 
   const out: WeakRef = Porffor.allocateBytes(9);
 

package/compiler/builtins/z_ecma262.ts

@@ -62,4 +62,20 @@ export const __ecma262_ToString = (argument: unknown): bytestring => {
   // 11. Assert: primValue is not an Object.
   // 12. Return ? ToString(primValue).
   return argument.toString();
+};
+
+// 7.1.19 ToPropertyKey (argument)
+// https://tc39.es/ecma262/#sec-topropertykey
+export const __ecma262_ToPropertyKey = (argument: any): any => {
+  // 1. Let key be ? ToPrimitive(argument, string).
+  const key: any = argument;
+
+  // 2. If key is a Symbol, then
+  if (Porffor.rawType(key) == Porffor.TYPES.symbol) {
+    // a. Return key.
+    return key;
+  }
+
+  // 3. Return ! ToString(key).
+  return __ecma262_ToString(key);
 };

package/compiler/builtins/z_map.ts

@@ -40,7 +40,7 @@ export const __Map_prototype_set = (_this: Map, key: any, value: any) => {
   Porffor.wasm.i32.store(keys, size + 1, 0, 0);
 
   // write new key at end
-  __Porffor_set_write(keys, size, key);
+  Porffor.set.write(keys, size, key);
 
   // write new value at end
   vals[size] = value;
@@ -97,10 +97,8 @@ export const Map = function (iterable: any): Map {
   const vals: any[] = Porffor.allocate();
   Porffor.wasm.i32.store(out, vals, 0, 4);
 
-  if (Porffor.fastAnd(
-    Porffor.rawType(iterable) != Porffor.TYPES.undefined,
-    iterable !== null
-  )) for (const x of iterable) {
+  if (iterable != null) for (const x of iterable) {
+    if (Porffor.rawType(x) < 0x06) throw new TypeError('Iterator contains non-object');
     __Map_prototype_set(out, x[0], x[1]);
   }
 
@@ -112,18 +110,19 @@ export const __Map_prototype_keys = (_this: Map) => {
   const out: any[] = Porffor.allocate();
 
   for (const x of keys) {
-    out.push(x);
+    Porffor.fastPush(out, x);
   }
 
   return out;
 };
 
 export const __Map_prototype_values = (_this: Map) => {
-  const vals: Set = Porffor.wasm.i32.load(_this, 0, 4);
+  const size: i32 = Porffor.wasm.i32.load(Porffor.wasm.i32.load(_this, 0, 0), 0, 0);
+  const vals: any[] = Porffor.wasm.i32.load(_this, 0, 4);
   const out: any[] = Porffor.allocate();
 
-  for (const x of vals) {
-    out.push(x);
+  for (let i: i32 = 0; i < size; i++) {
+    Porffor.fastPush(out, vals[i]);
   }
 
   return out;

package/compiler/builtins/z_weakmap.ts

@@ -3,7 +3,7 @@ import type {} from './porffor.d.ts';
 export const __WeakMap_prototype_has = (_this: WeakMap, key: any) => __Map_prototype_has(_this, key);
 
 export const __WeakMap_prototype_set = (_this: WeakMap, key: any, value: any) => {
-  if (Porffor.rawType(key) < 0x04) throw new TypeError('Value in WeakSet needs to be an object or symbol');
+  if (Porffor.rawType(key) < 0x05) throw new TypeError('Value in WeakSet needs to be an object or symbol');
 
   __Map_prototype_set(_this, key, value);
   return _this;
@@ -22,10 +22,8 @@ export const WeakMap = function (iterable: any): WeakMap {
   const vals: any[] = Porffor.allocate();
   Porffor.wasm.i32.store(out, vals, 0, 4);
 
-  if (Porffor.fastAnd(
-    Porffor.rawType(iterable) != Porffor.TYPES.undefined,
-    iterable !== null
-  )) for (const x of iterable) {
+  if (iterable != null) for (const x of iterable) {
+    if (Porffor.rawType(x) < 0x06) throw new TypeError('Iterator contains non-object');
     __WeakMap_prototype_set(out, x[0], x[1]);
   }
 

package/compiler/builtins/z_weakset.ts

@@ -3,7 +3,7 @@ import type {} from './porffor.d.ts';
 export const __WeakSet_prototype_has = (_this: WeakSet, value: any) => __Set_prototype_has(_this, value);
 
 export const __WeakSet_prototype_add = (_this: WeakSet, value: any) => {
-  if (Porffor.rawType(value) < 0x04) throw new TypeError('Value in WeakSet needs to be an object or symbol');
+  if (Porffor.rawType(value) < 0x05) throw new TypeError('Value in WeakSet needs to be an object or symbol');
 
   __Set_prototype_add(_this, value);
   return _this;
@@ -16,10 +16,7 @@ export const WeakSet = function (iterable: any): WeakSet {
 
   const out: WeakSet = __Porffor_allocate();
 
-  if (Porffor.fastAnd(
-    Porffor.rawType(iterable) != Porffor.TYPES.undefined,
-    iterable !== null
-  )) for (const x of iterable) {
+  if (iterable != null) for (const x of iterable) {
     __WeakSet_prototype_add(out, x);
   }
 

package/compiler/codegen.js

@@ -713,7 +713,7 @@ const truthy = (scope, wasm, type, intIn = false, intOut = false, forceTruthyMod
     if (truthyMode === 'full') return [
       // if value != 0 or NaN
       ...(!useTmp ? [] : [ [ Opcodes.local_get, tmp ] ]),
-      ...(intIn ? [ ] : [ Opcodes.i32_to ]),
+      ...(intIn ? [] : [ Opcodes.i32_to ]),
 
       [ Opcodes.i32_eqz ],
       [ Opcodes.i32_eqz ],
@@ -820,6 +820,7 @@ const nullish = (scope, wasm, type, intIn = false, intOut = false) => {
     ...typeSwitch(scope, type, {
       [TYPES.undefined]: [
         // undefined
+        ...(!useTmp ? [ [ Opcodes.drop ] ] : []),
         ...number(1, intOut ? Valtype.i32 : valtypeBinary)
       ],
       [TYPES.object]: [
@@ -831,6 +832,7 @@ const nullish = (scope, wasm, type, intIn = false, intOut = false) => {
       ],
       default: [
         // not
+        ...(!useTmp ? [ [ Opcodes.drop ] ] : []),
         ...number(0, intOut ? Valtype.i32 : valtypeBinary)
       ]
     }, intOut ? Valtype.i32 : valtypeBinary)
@@ -1082,6 +1084,13 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
   ]);
 };
 
+const knownNullish = decl => {
+  if (decl.type === 'Literal' && decl.value === null) return true;
+  if (decl.type === 'Identifier' && decl.name === 'undefined') return true;
+
+  return false;
+};
+
 const generateBinaryExp = (scope, decl, _global, _name) => {
   if (decl.operator === 'instanceof') {
     // very hacky basic instanceof
@@ -1110,8 +1119,24 @@ const generateBinaryExp = (scope, decl, _global, _name) => {
     return out;
   }
 
-  const out = performOp(scope, decl.operator, generate(scope, decl.left), generate(scope, decl.right), getNodeType(scope, decl.left), getNodeType(scope, decl.right), _global, _name);
+  // opt: == null|undefined -> nullish
+  if (decl.operator === '==' || decl.operator === '!=') {
+    if (knownNullish(decl.right)) {
+      const out = nullish(scope, generate(scope, decl.left), getNodeType(scope, decl.left), false, true);
+      if (decl.operator === '!=') out.push([ Opcodes.i32_eqz ]);
+      out.push(Opcodes.i32_from_u);
+      return out;
+    }
 
+    if (knownNullish(decl.left)) {
+      const out = nullish(scope, generate(scope, decl.right), getNodeType(scope, decl.right), false, true);
+      if (decl.operator === '!=') out.push([ Opcodes.i32_eqz ]);
+      out.push(Opcodes.i32_from_u);
+      return out;
+    }
+  }
+
+  const out = performOp(scope, decl.operator, generate(scope, decl.left), generate(scope, decl.right), getNodeType(scope, decl.left), getNodeType(scope, decl.right), _global, _name);
   if (valtype !== 'i32' && ['==', '===', '!=', '!==', '>', '>=', '<', '<='].includes(decl.operator)) out.push(Opcodes.i32_from_u);
 
   return out;
@@ -1307,7 +1332,7 @@ const isExistingProtoFunc = name => {
 const getType = (scope, _name) => {
   const name = mapName(_name);
 
-  // if (scope.locals[name] && !scope.locals[name + '#type']) console.log(name);
+  if (Object.hasOwn(builtinVars, name)) return number(builtinVars[name].type ?? TYPES.number, Valtype.i32);
 
   if (typedInput && scope.locals[name]?.metadata?.type != null) return number(scope.locals[name].metadata.type, Valtype.i32);
   if (Object.hasOwn(scope.locals, name)) return [ [ Opcodes.local_get, scope.locals[name + '#type'].idx ] ];
@@ -1315,13 +1340,13 @@ const getType = (scope, _name) => {
   if (typedInput && globals[name]?.metadata?.type != null) return number(globals[name].metadata.type, Valtype.i32);
   if (Object.hasOwn(globals, name)) return [ [ Opcodes.global_get, globals[name + '#type'].idx ] ];
 
-  let type = TYPES.undefined;
-  if (Object.hasOwn(builtinVars, name)) type = builtinVars[name].type ?? TYPES.number;
-  if (Object.hasOwn(builtinFuncs, name) || Object.hasOwn(importedFuncs, name) || Object.hasOwn(funcIndex, name) || Object.hasOwn(internalConstrs, name)) type = TYPES.function;
+  if (Object.hasOwn(builtinFuncs, name) || Object.hasOwn(importedFuncs, name) ||
+      Object.hasOwn(funcIndex, name) || Object.hasOwn(internalConstrs, name))
+        return number(TYPES.function, Valtype.i32);
 
-  if (isExistingProtoFunc(name)) type = TYPES.function;
+  if (isExistingProtoFunc(name)) return number(TYPES.function, Valtype.i32);
 
-  return number(type, Valtype.i32);
+  return number(TYPES.undefined, Valtype.i32);
 };
 
 const setType = (scope, _name, type) => {
@@ -1563,7 +1588,6 @@ const generateLiteral = (scope, decl, global, name) => {
       return number(decl.value);
 
     case 'boolean':
-      // hack: bool as int (1/0)
       return number(decl.value ? 1 : 0);
 
     case 'string':
@@ -2839,9 +2863,6 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
       value: decl.left.property.name
     };
 
-    includeBuiltin(scope, '__Map_prototype_get');
-    includeBuiltin(scope, '__Map_prototype_set');
-
     return [
       ...typeSwitch(scope, getNodeType(scope, decl.left.object), {
         [TYPES.array]: [
@@ -2879,23 +2900,26 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
           ...getNodeType(scope, object),
 
           ...generate(scope, property),
-          ...(op === '=' ? [] : [ [ Opcodes.local_tee, localTmp(scope, '#objset_property') ] ]),
           ...getNodeType(scope, property),
+          ...toPropertyKey(scope),
+          ...(op === '=' ? [] : [ [ Opcodes.local_set, localTmp(scope, '#objset_property_type', Valtype.i32) ] ]),
+          ...(op === '=' ? [] : [ [ Opcodes.local_tee, localTmp(scope, '#objset_property') ] ]),
+          ...(op === '=' ? [] : [ [ Opcodes.local_get, localTmp(scope, '#objset_property_type', Valtype.i32) ] ]),
 
           ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
             [ Opcodes.local_get, localTmp(scope, '#objset_object') ],
             ...getNodeType(scope, object),
 
             [ Opcodes.local_get, localTmp(scope, '#objset_property') ],
-            ...getNodeType(scope, property),
+            [ Opcodes.local_get, localTmp(scope, '#objset_property_type', Valtype.i32) ],
 
-            [ Opcodes.call, ...unsignedLEB128(funcIndex.__Map_prototype_get) ],
+            [ Opcodes.call, ...unsignedLEB128(includeBuiltin(scope, '__Map_prototype_get').index) ],
             ...setLastType(scope)
           ], generate(scope, decl.right), getLastType(scope), getNodeType(scope, decl.right), false, name, true)),
           [ Opcodes.local_tee, newValueTmp ],
           ...getNodeType(scope, decl),
 
-          [ Opcodes.call, ...unsignedLEB128(funcIndex.__Map_prototype_set) ],
+          [ Opcodes.call, ...unsignedLEB128(includeBuiltin(scope, '__Map_prototype_set').index) ],
           [ Opcodes.drop ],
 
           ...setLastType(scope, getNodeType(scope, decl)),
@@ -3406,16 +3430,22 @@ const generateForOf = (scope, decl) => {
     // get length
     [ Opcodes.local_get, pointer ],
     [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
-    [ Opcodes.local_set, length ]
+    [ Opcodes.local_tee, length ],
+
+    [ Opcodes.if, Blocktype.void ]
   );
 
+  depth.push('if');
   depth.push('forof');
+  depth.push('block');
+  depth.push('block');
 
   // setup local for left
   generate(scope, decl.left);
 
   let leftName = decl.left.declarations?.[0]?.id?.name;
   if (!leftName && decl.left.name) {
+    // todo: should be sloppy mode only
     leftName = decl.left.name;
 
     generateVar(scope, { kind: 'var', _bare: true, declarations: [ { id: { name: leftName } } ] })
@@ -3426,9 +3456,6 @@ const generateForOf = (scope, decl) => {
   const [ local, isGlobal ] = lookupName(scope, leftName);
   if (!local) return todo(scope, 'for of failed to get left local (probably destructure)');
 
-  depth.push('block');
-  depth.push('block');
-
   // // 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);
@@ -3571,12 +3598,6 @@ const generateForOf = (scope, decl) => {
       ...generate(scope, decl.body),
       [ Opcodes.end ],
 
-      // increment iter pointer
-      // [ Opcodes.local_get, pointer ],
-      // ...number(1, Valtype.i32),
-      // [ Opcodes.i32_add ],
-      // [ Opcodes.local_set, pointer ],
-
       // increment counter by 1
       [ Opcodes.local_get, counter ],
       ...number(1, Valtype.i32),
@@ -3734,6 +3755,8 @@ const generateForOf = (scope, decl) => {
     default: internalThrow(scope, 'TypeError', `Tried for..of on non-iterable type`)
   }, Blocktype.void));
 
+  out.push([ Opcodes.end ]); // end if
+
   depth.pop();
   depth.pop();
   depth.pop();
@@ -4310,9 +4333,12 @@ const generateArray = (scope, decl, global = false, name = '$undeclared', initEm
   return makeArray(scope, decl, global, name, initEmpty, valtype, false, true)[0];
 };
 
+const toPropertyKey = scope => Prefs.fastObject ? [] : [
+  [ Opcodes.call, ...unsignedLEB128(includeBuiltin(scope, '__ecma262_ToPropertyKey').index) ]
+];
+
 const generateObject = (scope, decl, global = false, name = '$undeclared') => {
   includeBuiltin(scope, 'Map');
-  includeBuiltin(scope, '__Map_prototype_set');
 
   // todo: optimize const objects
   const tmp = localTmp(scope, `#objectexpr${randId()}`);
@@ -4332,7 +4358,8 @@ const generateObject = (scope, decl, global = false, name = '$undeclared') => {
     const { method, shorthand, computed, kind, key, value } = x;
     if (kind !== 'init') return todo(scope, 'complex objects are not supported yet', true);
 
-    const k = computed ? key : {
+    let k = key;
+    if (!computed && key.type !== 'Literal') k = {
       type: 'Literal',
       value: key.name
     };
@@ -4343,11 +4370,12 @@ const generateObject = (scope, decl, global = false, name = '$undeclared') => {
 
       ...generate(scope, k),
       ...getNodeType(scope, k),
+      ...toPropertyKey(scope),
 
       ...generate(scope, value),
       ...getNodeType(scope, value),
 
-      [ Opcodes.call, ...unsignedLEB128(funcIndex.__Map_prototype_set) ],
+      [ Opcodes.call, ...unsignedLEB128(includeBuiltin(scope, '__Map_prototype_set').index) ],
 
       [ Opcodes.drop ],
       [ Opcodes.drop ]
@@ -4503,8 +4531,6 @@ const generateMember = (scope, decl, _global, _name) => {
     }, _global, _name, true, 'i16', true);
   }
 
-  includeBuiltin(scope, '__Map_prototype_get');
-
   const out = typeSwitch(scope, getNodeType(scope, object), {
     [TYPES.array]: [
       ...loadArray(scope, objectWasm, propertyWasm),
@@ -4580,8 +4606,9 @@ const generateMember = (scope, decl, _global, _name) => {
 
       ...propertyWasm,
       ...getNodeType(scope, property),
+      ...toPropertyKey(scope),
 
-      [ Opcodes.call, ...unsignedLEB128(funcIndex.__Map_prototype_get) ],
+      [ Opcodes.call, ...unsignedLEB128(includeBuiltin(scope, '__Map_prototype_get').index) ],
       ...setLastType(scope)
     ],