porffor 0.2.0-fdf0fc5 → 0.14.0-4e46400a9

package/compiler/builtins/set.ts

@@ -1,5 +1,187 @@
-// @porf --funsafe-no-unlikely-proto-checks
+// dark wasm magic for dealing with memory, sorry.
+export const __Porffor_allocate = (): number => {
+  Porffor.wasm`i32.const 1
+memory.grow 0
+drop
+memory.size 0
+i32.const 1
+i32.sub
+i32.const 65536
+i32.mul
+i32.from_u
+return`;
+};
 
-export const Set = (iterable: any): Set => {
+export const __Porffor_set_read = (_this: Set, index: number): any => {
+  Porffor.wasm`
+local offset i32
+local.get ${index}
+i32.to_u
+i32.const 9
+i32.mul
+local.get ${_this}
+i32.to_u
+i32.add
+local.set offset
 
+local.get offset
+f64.load 0 4
+
+local.get offset
+i32.load8_u 0 12
+return`;
+};
+
+export const __Porffor_set_write = (_this: Set, index: number, value: any): boolean => {
+  Porffor.wasm`
+local offset i32
+local.get ${index}
+i32.to_u
+i32.const 9
+i32.mul
+local.get ${_this}
+i32.to_u
+i32.add
+local.set offset
+
+local.get offset
+local.get ${value}
+f64.store 0 4
+
+local.get offset
+local.get ${value+1}
+i32.store8 0 12`;
+
+  return true;
+};
+
+
+// todo: this should be a getter somehow not a method
+export const __Set_prototype_size = (_this: Set) => {
+  return Porffor.wasm.i32.load(_this, 0, 0);
+};
+
+export const __Set_prototype_values = (_this: Set) => {
+  // todo: this should return an iterator not array
+  const size: number = __Set_prototype_size(_this);
+
+  const out: any[] = __Porffor_allocate();
+  for (let i: number = 0; i < size; i++) {
+    const val: any = __Porffor_set_read(_this, i);
+    out.push(val);
+  }
+
+  return out;
+};
+
+export const __Set_prototype_keys = (_this: Set) => {
+  return __Set_prototype_values(_this);
+};
+
+export const __Set_prototype_has = (_this: Set, value: any) => {
+  const size: number = __Set_prototype_size(_this);
+
+  for (let i: number = 0; i < size; i++) {
+    if (__Porffor_set_read(_this, i) === value) return true;
+  }
+
+  return false;
+};
+
+export const __Set_prototype_add = (_this: Set, value: any) => {
+  const size: number = __Set_prototype_size(_this);
+
+  // check if already in set
+  for (let i: number = 0; i < size; i++) {
+    if (__Porffor_set_read(_this, i) === value) return _this;
+  }
+
+  // not, add it
+  // increment size by 1
+  Porffor.wasm.i32.store(_this, size + 1, 0, 0);
+
+  // write new value at end
+  __Porffor_set_write(_this, size, value);
+
+  return _this;
+};
+
+export const __Set_prototype_delete = (_this: Set, value: any) => {
+  const size: number = __Set_prototype_size(_this);
+
+  // check if already in set
+  for (let i: number = 0; i < size; i++) {
+    if (__Porffor_set_read(_this, i) === value) {
+      // found, delete
+      // decrement size by 1
+      Porffor.wasm.i32.store(_this, size - 1, 0, 0);
+
+      // offset all elements after by -1 ind
+      Porffor.wasm`
+local offset i32
+local.get ${i}
+i32.to_u
+i32.const 9
+i32.mul
+local.get ${_this}
+i32.to_u
+i32.add
+i32.const 4
+i32.add
+local.set offset
+
+;; dst = offset (this element)
+local.get offset
+
+;; src = offset + 9 (this element + 1 element)
+local.get offset
+i32.const 9
+i32.add
+
+;; size = (size - i - 1) * 9
+local.get ${size}
+local.get ${i}
+f64.sub
+i32.to_u
+i32.const 1
+i32.sub
+i32.const 9
+i32.mul
+
+memory.copy 0 0`;
+
+      return true;
+    }
+  }
+
+  // not, return false
+  return false;
+};
+
+export const __Set_prototype_clear = (_this: Set) => {
+  // just set size to 0
+  // do not need to delete any as will not be accessed anymore,
+  // and will be overwritten with new add
+  Porffor.wasm.i32.store(_this, 0, 0, 0);
+};
+
+export const Set = () => {
+  throw new TypeError("Constructor Set requires 'new'");
+};
+
+export const Set$constructor = (iterable: any): Set => {
+  const out: Set = __Porffor_allocate();
+
+  const type: number = Porffor.rawType(iterable);
+  if (Porffor.fastOr(
+    type == Porffor.TYPES.array,
+    type == Porffor.TYPES.string, type == Porffor.TYPES.bytestring,
+    type == Porffor.TYPES.set
+  )) {
+    for (const x of iterable) {
+      __Set_prototype_add(out, x);
+    }
+  }
+
+  return out;
 };

package/compiler/builtins/string.ts

@@ -1,4 +1,4 @@
-// @porf --funsafe-no-unlikely-proto-checks --valtype=i32
+// @porf --valtype=i32
 
 export const __String_fromCharCode = (code: i32) => {
   // todo: support >1 arg

package/compiler/builtins.js

@@ -1,8 +1,8 @@
-import { Blocktype, Opcodes, Valtype, ValtypeSize } from "./wasmSpec.js";
-import { number, i32x4 } from "./embedding.js";
-import Prefs from './prefs.js';
 import * as GeneratedBuiltins from './generated_builtins.js';
+import { Blocktype, Opcodes, Valtype, ValtypeSize } from './wasmSpec.js';
+import { number } from './embedding.js';
 import { TYPES } from './types.js';
+import Prefs from './prefs.js';
 
 export const importedFuncs = [
   {
@@ -48,8 +48,6 @@ for (let i = 0; i < importedFuncs.length; i++) {
   importedFuncs[f.name] = i;
 }
 
-const char = c => number(c.charCodeAt(0));
-
 const printStaticStr = str => {
   const out = [];
 
@@ -140,7 +138,7 @@ export const BuiltinVars = function() {
   this.Math = number(1);
 
   // wintercg(tm)
-  this.__navigator_userAgent = (scope, { makeString }) => makeString(scope, `Porffor/0.2.0`, false, '__navigator_userAgent');
+  this.__navigator_userAgent = (scope, { makeString }) => makeString(scope, `Porffor/0.14.0`, false, '__navigator_userAgent');
   this.__navigator_userAgent.type = Prefs.bytestring ? TYPES.bytestring : TYPES.string;
 
   for (const x in TYPES) {
@@ -569,7 +567,6 @@ export const BuiltinFuncs = function() {
 
   // this is an implementation of xorshift128+ (in wasm bytecode)
   // fun fact: v8, SM, JSC also use this (you will need this fun fact to maintain your sanity reading this code)
-  // const prngSeed0 = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER), prngSeed1 = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER);
   const prngSeed0 = (Math.random() * (2 ** 30)) | 0, prngSeed1 = (Math.random() * (2 ** 30)) | 0;
 
   const prng = ({

package/compiler/codegen.js

@@ -1,14 +1,14 @@
-import { Blocktype, Opcodes, Valtype, PageSize, ValtypeSize } from "./wasmSpec.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";
-import { number, i32x4, enforceOneByte, enforceTwoBytes, enforceFourBytes, enforceEightBytes } from "./embedding.js";
-import { log } from "./log.js";
-import parse from "./parse.js";
-import * as Rhemyn from "../rhemyn/compile.js";
-import Prefs from './prefs.js';
+import { Blocktype, Opcodes, Valtype, PageSize, ValtypeSize } from './wasmSpec.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';
+import { number } from './embedding.js';
 import { TYPES, TYPE_NAMES } from './types.js';
+import * as Rhemyn from '../rhemyn/compile.js';
+import parse from './parse.js';
+import { log } from './log.js';
+import Prefs from './prefs.js';
 
 let globals = {};
 let globalInd = 0;
@@ -19,24 +19,6 @@ let funcIndex = {};
 let currentFuncIndex = importedFuncs.length;
 let builtinFuncs = {}, builtinVars = {}, prototypeFuncs = {};
 
-const debug = str => {
-  const code = [];
-
-  const logChar = n => {
-    code.push(...number(n));
-
-    code.push([ Opcodes.call, 0 ]);
-  };
-
-  for (let i = 0; i < str.length; i++) {
-    logChar(str.charCodeAt(i));
-  }
-
-  logChar(10); // new line
-
-  return code;
-};
-
 class TodoError extends Error {
   constructor(message) {
     super(message);
@@ -76,10 +58,11 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
 
     case 'ArrowFunctionExpression':
     case 'FunctionDeclaration':
+    case 'FunctionExpression':
       const func = generateFunc(scope, decl);
 
       if (decl.type.endsWith('Expression')) {
-        return number(func.index);
+        return number(func.index - importedFuncs.length);
       }
 
       return [];
@@ -171,11 +154,6 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
         newFunc.export = true;
       }
 
-      // if (funcsBefore === funcs.length) throw new Error('no new func added in export');
-
-      // const newFunc = funcs[funcs.length - 1];
-      // newFunc.export = true;
-
       return [];
 
     case 'TaggedTemplateExpression': {
@@ -210,7 +188,7 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
             if (!Array.isArray(inst)) inst = [ inst ];
             const immediates = asm.slice(1).map(x => {
               const int = parseInt(x);
-              if (Number.isNaN(int)) return scope.locals[x]?.idx;
+              if (Number.isNaN(int)) return scope.locals[x]?.idx ?? globals[x].idx;
               return int;
             });
 
@@ -336,10 +314,10 @@ const generateIdent = (scope, decl) => {
 
     if (local?.idx === undefined) {
       // no local var with name
-      if (Object.hasOwn(importedFuncs, name)) return number(importedFuncs[name]);
-      if (Object.hasOwn(funcIndex, name)) return number(funcIndex[name]);
-
       if (Object.hasOwn(globals, name)) return [ [ Opcodes.global_get, globals[name].idx ] ];
+
+      if (Object.hasOwn(importedFuncs, name)) return number(importedFuncs[name] - importedFuncs.length);
+      if (Object.hasOwn(funcIndex, name)) return number(funcIndex[name] - importedFuncs.length);
     }
 
     if (local?.idx === undefined && rawName.startsWith('__')) {
@@ -858,31 +836,6 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
 
   // if strict (in)equal check types match
   if (strictOp) {
-    // startOut.push(
-    //   ...leftType,
-    //   ...rightType,
-    //   [ Opcodes.i32_eq ]
-    // );
-
-    // endOut.push(
-    //   [ Opcodes.i32_and ]
-    // );
-
-    // startOut.push(
-    //   [ Opcodes.block, Valtype.i32 ],
-    //   ...leftType,
-    //   ...rightType,
-    //   [ Opcodes.i32_ne ],
-    //   [ Opcodes.if, Blocktype.void ],
-    //   ...number(op === '===' ? 0 : 1, Valtype.i32),
-    //   [ Opcodes.br, 1 ],
-    //   [ Opcodes.end ]
-    // );
-
-    // endOut.push(
-    //   [ Opcodes.end ]
-    // );
-
     endOut.push(
       ...leftType,
       ...rightType,
@@ -1089,7 +1042,7 @@ const generateBinaryExp = (scope, decl, _global, _name) => {
 
 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,
+    TYPES, TYPE_NAMES, typeSwitch, makeArray, makeString, allocPage, internalThrow,
     builtin: name => {
       let idx = funcIndex[name] ?? importedFuncs[name];
       if (idx === undefined && builtinFuncs[name]) {
@@ -1248,7 +1201,7 @@ const setLastType = scope => {
 };
 
 const getNodeType = (scope, node) => {
-  const inner = () => {
+  const ret = (() => {
     if (node.type === 'Literal') {
       if (node.regex) return TYPES.regexp;
 
@@ -1291,7 +1244,6 @@ const getNodeType = (scope, node) => {
       const func = funcs.find(x => x.name === name);
 
       if (func) {
-        // console.log(scope, func, func.returnType);
         if (func.returnType) return func.returnType;
       }
 
@@ -1435,10 +1387,8 @@ const getNodeType = (scope, node) => {
     // presume
     // todo: warn here?
     return TYPES.number;
-  };
+  })();
 
-  const ret = inner();
-  // console.trace(node, ret);
   if (typeof ret === 'number') return number(ret, Valtype.i32);
   return ret;
 };
@@ -1577,15 +1527,6 @@ const RTArrayUtil = {
 };
 
 const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
-  /* const callee = decl.callee;
-  const args = decl.arguments;
-
-  return [
-    ...generate(args),
-    ...generate(callee),
-    Opcodes.call_indirect,
-  ]; */
-
   let name = mapName(decl.callee.name);
   if (isFuncType(decl.callee.type)) { // iife
     const func = generateFunc(scope, decl.callee);
@@ -1759,8 +1700,6 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
           continue;
         }
 
-        // const protoLocal = protoFunc.local ? localTmp(scope, `__${TYPE_NAMES[x]}_${protoName}_tmp`, protoFunc.local) : -1;
-        // const protoLocal2 = protoFunc.local2 ? localTmp(scope, `__${TYPE_NAMES[x]}_${protoName}_tmp2`, protoFunc.local2) : -1;
         const protoLocal = protoFunc.local ? localTmp(scope, `__${protoName}_tmp`, protoFunc.local) : -1;
         const protoLocal2 = protoFunc.local2 ? localTmp(scope, `__${protoName}_tmp2`, protoFunc.local2) : -1;
 
@@ -1837,22 +1776,6 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
 
     includeBuiltin(scope, name);
     idx = funcIndex[name];
-
-    // infer arguments types from builtins params
-    // const func = funcs.find(x => x.name === name);
-    // for (let i = 0; i < decl.arguments.length; i++) {
-    //   const arg = decl.arguments[i];
-    //   if (!arg.name) continue;
-
-    //   const local = scope.locals[arg.name];
-    //   if (!local) continue;
-
-    //   local.type = func.params[i];
-    //   if (local.type === Valtype.v128) {
-    //     // specify vec subtype inferred from last vec type in function name
-    //     local.vecType = name.split('_').reverse().find(x => x.includes('x'));
-    //   }
-    // }
   }
 
   if (idx === undefined && internalConstrs[name]) return internalConstrs[name].generate(scope, decl, _global, _name);
@@ -1909,7 +1832,23 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
   }
 
   if (idx === undefined) {
-    if (scope.locals[name] !== undefined || globals[name] !== undefined || builtinVars[name] !== undefined) return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, true);
+    if (scope.locals[name] !== undefined || globals[name] !== undefined || builtinVars[name] !== undefined) {
+      if (!Prefs.indirectCalls) return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, true);
+
+      const [ local, global ] = lookupName(scope, name);
+      funcs.table = true;
+
+      // todo: only works when:
+      //   1. arg count matches arg count of function
+      //   2. function uses typedParams and typedReturns
+      return typeSwitch(scope, getNodeType(decl.callee), {
+        [TYPES.function]: [
+          [ global ? Opcodes.global_get : Opcodes.local_get, local.idx ],
+          [ Opcodes.call_indirect ]
+        ],
+        default: internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, true)
+      });
+    }
     return internalThrow(scope, 'ReferenceError', `${unhackName(name)} is not defined`, true);
   }
 
@@ -1938,11 +1877,10 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     const arg = args[i];
     out = out.concat(generate(scope, arg));
 
-    if (builtinFuncs[name] && builtinFuncs[name].params[i * (typedParams ? 2 : 1)] === Valtype.i32 && valtypeBinary !== Valtype.i32) {
-      out.push(Opcodes.i32_to);
-    }
-
-    if (importedFuncs[name] && name.startsWith('profile')) {
+    if (valtypeBinary !== Valtype.i32 && (
+      (builtinFuncs[name] && builtinFuncs[name].params[i * (typedParams ? 2 : 1)] === Valtype.i32) ||
+      (importedFuncs[name] && name.startsWith('profile'))
+    )) {
       out.push(Opcodes.i32_to);
     }
 
@@ -2178,7 +2116,6 @@ const addVarMetadata = (scope, name, global = false, metadata = {}) => {
 const typeAnnoToPorfType = x => {
   if (!x) return null;
   if (TYPES[x.toLowerCase()] != null) return TYPES[x.toLowerCase()];
-  if (TYPES['_' + x.toLowerCase()] != null) return TYPES['_' + x.toLowerCase()];
 
   switch (x) {
     case 'i32':
@@ -2219,9 +2156,8 @@ const generateVar = (scope, decl) => {
 
   const topLevel = scope.name === 'main';
 
-  // global variable if in top scope (main) and var ..., or if wanted
-  const global = topLevel || decl._bare; // decl.kind === 'var';
-  const target = global ? globals : scope.locals;
+  // global variable if in top scope (main) or if internally wanted
+  const global = topLevel || decl._bare;
 
   for (const x of decl.declarations) {
     const name = mapName(x.id.name);
@@ -2235,7 +2171,6 @@ const generateVar = (scope, decl) => {
       continue;
     }
 
-    // console.log(name);
     if (topLevel && builtinVars[name]) {
       // cannot redeclare
       if (decl.kind !== 'var') return internalThrow(scope, 'SyntaxError', `Identifier '${unhackName(name)}' has already been declared`);
@@ -2255,6 +2190,22 @@ const generateVar = (scope, decl) => {
     }
 
     if (x.init) {
+      // if (isFuncType(x.init.type)) {
+      //   // let a = function () { ... }
+      //   x.init.id = { name };
+
+      //   const func = generateFunc(scope, x.init);
+
+      //   out.push(
+      //     ...number(func.index - importedFuncs.length),
+      //     [ global ? Opcodes.global_set : Opcodes.local_set, idx ],
+
+      //     ...setType(scope, name, TYPES.function)
+      //   );
+
+      //   continue;
+      // }
+
       const generated = generate(scope, x.init, global, name);
       if (scope.arrays?.get(name) != null) {
         // hack to set local as pointer before
@@ -2266,6 +2217,7 @@ const generateVar = (scope, decl) => {
         out = out.concat(generated);
         out.push([ global ? Opcodes.global_set : Opcodes.local_set, idx ]);
       }
+
       out.push(...setType(scope, name, getNodeType(scope, x.init)));
     }
 
@@ -2279,6 +2231,7 @@ const generateVar = (scope, decl) => {
 // todo: optimize this func for valueUnused
 const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
   const { type, name } = decl.left;
+  const [ local, isGlobal ] = lookupName(scope, name);
 
   if (type === 'ObjectPattern') {
     // hack: ignore object parts of `var a = {} = 2`
@@ -2288,8 +2241,18 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
   if (isFuncType(decl.right.type)) {
     // hack for a = function () { ... }
     decl.right.id = { name };
-    generateFunc(scope, decl.right);
-    return [];
+
+    const func = generateFunc(scope, decl.right);
+
+    return [
+      ...number(func.index - importedFuncs.length),
+      ...(local != null ? [
+        [ isGlobal ? Opcodes.global_set : Opcodes.local_set, local.idx ],
+        [ isGlobal ? Opcodes.global_get : Opcodes.local_get, local.idx ],
+
+        ...setType(scope, name, TYPES.function)
+      ] : [])
+    ];
   }
 
   const op = decl.operator.slice(0, -1) || '=';
@@ -2388,8 +2351,6 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
 
   if (!name) return todo(scope, 'destructuring is not supported yet', true);
 
-  const [ local, isGlobal ] = lookupName(scope, name);
-
   if (local === undefined) {
     // todo: this should be a sloppy mode only thing
 
@@ -3036,13 +2997,6 @@ const generateEmpty = (scope, decl) => {
   return [];
 };
 
-const generateAssignPat = (scope, decl) => {
-  // TODO
-  // if identifier declared, use that
-  // else, use default (right)
-  return todo(scope, 'assignment pattern (optional arg)');
-};
-
 let pages = new Map();
 const allocPage = (scope, reason, type) => {
   if (pages.has(reason)) return pages.get(reason).ind;
@@ -3455,8 +3409,11 @@ const generateFunc = (scope, decl) => {
   };
 
   if (typedInput && decl.returnType) {
-    innerScope.returnType = extractTypeAnnotation(decl.returnType).type;
-    innerScope.returns = [ valtypeBinary ];
+    const { type } = extractTypeAnnotation(decl.returnType);
+    if (type != null && !Prefs.indirectCalls) {
+      innerScope.returnType = type;
+      innerScope.returns = [ valtypeBinary ];
+    }
   }
 
   for (let i = 0; i < params.length; i++) {
@@ -3498,7 +3455,7 @@ const generateFunc = (scope, decl) => {
   if (name !== 'main' && wasm[wasm.length - 1]?.[0] !== Opcodes.return && countLeftover(wasm) === 0) {
     wasm.push(
       ...number(0),
-      ...number(TYPES.undefined, Valtype.i32),
+      ...(innerScope.returnType != null ? [] : number(TYPES.undefined, Valtype.i32)),
       [ Opcodes.return ]
     );
   }

package/compiler/decompile.js

@@ -1,5 +1,5 @@
-import { Blocktype, Opcodes, Valtype } from "./wasmSpec.js";
-import { read_ieee754_binary64, read_signedLEB128, read_unsignedLEB128 } from "./encoding.js";
+import { Blocktype, Opcodes, Valtype } from './wasmSpec.js';
+import { read_ieee754_binary64, read_signedLEB128, read_unsignedLEB128 } from './encoding.js';
 
 const inv = (obj, keyMap = x => x) => Object.keys(obj).reduce((acc, x) => { acc[keyMap(obj[x])] = x; return acc; }, {});
 const invOpcodes = inv(Opcodes);

package/compiler/embedding.js

@@ -1,5 +1,5 @@
-import { Opcodes, Valtype } from "./wasmSpec.js";
-import { signedLEB128, ieee754_binary64 } from "./encoding.js";
+import { Opcodes, Valtype } from './wasmSpec.js';
+import { signedLEB128, ieee754_binary64 } from './encoding.js';
 
 export const number = (n, valtype = valtypeBinary) => {
   switch (valtype) {

package/compiler/encoding.js

@@ -7,21 +7,7 @@ export const codifyString = str => {
   return out;
 };
 
-// export const encodeString = str => [
-//   str.length,
-//   ...codifyString(str)
-// ];
 export const encodeString = str => unsignedLEB128(str.length).concat(codifyString(str));
-
-// export const encodeVector = data => [
-//   ...unsignedLEB128(data.length),
-//   ...data.flat()
-// ];
-// export const encodeVector = data => {
-//   const out = data.flat();
-//   out.unshift.apply(out, unsignedLEB128(data.length));
-//   return out;
-// };
 export const encodeVector = data => unsignedLEB128(data.length).concat(data.flat());
 
 export const encodeLocal = (count, type) => [

package/compiler/expression.js

@@ -1,4 +1,4 @@
-import { Opcodes } from "./wasmSpec.js";
+import { Opcodes } from './wasmSpec.js';
 
 export const operatorOpcode = {
   i32: {