porffor 0.16.0-fe07da0f4 → 0.17.0-05070e1f0

package/compiler/prefs.js

@@ -1,10 +1,9 @@
-const onByDefault = [ 'bytestring', 'treeshakeWasmImports', 'alwaysMemory', 'indirectCalls', 'optUnused' ];
+const onByDefault = [ 'bytestring', 'treeshakeWasmImports', 'alwaysMemory', 'indirectCalls', 'optUnused', 'data', 'rmUnusedTypes' ];
 
 let cache = {};
 const obj = new Proxy({}, {
   get(_, p) {
-    // intentionally misses with undefined values cached
-    if (cache[p]) return cache[p];
+    if (cache[p] != null) return cache[p];
 
     const ret = (() => {
       // fooBar -> foo-bar
@@ -23,9 +22,14 @@ const obj = new Proxy({}, {
     // do not cache in web demo as args are changed live
     if (!globalThis.document) cache[p] = ret;
     return ret;
+  },
+
+  set(_, p, v) {
+    cache[p] = v;
+    return true;
   }
 });
 
-obj.uncache = () => cache = {};
+export const uncache = () => cache = {};
 
 export default obj;

package/compiler/prototype.js

@@ -1,6 +1,5 @@
 import { Opcodes, Blocktype, Valtype, ValtypeSize } from './wasmSpec.js';
 import { number } from './embedding.js';
-import { unsignedLEB128 } from './encoding.js';
 import { UNDEFINED } from './builtins.js';
 import { TYPES } from './types.js';
 import Prefs from './prefs.js';
@@ -55,10 +54,10 @@ export const PrototypeFuncs = function() {
 
       // read from memory
       [ Opcodes.local_get, iTmp ],
-      [ Opcodes.load, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+      [ Opcodes.load, 0, ValtypeSize.i32 ],
 
       [ Opcodes.local_get, iTmp ],
-      [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32 + ValtypeSize[valtype]) ]
+      [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 + ValtypeSize[valtype] ]
     ],
 
     // todo: only for 1 argument
@@ -74,12 +73,12 @@ export const PrototypeFuncs = function() {
       // store value
       [ Opcodes.local_get, iTmp ],
       ...wNewMember,
-      [ Opcodes.store, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+      [ Opcodes.store, 0, ValtypeSize.i32 ],
 
       // store type
       [ Opcodes.local_get, iTmp ],
       ...wType,
-      [ Opcodes.i32_store8, 0, ...unsignedLEB128(ValtypeSize.i32 + ValtypeSize[valtype]) ],
+      [ Opcodes.i32_store8, 0, ValtypeSize.i32 + ValtypeSize[valtype] ],
 
       // bump array length by 1 and return it
       ...length.setI32([
@@ -137,10 +136,10 @@ export const PrototypeFuncs = function() {
         [ Opcodes.local_set, iTmp ],
 
         [ Opcodes.local_get, iTmp ],
-        [ Opcodes.load, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+        [ Opcodes.load, 0, ValtypeSize.i32 ],
 
         [ Opcodes.local_get, iTmp ],
-        [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32 + ValtypeSize[valtype]) ]
+        [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 + ValtypeSize[valtype] ]
       ])
     ],
 
@@ -168,10 +167,10 @@ export const PrototypeFuncs = function() {
       // load first element
       // todo/perf: unusedValue opt
       ...pointer,
-      [ Opcodes.load, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+      [ Opcodes.load, 0, ValtypeSize.i32 ],
 
       ...pointer,
-      [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32 + ValtypeSize[valtype]) ],
+      [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 + ValtypeSize[valtype] ],
 
       // offset page by -1 ind
       // ...number(pointer + ValtypeSize.i32, Valtype.i32), // dst = base array index + length size
@@ -250,12 +249,12 @@ export const PrototypeFuncs = function() {
       // store value
       [ Opcodes.local_get, iTmp2 ],
       [ Opcodes.local_get, iTmp ],
-      [ Opcodes.store, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+      [ Opcodes.store, 0, ValtypeSize.i32 ],
 
       // store type
       [ Opcodes.local_get, iTmp2 ],
       ...wType,
-      [ Opcodes.i32_store8, 0, ...unsignedLEB128(ValtypeSize.i32 + ValtypeSize[valtype]) ],
+      [ Opcodes.i32_store8, 0, ValtypeSize.i32 + ValtypeSize[valtype] ],
 
       // pointer - sizeof value
       ...length.getCachedI32(),
@@ -292,11 +291,8 @@ export const PrototypeFuncs = function() {
       const [ newOut, newPointer ] = arrayShell(1, 'i16');
 
       return [
-        // setup new/out array
+        // setup new/out array and use pointer for store
         ...newOut,
-        [ Opcodes.drop ],
-
-        ...number(0, Valtype.i32), // base 0 for store later
 
         ...wIndex,
         Opcodes.i32_to_u,
@@ -335,13 +331,14 @@ export const PrototypeFuncs = function() {
         [ Opcodes.i32_add ],
 
         // load current string ind {arg}
-        [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
+        [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ValtypeSize.i32 ],
 
         // store to new string ind 0
-        [ Opcodes.i32_store16, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
+        [ Opcodes.i32_store16, Math.log2(ValtypeSize.i16) - 1, ValtypeSize.i32 ],
 
         // return new string (pointer)
-        ...number(newPointer)
+        ...newPointer,
+        Opcodes.i32_from_u
       ];
     },
 
@@ -350,11 +347,8 @@ export const PrototypeFuncs = function() {
       const [ newOut, newPointer ] = arrayShell(1, 'i16');
 
       return [
-        // setup new/out array
+        // setup new/out array and use as pointer for store
         ...newOut,
-        [ Opcodes.drop ],
-
-        ...number(0, Valtype.i32), // base 0 for store later
 
         ...wIndex,
         Opcodes.i32_to,
@@ -366,13 +360,14 @@ export const PrototypeFuncs = function() {
         [ Opcodes.i32_add ],
 
         // load current string ind {arg}
-        [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
+        [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ValtypeSize.i32 ],
 
         // store to new string ind 0
-        [ Opcodes.i32_store16, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
+        [ Opcodes.i32_store16, Math.log2(ValtypeSize.i16) - 1, ValtypeSize.i32 ],
 
         // return new string (page)
-        ...number(newPointer)
+        ...newPointer,
+        Opcodes.i32_from_u
       ];
     },
 
@@ -411,7 +406,7 @@ export const PrototypeFuncs = function() {
       [ Opcodes.i32_add ],
 
       // load current string ind {arg}
-      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
+      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ValtypeSize.i32 ],
       Opcodes.i32_from_u
     ],
 
@@ -433,7 +428,7 @@ export const PrototypeFuncs = function() {
       [ Opcodes.block, Blocktype.void ],
 
       [ Opcodes.local_get, iTmp ],
-      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
+      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ValtypeSize.i32 ],
       [ Opcodes.local_set, iTmp2 ],
 
       // if not surrogate, continue
@@ -455,7 +450,7 @@ export const PrototypeFuncs = function() {
 
       // if not followed by trailing surrogate, return false
       [ Opcodes.local_get, iTmp ],
-      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32 + ValtypeSize.i16) ],
+      [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ValtypeSize.i32 + ValtypeSize.i16 ],
       ...number(0xFC00, Valtype.i32),
       [ Opcodes.i32_and ],
       ...number(0xDC00, Valtype.i32),
@@ -507,11 +502,8 @@ export const PrototypeFuncs = function() {
         const [ newOut, newPointer ] = arrayShell(1, 'i8');
 
         return [
-          // setup new/out array
+          // setup new/out array and use pointer for store later
           ...newOut,
-          [ Opcodes.drop ],
-
-          ...number(0, Valtype.i32), // base 0 for store later
 
           ...wIndex,
           Opcodes.i32_to_u,
@@ -548,13 +540,14 @@ export const PrototypeFuncs = function() {
           [ Opcodes.i32_add ],
 
           // load current string ind {arg}
-          [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+          [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 ],
 
           // store to new string ind 0
-          [ Opcodes.i32_store8, 0, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
+          [ Opcodes.i32_store8, 0, ValtypeSize.i32 ],
 
           // return new string (pointer)
-          ...number(newPointer)
+          ...newPointer,
+          Opcodes.i32_from_u
         ];
       },
 
@@ -563,11 +556,8 @@ export const PrototypeFuncs = function() {
         const [ newOut, newPointer ] = arrayShell(1, 'i8');
 
         return [
-          // setup new/out array
+          // setup new/out array and use pointer for later
           ...newOut,
-          [ Opcodes.drop ],
-
-          ...number(0, Valtype.i32), // base 0 for store later
 
           ...wIndex,
           Opcodes.i32_to,
@@ -576,13 +566,14 @@ export const PrototypeFuncs = function() {
           [ Opcodes.i32_add ],
 
           // load current string ind {arg}
-          [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+          [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 ],
 
           // store to new string ind 0
-          [ Opcodes.i32_store8, 0, ...unsignedLEB128(newPointer + ValtypeSize.i32) ],
+          [ Opcodes.i32_store8, 0, ValtypeSize.i32 ],
 
           // return new string (page)
-          ...number(newPointer)
+          ...newPointer,
+          Opcodes.i32_from_u
         ];
       },
 
@@ -618,7 +609,7 @@ export const PrototypeFuncs = function() {
         [ Opcodes.i32_add ],
 
         // load current string ind {arg}
-        [ Opcodes.i32_load8_u, 0, ...unsignedLEB128(ValtypeSize.i32) ],
+        [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 ],
         Opcodes.i32_from_u
       ],
 

package/compiler/types.js

@@ -20,10 +20,26 @@ export const TYPE_NAMES = {
   [TYPES.bigint]: 'BigInt'
 };
 
+// flags
+export const TYPE_FLAGS = {
+  // iterable:  0b10000000,
+  length:    0b01000000,
+};
+
+// TYPES.string |= TYPE_FLAGS.iterable;
+TYPES.string |= TYPE_FLAGS.length;
+
+export const typeHasFlag = (type, flag) => (type & flag) !== 0;
+
 export const INTERNAL_TYPE_BASE = 0x10;
 let internalTypeIndex = INTERNAL_TYPE_BASE;
-const registerInternalType = name => {
-  const n = internalTypeIndex++;
+const registerInternalType = (name, flags = []) => {
+  let n = internalTypeIndex++;
+
+  for (const x of flags) {
+    if (TYPE_FLAGS[x]) n |= TYPE_FLAGS[x];
+  }
+
   TYPES[name.toLowerCase()] = n;
   TYPE_NAMES[n] = name;
 };
@@ -31,8 +47,18 @@ const registerInternalType = name => {
 // note: when adding a new internal type, please also add a deserializer to wrap.js
 // (it is okay to add a throw todo deserializer for wips)
 
-registerInternalType('Array');
+registerInternalType('Array', ['iterable', 'length']);
 registerInternalType('RegExp');
-registerInternalType('ByteString');
+registerInternalType('ByteString', ['iterable', 'length']);
 registerInternalType('Date');
-registerInternalType('Set');
+registerInternalType('Set', ['iterable']);
+
+registerInternalType('Uint8Array', ['iterable', 'length']);
+registerInternalType('Int8Array', ['iterable', 'length']);
+registerInternalType('Uint8ClampedArray', ['iterable', 'length']);
+registerInternalType('Uint16Array', ['iterable', 'length']);
+registerInternalType('Int16Array', ['iterable', 'length']);
+registerInternalType('Uint32Array', ['iterable', 'length']);
+registerInternalType('Int32Array', ['iterable', 'length']);
+registerInternalType('Float32Array', ['iterable', 'length']);
+registerInternalType('Float64Array', ['iterable', 'length']);

package/compiler/wasmSpec.js

@@ -68,6 +68,7 @@ export const Opcodes = {
 
   i32_load: 0x28,
   i64_load: 0x29,
+  f32_load: 0x2a,
   f64_load: 0x2b,
 
   i32_load8_s: 0x2c,
@@ -82,6 +83,7 @@ export const Opcodes = {
 
   i32_store: 0x36,
   i64_store: 0x37,
+  f32_store: 0x38,
   f64_store: 0x39,
 
   i32_store8: 0x3a,
@@ -191,6 +193,8 @@ export const Opcodes = {
   i32_trunc_sat_f64_s: [ 0xfc, 0x02 ],
   i32_trunc_sat_f64_u: [ 0xfc, 0x03 ],
 
+  memory_init: [ 0xfc, 0x08 ],
+  data_drop: [ 0xfc, 0x09 ],
   memory_copy: [ 0xfc, 0x0a ],
 
   // simd insts are 0xFD simdop: varuint32
@@ -209,8 +213,6 @@ export const Opcodes = {
   i32x4_add: [ 0xfd, 0xae, 0x01 ],
   i32x4_sub: [ 0xfd, 0xb1, 0x01 ],
   i32x4_mul: [ 0xfd, 0xb5, 0x01 ],
-
-  i32x4_dot_i16x8_s: [ 0xfd, 0xba, 0x01 ],
 };
 
 export const FuncType = 0x60;

package/compiler/wrap.js

@@ -2,12 +2,29 @@ import { encodeVector, encodeLocal } from './encoding.js';
 import { importedFuncs } from './builtins.js';
 import compile from './index.js';
 import decompile from './decompile.js';
-import { TYPES } from './types.js';
+import { TYPES, TYPE_NAMES } from './types.js';
 import { log } from './log.js';
 import Prefs from './prefs.js';
 
+const fs = (typeof process?.version !== 'undefined' ? (await import('node:fs')) : undefined);
+
 const bold = x => `\u001b[1m${x}\u001b[0m`;
 
+export const readByteStr = (memory, ptr) => {
+  const length = (new Int32Array(memory.buffer, ptr, 1))[0];
+  return Array.from(new Uint8Array(memory.buffer, ptr + 4, length)).map(x => String.fromCharCode(x)).join('');
+};
+
+export const writeByteStr = (memory, ptr, str) => {
+  const length = str.length;
+  (new Int32Array(memory.buffer, ptr, 1))[0] = length;
+
+  const arr = new Uint8Array(memory.buffer, ptr + 4, length);
+  for (let i = 0; i < length; i++) {
+    arr[i] = str.charCodeAt(i);
+  }
+};
+
 const porfToJSValue = ({ memory, funcs, pages }, value, type) => {
   switch (type) {
     case TYPES.boolean: return Boolean(value);
@@ -87,42 +104,59 @@ const porfToJSValue = ({ memory, funcs, pages }, value, type) => {
 
     case TYPES.symbol: {
       const descStore = pages.get('bytestring: __Porffor_symbol_descStore/ptr').ind * pageSize;
+      if (!descStore) return Symbol();
+
       const offset = descStore + 4 + ((value - 1) * 9);
 
       const v = (new Float64Array(memory.buffer.slice(offset, offset + 8), 0, 1))[0];
       const t = (new Uint8Array(memory.buffer, offset + 8, 1))[0];
 
       const desc = porfToJSValue({ memory, funcs, pages }, v, t);
-
       return Symbol(desc);
     }
 
+    case TYPES.uint8array:
+    case TYPES.int8array:
+    case TYPES.uint8clampedarray:
+    case TYPES.uint16array:
+    case TYPES.int16array:
+    case TYPES.uint32array:
+    case TYPES.int32array:
+    case TYPES.float32array:
+    case TYPES.float64array: {
+      const length = (new Int32Array(memory.buffer, value, 1))[0];
+      return new globalThis[TYPE_NAMES[type]](memory.buffer, value + 4, length);
+    }
+
     default: return value;
   }
 };
 
-export default async (source, flags = [ 'module' ], customImports = {}, print = str => process.stdout.write(str)) => {
+export default (source, flags = [ 'module' ], customImports = {}, print = str => process.stdout.write(str)) => {
   const times = [];
 
   const t1 = performance.now();
-  const { wasm, funcs, globals, tags, exceptions, pages, c } = compile(source, flags);
+  const { wasm, funcs, globals, tags, exceptions, pages, c } = typeof source === 'object' ? source : compile(source, flags);
 
   globalThis.porfDebugInfo = { funcs, globals };
 
-  if (source.includes('export function')) flags.push('module');
+  // if (process.argv[1].includes('/runner') && source.includes?.('export ')) flags.push('module');
 
-  // (await import('node:fs')).writeFileSync('out.wasm', Buffer.from(wasm));
+  // fs.writeFileSync('out.wasm', Buffer.from(wasm));
 
   times.push(performance.now() - t1);
   if (Prefs.profileCompiler) console.log(bold(`compiled in ${times[0].toFixed(2)}ms`));
 
   const backtrace = (funcInd, blobOffset) => {
-    if (funcInd == null || blobOffset == null) return false;
+    if (funcInd == null || blobOffset == null ||
+        Number.isNaN(funcInd) || Number.isNaN(blobOffset)) return false;
 
     // convert blob offset -> function wasm offset.
     // this is not good code and is somewhat duplicated
     // I just want it to work for debugging, I don't care about perf/yes
     const func = funcs.find(x => x.index === funcInd);
+    if (!func) return false;
+
     const locals = Object.values(func.locals).sort((a, b) => a.idx - b.idx).slice(func.params.length).sort((a, b) => a.idx - b.idx);
 
     let localDecl = [], typeCount = 0, lastType;
@@ -197,13 +231,15 @@ export default async (source, flags = [ 'module' ], customImports = {}, print =
 
   let instance;
   try {
-    let wasmEngine = WebAssembly;
-    if (Prefs.asur) {
-      log.warning('wrap', 'using our !experimental! asur wasm engine instead of host to run');
-      wasmEngine = await import('../asur/index.js');
-    }
-
-    0, { instance } = await wasmEngine.instantiate(wasm, {
+    // let wasmEngine = WebAssembly;
+    // if (Prefs.asur) {
+    //   log.warning('wrap', 'using our !experimental! asur wasm engine instead of host to run');
+    //   wasmEngine = await import('../asur/index.js');
+    // }
+
+    // 0, { instance } = await wasmEngine.instantiate(wasm, {
+    const module = new WebAssembly.Module(wasm);
+    instance = new WebAssembly.Instance(module, {
       '': {
         p: valtype === 'i64' ? i => print(Number(i).toString()) : i => print(i.toString()),
         c: valtype === 'i64' ? i => print(String.fromCharCode(Number(i))) : i => print(String.fromCharCode(i)),
@@ -211,12 +247,33 @@ export default async (source, flags = [ 'module' ], customImports = {}, print =
         u: () => performance.timeOrigin,
         y: () => {},
         z: () => {},
+        w: (ind, outPtr) => { // readArgv
+          let args = process.argv.slice(2);
+          args = args.slice(args.findIndex(x => !x.startsWith('-')) + 1);
+
+          const str = args[ind - 1];
+          if (!str) return -1;
+
+          writeByteStr(memory, outPtr, str);
+          return str.length;
+        },
+        q: (pathPtr, outPtr) => { // readFile
+          try {
+            const path = pathPtr === 0 ? 0 : readByteStr(memory, pathPtr);
+            const contents = fs.readFileSync(path, 'utf8');
+            writeByteStr(memory, outPtr, contents);
+            return contents.length;
+          } catch {
+            return -1;
+          }
+        },
         ...customImports
       }
     });
   } catch (e) {
     // only backtrace for runner, not test262/etc
     if (!process.argv[1].includes('/runner')) throw e;
+    if (!(e instanceof WebAssembly.CompileError)) throw e;
 
     const funcInd = parseInt(e.message.match(/function #([0-9]+) /)?.[1]);
     const blobOffset = parseInt(e.message.split('@')?.[1]);
@@ -255,16 +312,58 @@ export default async (source, flags = [ 'module' ], customImports = {}, print =
         return porfToJSValue({ memory, funcs, pages }, ret[0], ret[1]);
       } catch (e) {
         if (e.is && e.is(exceptTag)) {
-          const exceptId = e.getArg(exceptTag, 0);
-          const exception = exceptions[exceptId];
+          const exceptionMode = Prefs.exceptionMode ?? 'lut';
+          if (exceptionMode === 'lut') {
+            const exceptId = e.getArg(exceptTag, 0);
+            const exception = exceptions[exceptId];
+
+            const constructorName = exception.constructor;
+
+            // no constructor, just throw message
+            if (!constructorName) throw exception.message;
+
+            const constructor = globalThis[constructorName] ?? eval(`class ${constructorName} extends Error { constructor(message) { super(message); this.name = "${constructorName}"; } }; ${constructorName}`);
+            throw new constructor(exception.message);
+          }
+
+          if (exceptionMode === 'stack') {
+            const value = e.getArg(exceptTag, 0);
+            const type = e.getArg(exceptTag, 1);
+
+            throw porfToJSValue({ memory, funcs, pages }, value, type);
+          }
+
+          if (exceptionMode === 'stackest') {
+            const constructorIdx = e.getArg(exceptTag, 0);
+            const constructorName = constructorIdx == -1 ? null : funcs.find(x => ((x.originalIndex ?? x.index) - importedFuncs.length) === constructorIdx)?.name;
+
+            const value = e.getArg(exceptTag, 1);
+            const type = e.getArg(exceptTag, 2);
+            const message = porfToJSValue({ memory, funcs, pages }, value, type);
+
+            // no constructor, just throw message
+            if (!constructorName) throw message;
+
+            const constructor = globalThis[constructorName] ?? eval(`class ${constructorName} extends Error { constructor(message) { super(message); this.name = "${constructorName}"; } }; ${constructorName}`);
+            throw new constructor(message);
+          }
+
+          if (exceptionMode === 'partial') {
+            const exceptId = e.getArg(exceptTag, 0);
+            const exception = exceptions[exceptId];
+
+            const constructorName = exception.constructor;
 
-          const constructorName = exception.constructor;
+            const value = e.getArg(exceptTag, 1);
+            const type = e.getArg(exceptTag, 2);
+            const message = porfToJSValue({ memory, funcs, pages }, value, type);
 
-          // no constructor, just throw message
-          if (!constructorName) throw exception.message;
+            // no constructor, just throw message
+            if (!constructorName) throw message;
 
-          const constructor = globalThis[constructorName] ?? eval(`class ${constructorName} extends Error { constructor(message) { super(message); this.name = "${constructorName}"; } }; ${constructorName}`);
-          throw new constructor(exception.message);
+            const constructor = globalThis[constructorName] ?? eval(`class ${constructorName} extends Error { constructor(message) { super(message); this.name = "${constructorName}"; } }; ${constructorName}`);
+            throw new constructor(message);
+          }
         }
 
         if (e instanceof WebAssembly.RuntimeError) {

package/package.json

@@ -1,12 +1,10 @@
 {
   "name": "porffor",
   "description": "a basic experimental wip aot optimizing js -> wasm engine/compiler/runtime in js",
-  "version": "0.16.0-fe07da0f4",
+  "version": "0.17.0-05070e1f0",
   "author": "CanadaHonk",
   "license": "MIT",
-  "scripts": {
-    "precompile": "node ./compiler/precompile.js"
-  },
+  "scripts": {},
   "dependencies": {
     "acorn": "^8.11.3",
     "node-repl-polyfill": "^0.1.1"
@@ -28,5 +26,5 @@
   "bugs": {
     "url": "https://github.com/CanadaHonk/porffor/issues"
   },
-  "homepage": "https://porffor.goose.icu"
+  "homepage": "https://porffor.dev"
 }

package/rhemyn/README.md

@@ -24,13 +24,16 @@ Made for use with Porffor but could possibly be adapted, implementation/library
   - 🟢 digit, not digit (eg `\d\D`)
   - 🟢 word, not word (eg `\w\W`)
   - 🟢 whitespace, not whitespace (eg `\s\S`)
-- 🟠 quantifiers
-  - 🟠 star (eg `a*`)
-  - 🟠 plus (eg `a+`)
-  - 🟠 optional (eg `a?`)
+- 🟡 quantifiers
+  - 🟡 star (eg `a*`)
+  - 🟡 plus (eg `a+`)
+  - 🟡 optional (eg `a?`)
   - 🟠 lazy modifier (eg `a*?`)
   - 🔴 n repetitions (eg `a{4}`)
   - 🔴 n-m repetitions (eg `a{2,4}`)
+- 🟠 groups
+  - 🟠 capturing groups (`(a)`)
+  - 🔴 non-capturing groups (`(?:a)`)
 - 🔴 assertions
   - 🔴 beginning (eg `^a`)
   - 🔴 end (eg `a$`)