porffor 0.58.3 → 0.58.5

package/compiler/codegen.js

@@ -45,17 +45,23 @@ const funcRef = func => {
 
   const wrapperArgc = Prefs.indirectWrapperArgc ?? 10;
   if (!func.wrapperFunc) {
-    const locals = {}, params = [];
+    const locals = {
+      ['#length']: { idx: 0, type: Valtype.i32 }
+    }, params = [
+      Valtype.i32
+    ];
+
     for (let i = 0; i < wrapperArgc + 2; i++) {
       params.push(valtypeBinary, Valtype.i32);
-      locals[i * 2] = { idx: i * 2, type: valtypeBinary };
-      locals[i * 2 + 1] = { idx: i * 2 + 1, type: Valtype.i32 };
+      locals[`#${i}`] = { idx: 1 + i * 2, type: valtypeBinary };
+      locals[`#${i}#type`] = { idx: 2 + i * 2, type: Valtype.i32 };
     }
-    let localInd = (wrapperArgc + 2) * 2;
+    let localInd = 1 + (wrapperArgc + 2) * 2;
 
     if (indirectFuncs.length === 0) {
       // add empty indirect func
       const emptyFunc = {
+        constr: true, internal: true, indirect: true,
         name: '#indirect#empty',
         params,
         locals: { ...locals }, localInd,
@@ -64,9 +70,6 @@ const funcRef = func => {
           number(0),
           number(0, Valtype.i32)
         ],
-        constr: true,
-        internal: true,
-        indirect: true,
         wrapperOf: {
           name: '',
           jsLength: 0
@@ -76,7 +79,7 @@ const funcRef = func => {
 
       // check not being constructed
       emptyFunc.wasm.unshift(
-        [ Opcodes.local_get, 0 ], // new.target value
+        [ Opcodes.local_get, 1 ], // new.target value
         Opcodes.i32_to_u,
         [ Opcodes.if, Blocktype.void ], // if value is non-zero
           ...internalThrow(emptyFunc, 'TypeError', `Function is not a constructor`), // throw type error
@@ -88,27 +91,94 @@ const funcRef = func => {
     }
 
     const wasm = [];
-    const offset = func.constr ? 0 : (func.method ? 2 : 4);
-    for (let i = 0; i < func.params.length; i++) {
-      if (func.internal && func.name.includes('_prototype_') && i < 2) {
-        // special case: use real this for prototype internals
-        wasm.push(
-          [ Opcodes.local_get, 2 + i ],
-          ...(i % 2 === 0 && func.params[i] === Valtype.i32 ? [ Opcodes.i32_to ]: [])
-        );
-      } else {
+    const name = '#indirect_' + func.name;
+    const wrapperFunc = {
+      constr: true, internal: true, indirect: true,
+      name, params, locals, localInd,
+      returns: [ valtypeBinary, Valtype.i32 ],
+      wasm,
+      wrapperOf: func,
+      indirectIndex: indirectFuncs.length
+    };
+
+    indirectFuncs.push(wrapperFunc);
+
+    wrapperFunc.jsLength = countLength(func);
+    func.wrapperFunc = wrapperFunc;
+
+    const paramCount = countParams(func, name);
+    const args = [];
+    for (let i = 0; i < paramCount - (func.hasRestArgument ? 1 : 0); i++) {
+      args.push({
+        type: 'Identifier',
+        name: `#${i + 2}`
+      });
+    }
+
+    if (func.hasRestArgument) {
+      const array = (wrapperFunc.localInd += 2) - 2;
+      locals['#array#i32'] = { idx: array, type: Valtype.i32 };
+      locals['#array'] = { idx: array + 1, type: valtypeBinary };
+
+      wasm.push(
+        [ Opcodes.call, includeBuiltin(wrapperFunc, '__Porffor_allocate').index ],
+        [ Opcodes.local_tee, array ],
+        Opcodes.i32_from_u,
+        [ Opcodes.local_set, array + 1 ],
+
+        [ Opcodes.local_get, array ],
+        [ Opcodes.local_get, 0 ],
+        number(paramCount - 1, Valtype.i32),
+        [ Opcodes.i32_sub ],
+        [ Opcodes.i32_store, 0, 0 ]
+      );
+
+      let offset = 4;
+      for (let i = paramCount - 1; i < wrapperArgc; i++) {
         wasm.push(
-          [ Opcodes.local_get, offset + (!func.internal || func.typedParams ? i : i * 2) ],
-          ...(i % 2 === 0 && func.params[i] === Valtype.i32 ? [ Opcodes.i32_to ]: [])
+          [ Opcodes.local_get, array ],
+          [ Opcodes.local_get, 5 + i * 2 ],
+          [ Opcodes.f64_store, 0, offset ],
+
+          [ Opcodes.local_get, array ],
+          [ Opcodes.local_get, 6 + i * 2 ],
+          [ Opcodes.i32_store8, 0, offset + 8 ],
         );
+        offset += 9;
       }
+
+      args.push({
+        type: 'SpreadElement',
+        argument: {
+          type: 'Identifier',
+          name: '#array',
+          _type: TYPES.array
+        }
+      });
     }
 
-    wasm.push([ Opcodes.call, func.index ]);
+    wasm.push(...generate(wrapperFunc, {
+      type: 'CallExpression',
+      callee: {
+        type: 'Identifier',
+        name: func.name
+      },
+      _funcIdx: func.index,
+      arguments: args,
+      _insideIndirect: true,
+      _newTargetWasm: [
+        [ Opcodes.local_get, 1 ],
+        [ Opcodes.local_get, 2 ]
+      ],
+      _thisWasm: [
+        [ Opcodes.local_get, 3 ],
+        [ Opcodes.local_get, 4 ]
+      ]
+    }));
 
     if (func.returns[0] === Valtype.i32) {
       if (func.returns.length === 2) {
-        const localIdx = localInd++;
+        const localIdx = wrapperFunc.localInd++;
         locals[localIdx] = { idx: localIdx, type: Valtype.i32 };
 
         wasm.push(
@@ -131,29 +201,10 @@ const funcRef = func => {
       wasm.push(number(func.returnType ?? TYPES.number, Valtype.i32));
     }
 
-    const name = '#indirect_' + func.name;
-    const wrapperFunc = {
-      name,
-      params,
-      locals, localInd,
-      returns: [ valtypeBinary, Valtype.i32 ],
-      wasm,
-      constr: true,
-      internal: true,
-      indirect: true,
-      wrapperOf: func,
-      indirectIndex: indirectFuncs.length
-    };
-
-    indirectFuncs.push(wrapperFunc);
-
-    wrapperFunc.jsLength = countLength(func);
-    func.wrapperFunc = wrapperFunc;
-
     if (!func.constr) {
       // check not being constructed
       wasm.unshift(
-        [ Opcodes.local_get, 0 ], // new.target value
+        [ Opcodes.local_get, 1 ], // new.target value
         Opcodes.i32_to_u,
         [ Opcodes.if, Blocktype.void ], // if value is non-zero
           // ...internalThrow(wrapperFunc, 'TypeError', `${unhackName(func.name)} is not a constructor`), // throw type error
@@ -662,8 +713,6 @@ const generateReturn = (scope, decl) => {
         ...(scope.subclass ? [
           // if subclass and returning undefined, return this
           [ Opcodes.local_get, localTmp(scope, '#return#type', Valtype.i32) ],
-          number(TYPE_FLAGS.parity, Valtype.i32),
-          [ Opcodes.i32_or ],
           number(TYPES.undefined, Valtype.i32),
           [ Opcodes.i32_eq ],
           [ Opcodes.if, Blocktype.void ],
@@ -989,7 +1038,7 @@ const nullish = (scope, wasm, type, intIn = false, intOut = false) => {
     ...(!useTmp ? [] : [ [ Opcodes.local_set, tmp ] ]),
 
     ...typeSwitch(scope, type, [
-      [ [ TYPES.empty, TYPES.undefined ], [
+      [ TYPES.undefined, [
         // empty
         ...(!useTmp ? [ [ Opcodes.drop ] ] : []),
         number(1, intOut ? Valtype.i32 : valtypeBinary)
@@ -2055,7 +2104,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     name = func.name;
   }
 
-  if (!decl._new && (name === 'eval' || (decl.callee.type === 'SequenceExpression' && decl.callee.expressions.at(-1)?.name === 'eval'))) {
+  if (!decl._funcIdx && !decl._new && (name === 'eval' || (decl.callee.type === 'SequenceExpression' && decl.callee.expressions.at(-1)?.name === 'eval'))) {
     const known = knownValue(scope, decl.arguments[0]);
     if (known !== unknownValue) {
       // eval('with known/literal string')
@@ -2101,7 +2150,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     }
   }
 
-  if (name === 'Function') {
+  if (!decl._funcIdx && name === 'Function') {
     const knowns = decl.arguments.map(x => knownValue(scope, x));
     if (knowns.every(x => x !== unknownValue)) {
       // new Function('with known/literal strings')
@@ -2237,19 +2286,24 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
       const lengthLocal = localTmp(scope, '__proto_length_cache', Valtype.i32);
       const pointerLocal = localTmp(scope, '__proto_pointer_cache', Valtype.i32);
 
-      // 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;
+      if (out.length === 0) {
+        out.push(
+          ...generate(scope, target),
+          Opcodes.i32_to_u,
+          [ Opcodes.local_set, pointerLocal ]
+        );
+      } else {
+        out.push(
+          [ Opcodes.local_get, localTmp(scope, '#proto_target') ],
+          Opcodes.i32_to_u,
+          [ Opcodes.local_set, pointerLocal ]
+        );
+      }
 
-      const useLengthCache = true; // basically every prototype uses it
       for (const x in protoCands) {
         const protoFunc = protoCands[x];
+        const getPointer = [ [ Opcodes.local_get, pointerLocal ] ];
+
         if (protoFunc.noArgRetLength && decl.arguments.length === 0) {
           protoBC[x] = [
             ...ArrayUtil.getLength(getPointer),
@@ -2289,37 +2343,16 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
           });
 
           return [
-            [ Opcodes.block, unusedValue ? Blocktype.void : valtypeBinary ],
+            ...ArrayUtil.getLengthI32(getPointer),
+            [ Opcodes.local_set, lengthLocal ],
+
+            [ Opcodes.block, unusedValue && optUnused ? Blocktype.void : valtypeBinary ],
               ...protoOut,
-              ...(unusedValue && !optUnused ? [ [ Opcodes.drop ] ] : []),
-            [ Opcodes.end ]
+            [ Opcodes.end ],
+            ...(unusedValue && optUnused ? [ number(UNDEFINED) ] : [])
           ];
         };
       }
-
-      // alias primitive prototype with primitive object types
-      aliasPrimObjsBC(protoBC);
-
-      return [
-        ...(usePointerCache ? [
-          ...rawPointer,
-          [ Opcodes.local_set, pointerLocal ],
-        ] : []),
-
-        ...(useLengthCache ? [
-          ...ArrayUtil.getLengthI32(getPointer),
-          [ Opcodes.local_set, lengthLocal ],
-        ] : []),
-
-        ...typeSwitch(scope, getNodeType(scope, target), {
-          ...protoBC,
-
-          // TODO: error better
-          default: decl.optional ? withType(scope, [ number(UNDEFINED) ], TYPES.undefined)
-            : internalThrow(scope, 'TypeError', `'${protoName}' proto func tried to be called on a type without an impl`, !unusedValue)
-        }, unusedValue ? Blocktype.void : valtypeBinary),
-        ...(unusedValue ? [ number(UNDEFINED) ] : [])
-      ];
     }
 
     if (Object.keys(protoBC).length > 0) {
@@ -2374,7 +2407,9 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
   }
 
   let idx;
-  if (Object.hasOwn(funcIndex, name)) {
+  if (decl._funcIdx) {
+    idx = decl._funcIdx;
+  } else if (Object.hasOwn(funcIndex, name)) {
     idx = funcIndex[name];
   } else if (scope.name === name) {
     // fallback for own func but with a different var/id name
@@ -2503,7 +2538,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
       }
     }
 
-    let callee = decl.callee, callAsNew = decl._new;
+    let callee = decl.callee, callAsNew = decl._new, sup = false;
     if (callee.type === 'Super') {
       // call super constructor with direct super() call
       callee = getObjProp(callee, 'constructor');
@@ -2512,6 +2547,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
         ...generate(scope, { type: 'ThisExpression' }),
         ...getNodeType(scope, { type: 'ThisExpression' })
       ];
+      sup = true;
     }
 
     const newTargetWasm = decl._newTargetWasm ?? createNewTarget(scope, decl, [
@@ -2519,32 +2555,35 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     ], callAsNew);
     const thisWasm = decl._thisWasm ?? knownThis ?? createThisArg(scope, decl);
 
-    return [
+    out = [
       ...(getCallee ? getCallee : generate(scope, callee)),
       [ Opcodes.local_set, calleeLocal ],
 
       ...typeSwitch(scope, getNodeType(scope, callee), {
         [TYPES.function]: () => [
+          number(10 - underflow, Valtype.i32),
           ...forceDuoValtype(scope, newTargetWasm, Valtype.f64),
           ...forceDuoValtype(scope, thisWasm, Valtype.f64),
           ...out,
 
           [ Opcodes.local_get, calleeLocal ],
           Opcodes.i32_to_u,
-          [ Opcodes.call_indirect, args.length + 2, 0 ],
+          [ Opcodes.call_indirect, args.length + 2, 0,  ],
           ...setLastType(scope)
         ],
 
         default: decl.optional ? withType(scope, [ number(UNDEFINED, Valtype.f64) ], TYPES.undefined)
           : internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, Valtype.f64)
-      }, Valtype.f64),
-      ...(valtypeBinary === Valtype.i32 ? [ Opcodes.i32_trunc_sat_f64_s ] : [])
+      }, Valtype.f64)
     ];
+
+    if (valtypeBinary === Valtype.i32) out.push(Opcodes.i32_trunc_sat_f64_s);
+    if (sup) out.push([ null, 'super marker' ]);
+    return out;
   }
 
   const func = funcByIndex(idx);
-
-  if (func && !decl._new) func.onlyNew = false;
+  if (func && !decl._new && !decl._insideIndirect) func.onlyNew = false;
 
   // generate func
   if (func) func.generate?.();
@@ -2640,6 +2679,8 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
   }
 
   out.push([ Opcodes.call, idx ]);
+  if (decl._insideIndirect) return out;
+
   if (typedReturns) out.push(...setLastType(scope));
 
   if (
@@ -3270,7 +3311,7 @@ const generateVarDstr = (scope, kind, pattern, init, defaultValue, global) => {
 
       if (defaultValue) {
         out.push(
-          ...typeIsOneOf(getType(scope, name), [ TYPES.undefined, TYPES.empty ]),
+          ...typeIsOneOf(getType(scope, name), [ TYPES.undefined ]),
           [ Opcodes.if, Blocktype.void ],
             ...generate(scope, defaultValue, global, name),
             [ global ? Opcodes.global_set : Opcodes.local_set, idx ],
@@ -3418,7 +3459,7 @@ const generateVarDstr = (scope, kind, pattern, init, defaultValue, global) => {
     out = out.concat([
       // check tmp is valid object
       // not undefined or empty type
-      ...typeIsOneOf(getType(scope, tmpName), [ TYPES.undefined, TYPES.empty ]),
+      ...typeIsOneOf(getType(scope, tmpName), [ TYPES.undefined ]),
 
       // not null
       ...getType(scope, tmpName),
@@ -4313,7 +4354,7 @@ const generateUnary = (scope, decl) => {
         [ TYPES.number, () => makeString(scope, 'number') ],
         [ TYPES.boolean, () => makeString(scope, 'boolean') ],
         [ [ TYPES.string, TYPES.bytestring ], () => makeString(scope, 'string') ],
-        [ [ TYPES.undefined, TYPES.empty ], () => makeString(scope, 'undefined') ],
+        [ TYPES.undefined, () => makeString(scope, 'undefined') ],
         [ TYPES.function, () => makeString(scope, 'function') ],
         [ TYPES.symbol, () => makeString(scope, 'symbol') ],
 
@@ -6207,14 +6248,33 @@ const generateClass = (scope, decl) => {
   const proto = getObjProp(root, 'prototype');
 
   const [ func, out ] = generateFunc(scope, {
-    ...(body.find(x => x.kind === 'constructor')?.value ?? {
+    ...(body.find(x => x.kind === 'constructor')?.value ?? (decl.superClass ? {
+      type: 'FunctionExpression',
+      params: [
+        {
+          type: 'RestElement',
+          argument: { type: 'Identifier', name: 'args' }
+        }
+      ],
+      body: {
+        type: 'ExpressionStatement',
+        expression: {
+          type: 'CallExpression',
+          callee: { type: 'Super' },
+          arguments: [ {
+            type: 'SpreadElement',
+            argument: { type: 'Identifier', name: 'args' }
+          } ]
+        }
+      }
+    }: {
       type: 'FunctionExpression',
       params: [],
       body: {
         type: 'BlockStatement',
         body: []
       }
-    }),
+    })),
     id: root,
     strict: true,
     type: expr ? 'FunctionExpression' : 'FunctionDeclaration',
@@ -6225,6 +6285,13 @@ const generateClass = (scope, decl) => {
   // always generate class constructor funcs
   func.generate();
 
+  let constrInsertIndex = func.wasm.findIndex(x => x.at(-1) === 'super marker');
+  if (constrInsertIndex != -1) {
+    func.wasm.splice(constrInsertIndex, 1);
+  } else {
+    constrInsertIndex = 0;
+  }
+
   if (decl.superClass) {
     const superTmp = localTmp(scope, '#superclass');
     const superTypeTmp = localTmp(scope, '#superclass#type', Valtype.i32);
@@ -6287,6 +6354,7 @@ const generateClass = (scope, decl) => {
   scope.overrideThis = generate(scope, root);
   scope.overrideThisType = TYPES.function;
 
+  let constrAdd = [];
   for (const x of body) {
     let { type, value, kind, static: _static, computed } = x;
     if (kind === 'constructor') continue;
@@ -6351,7 +6419,7 @@ const generateClass = (scope, decl) => {
         );
       }
 
-      func.wasm.unshift(
+      const constrWasm = [
         ...generate(func, object),
         Opcodes.i32_to_u,
         ...getNodeType(func, object),
@@ -6370,7 +6438,10 @@ const generateClass = (scope, decl) => {
         ...getNodeType(func, value),
 
         [ Opcodes.call, includeBuiltin(func, `__Porffor_object_class_${initKind}`).index ]
-      );
+      ];
+
+      func.wasm.splice(constrInsertIndex, 0, ...constrWasm);
+      constrInsertIndex += constrWasm.length;
     } else {
       out.push(
         ...generate(scope, object),
@@ -6727,8 +6798,6 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
                 [ Opcodes.i32_ne ],
                 [ Opcodes.if, Blocktype.void ],
                   [ Opcodes.local_get, func.locals[name].idx + 1 ],
-                  number(TYPE_FLAGS.parity, Valtype.i32),
-                  [ Opcodes.i32_or ],
                   number(TYPES.undefined, Valtype.i32),
                   [ Opcodes.i32_eq ],
 
@@ -7161,7 +7230,7 @@ export default program => {
   data = [];
   currentFuncIndex = importedFuncs.length;
   typeswitchDepth = 0;
-  usedTypes = new Set([ TYPES.empty, TYPES.undefined, TYPES.number, TYPES.boolean, TYPES.function ]);
+  usedTypes = new Set([ TYPES.undefined, TYPES.number, TYPES.boolean, TYPES.function ]);
   coctc = new Map();
   globalInfer = new Map();
 

package/compiler/parse.js

@@ -11,21 +11,24 @@ globalThis.typedInput = types && Prefs.optTypes;
 // - meriyah
 // - hermes-parser
 // - @babel/parser
+// - oxc-parser
 
 globalThis.parser = '';
 let parse;
 const loadParser = async (fallbackParser = 'acorn', forceParser) => {
   parser = forceParser ?? Prefs.parser ?? fallbackParser;
-  0, { parse } = (await import((globalThis.document || globalThis.Deno ? 'https://esm.sh/' : '') + parser));
+  const mod = (await import((globalThis.document || globalThis.Deno ? 'https://esm.sh/' : '') + parser));
+  if (mod.parseSync) parse = mod.parseSync;
+    else parse = mod.parse;
 };
 globalThis._porf_loadParser = loadParser;
 await loadParser(types ? '@babel/parser' : undefined);
 
-if (types && !['@babel/parser', 'hermes-parser'].includes(parser)) log.warning('parse', `passed -parse-types with a parser (${parser}) which does not support`);
+if (types && !['@babel/parser', 'hermes-parser', 'oxc-parser'].includes(parser)) log.warning('parse', `passed -parse-types with a parser (${parser}) which does not support`);
 
 export default input => {
   try {
-    const ast = parse(input, {
+    const options = {
       // acorn
       ecmaVersion: 'latest',
 
@@ -43,9 +46,14 @@ export default input => {
       ranges: false,
       tokens: false,
       comments: false,
-    });
 
-    if (ast.type === 'File') return ast.program;
+      // oxc
+      lang: types ? 'ts' : 'js',
+      showSemanticErrors: true // sorry oxc pals but this default is bad
+    };
+
+    let ast = parser === 'oxc-parser' ? parse('js', input, options) : parse(input, options);
+    if (ast.program) ast = ast.program;
 
     return ast;
   } catch (e) {

package/compiler/precompile.js

@@ -277,7 +277,7 @@ ${funcs.map(x => {
   // todo: check for other identifier unsafe characters
   const name = x.name.includes('#') ? `['${x.name}']` : `.${x.name}`;
 
-  const returnTypes = [...(x.returnTypes ?? [])].filter(x => ![ TYPES.empty, TYPES.undefined, TYPES.number, TYPES.boolean, TYPES.function ].includes(x));
+  const returnTypes = [...(x.returnTypes ?? [])].filter(x => ![ TYPES.undefined, TYPES.number, TYPES.boolean, TYPES.function ].includes(x));
   return `this${name} = {
 wasm:${rewriteWasm(x.wasm)},
 params:${JSON.stringify(x.params)},typedParams:1,returns:${JSON.stringify(x.returns)},${x.returnType != null ? `returnType:${JSON.stringify(x.returnType)},` : ''}${returnTypes.length > 0 ? `returnTypes:${JSON.stringify(returnTypes)},` : ''}

package/compiler/prototype.js

@@ -320,7 +320,6 @@ export const PrototypeFuncs = function() {
   this[TYPES.string].at.local2 = Valtype.i32;
   this[TYPES.string].charAt.local = Valtype.i32;
   this[TYPES.string].charCodeAt.local = Valtype.i32;
-  this[TYPES.string].charCodeAt.noPointerCache = zeroChecks.charcodeat;
 
   this[TYPES.bytestring] = {
     at: ({ pointer, length, arg, iTmp, iTmp2, alloc, setType }) => [
@@ -454,5 +453,4 @@ export const PrototypeFuncs = function() {
   this[TYPES.bytestring].at.local2 = Valtype.i32;
   this[TYPES.bytestring].charAt.local = Valtype.i32;
   this[TYPES.bytestring].charCodeAt.local = Valtype.i32;
-  this[TYPES.bytestring].charCodeAt.noPointerCache = zeroChecks.charcodeat;
 };

package/compiler/types.js

@@ -6,20 +6,17 @@ export const TYPE_FLAGS = {
 };
 
 export const TYPES = {
-  empty: 0x00,
+  undefined: 0x00,
   number: 0x01,
   boolean: 0x02,
   string: 0x03 | TYPE_FLAGS.length,
   bigint: 0x04,
   symbol: 0x05,
   function: 0x06,
-  object: 0x07,
-
-  undefined: 0x00 | TYPE_FLAGS.parity,
+  object: 0x07
 };
 
 export const TYPE_NAMES = {
-  [TYPES.empty]: 'empty',
   [TYPES.number]: 'Number',
   [TYPES.boolean]: 'Boolean',
   [TYPES.string]: 'String',

package/compiler/wrap.js

@@ -33,7 +33,6 @@ const writeByteStr = (memory, ptr, str) => {
 
 const porfToJSValue = ({ memory, funcs, pages }, value, type, override = undefined) => {
   switch (type) {
-    case TYPES.empty:
     case TYPES.undefined:
       return undefined;
 

package/jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@honk/porffor",
-  "version": "0.58.3",
+  "version": "0.58.5",
   "exports": "./compiler/wrap.js",
   "publish": {
     "exclude": [

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "porffor",
   "description": "An ahead-of-time JavaScript compiler",
-  "version": "0.58.3",
+  "version": "0.58.5",
   "author": "Oliver Medhurst <honk@goose.icu>",
   "license": "MIT",
   "scripts": {},
@@ -12,7 +12,8 @@
   "optionalDependencies": {
     "@babel/parser": "^7.24.4",
     "hermes-parser": "^0.18.2",
-    "meriyah": "^4.3.9"
+    "meriyah": "^4.3.9",
+    "oxc-parser": "^0.72.2"
   },
   "bin": {
     "porf": "./runtime/index.js"

package/runtime/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import fs from 'node:fs';
-globalThis.version = '0.58.3';
+globalThis.version = '0.58.5';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {