porffor 0.0.0-ebc0491 → 0.0.0-ee33579

package/README.md

@@ -1,11 +1,10 @@
 # porffor
-a basic experimental wip *aot* optimizing js -> wasm engine/compiler/runtime in js. not serious/intended for (real) use. (this is a straight forward, honest readme)<br>
+a basic experimental wip *aot* optimizing js -> wasm/c engine/compiler/runtime in js. not serious/intended for (real) use. (this is a straight forward, honest readme)<br>
 age: ~1 month
 
 ## design
 porffor is a very unique js engine, due a very different approach. it is seriously limited, but what it can do, it does pretty well. key differences:
 - 100% aot compiled *(not jit)*
-- everything is a number
 - no constant runtime/preluded code
 - least Wasm imports possible (only stdio)
 
@@ -18,6 +17,12 @@ porffor is mostly built from scratch, the only thing that is not is the parser (
 - no variables between scopes (except args and globals)
 - literal callees only in calls (eg `print()` works, `a = print; a()` does not)
 
+## rhemyn
+rhemyn is porffor's own regex engine; it compiles literal regex to wasm bytecode aot (remind you of anything?). it is quite basic and wip. see [its readme](rhemyn/README.md) for more details.
+
+## 2c
+2c is porffor's own wasm -> c compiler, using generated wasm bytecode and internal info to generate specific and efficient/fast c code. no boilerplate/preluded code or required external files, just for cli binaries (not like wasm2c very much at all).
+
 ## supported
 see [optimizations](#optimizations) for opts implemented/supported.
 
@@ -116,8 +121,6 @@ no particular order and no guarentees, just what could happen soon™
   - basic object expressions (eg `{}`, `{ a: 0 }`)
 - wasm
   - *basic* wasm engine (interpreter) in js
-- regex
-  - *basic* regex engine (in wasm compiled aot or js interpreter?)
 - more math operators (`**`, etc)
 - `do { ... } while (...)`
 - rewrite `console.log` to work with strings/arrays
@@ -136,9 +139,6 @@ no particular order and no guarentees, just what could happen soon™
 
 ![Screenshot of comparison chart](https://github.com/CanadaHonk/porffor/assets/19228318/76c75264-cc68-4be1-8891-c06dc389d97a)
 
-## test262
-porffor can run test262 via some hacks/transforms which remove unsupported features whilst still doing the same asserts (eg simpler error messages using literals only). it currently passes >10% (see latest commit desc for latest and details). use `node test262` to test, it will also show a difference of overall results between the last commit and current results.
-
 ## optimizations
 mostly for reducing size. do not really care about compiler perf/time as long as it is reasonable. we do not use/rely on external opt tools (`wasm-opt`, etc), instead doing optimization inside the compiler itself creating even smaller code sizes than `wasm-opt` itself can produce as we have more internal information. (this also enables fast + small runtime use as a potential cursed jit in frontend).
 
@@ -163,6 +163,9 @@ mostly for reducing size. do not really care about compiler perf/time as long as
 - type cache/index (no repeated types)
 - no main func if empty (and other exports)
 
+## test262
+porffor can run test262 via some hacks/transforms which remove unsupported features whilst still doing the same asserts (eg simpler error messages using literals only). it currently passes >10% (see latest commit desc for latest and details). use `node test262` to test, it will also show a difference of overall results between the last commit and current results.
+
 ## codebase
 - `compiler`: contains the compiler itself
   - `builtins.js`: all built-ins of the engine (spec, custom. vars, funcs)
@@ -183,6 +186,10 @@ mostly for reducing size. do not really care about compiler perf/time as long as
   - `info.js`: runs with extra info printed
   - `repl.js`: basic repl (uses `node:repl`)
 
+- `rhemyn`: contains [rhemyn](#rhemyn) - the regex engine used by porffor
+  - `compile.js`: compiles regex ast into wasm bytecode
+  - `parse.js`: own regex parser
+
 - `test`: contains many test files for majority of supported features
 - `test262`: test262 runner and utils
 
@@ -200,8 +207,13 @@ basically nothing will work :). see files in `test` for examples.
 you can also use deno (`deno run -A ...` instead of `node ...`), or bun (`bun ...` instead of `node ...`)
 
 ### flags
-- `-raw` for no info logs (just raw js output)
-- `-valtype=i32|i64|f64` to set valtype, f64 by default
+- `-target=wasm|c|native` (default: `wasm`) to set target output (native compiles c output to binary, see args below)
+- `-target=c|native` only:
+  - `-o=out.c|out.exe|out` to set file to output c or binary
+- `-target=native` only:
+  - `-compiler=clang` to set compiler binary (path/name) to use to compile
+  - `-cO=O3` to set compiler opt argument
+- `-valtype=i32|i64|f64` (default: `f64`) to set valtype
 - `-O0` to disable opt
 - `-O1` (default) to enable basic opt (simplify insts, treeshake wasm imports)
 - `-O2` to enable advanced opt (inlining)
@@ -209,6 +221,7 @@ you can also use deno (`deno run -A ...` instead of `node ...`), or bun (`bun ..
 - `-no-run` to not run wasm output, just compile
 - `-opt-log` to log some opts
 - `-code-log` to log some codegen (you probably want `-funcs`)
+- `-regex-log` to log some regex
 - `-funcs` to log funcs
 - `-opt-funcs` to log funcs after opt
 - `-sections` to log sections as hex

package/compiler/2c.js

@@ -0,0 +1,255 @@
+import { read_ieee754_binary64, read_signedLEB128 } from './encoding.js';
+import { Blocktype, Opcodes, Valtype } from './wasmSpec.js';
+import { operatorOpcode } from './expression.js';
+
+const CValtype = {
+  i8: 'char',
+  i16: 'unsigned short', // presume all i16 stuff is unsigned
+  i32: 'long',
+  i32_u: 'unsigned long',
+  i64: 'long long',
+  i64_u: 'unsigned long long',
+
+  f32: 'float',
+  f64: 'double',
+
+  undefined: 'void'
+};
+
+const inv = (obj, keyMap = x => x) => Object.keys(obj).reduce((acc, x) => { acc[keyMap(obj[x])] = x; return acc; }, {});
+const invOpcodes = inv(Opcodes);
+
+for (const x in CValtype) {
+  if (Valtype[x]) CValtype[Valtype[x]] = CValtype[x];
+}
+
+const todo = msg => {
+  class TodoError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = 'TodoError';
+    }
+  }
+
+  throw new TodoError(`todo: ${msg}`);
+};
+
+export default ({ funcs, globals, tags, exceptions, pages }) => {
+  const invOperatorOpcode = inv(operatorOpcode[valtype]);
+  const invGlobals = inv(globals, x => x.idx);
+
+  const includes = new Map();
+  let out = '';
+
+  for (const x in globals) {
+    const g = globals[x];
+
+    out += `${CValtype[g.type]} ${x}`;
+    if (x.init) out += ` ${x.init}`;
+    out += ';\n';
+  }
+
+  for (const [ x, p ] of pages) {
+    out += `${CValtype[p.type]} ${x.replace(': ', '_').replace(/[^0-9a-zA-Z_]/g, '')}[100]`;
+    out += ';\n';
+  }
+
+  if (out) out += '\n';
+
+  for (const f of funcs) {
+    const invLocals = inv(f.locals, x => x.idx);
+    if (f.returns.length > 1) todo('funcs returning >1 value unsupported');
+
+    const sanitize = str => str.replace(/[^0-9a-zA-Z_]/g, _ => String.fromCharCode(97 + _.charCodeAt(0) % 32));
+
+    const returns = f.returns.length === 1;
+
+    const shouldInline = ['f64_%'].includes(f.name);
+    out += `${f.name === 'main' ? 'int' : CValtype[f.returns[0]]} ${shouldInline ? 'inline ' : ''}${sanitize(f.name)}(${f.params.map((x, i) => `${CValtype[x]} ${invLocals[i]}`).join(', ')}) {\n`;
+
+    let depth = 1;
+    const line = (str, semi = true) => out += `${' '.repeat(depth * 2)}${str}${semi ? ';' : ''}\n`;
+
+    const localKeys = Object.keys(f.locals).sort((a, b) => f.locals[a].idx - f.locals[b].idx).slice(f.params.length).sort((a, b) => f.locals[a].idx - f.locals[b].idx);
+    for (const x of localKeys) {
+      const l = f.locals[x];
+      line(`${CValtype[l.type]} ${x}`);
+    }
+
+    if (localKeys.length !== 0) out += '\n';
+
+    let vals = [];
+    const endNeedsCurly = [], ignoreEnd = [];
+    let beginLoop = false, lastCond = false, ifTernary = false;
+    for (let _ = 0; _ < f.wasm.length; _++) {
+      const i = f.wasm[_];
+
+      if (invOperatorOpcode[i[0]]) {
+        const b = vals.pop();
+        const a = vals.pop();
+
+        let op = invOperatorOpcode[i[0]];
+        if (op.length === 3) op = op.slice(0, 2);
+
+        if (['==', '!=', '>', '>=', '<', '<='].includes(op)) lastCond = true;
+          else lastCond = false;
+
+        vals.push(`${a} ${op} ${b}`);
+        continue;
+      }
+
+      // misc insts
+      if (i[0] === 0xfc) {
+        switch (i[1]) {
+          // i32_trunc_sat_f64_s
+          case 0x02:
+            vals.push(`(${CValtype.i32})${vals.pop()}`);
+            break;
+
+          // i32_trunc_sat_f64_u
+          case 0x03:
+            vals.push(`(${CValtype.i32})(${CValtype.i32_u})${vals.pop()}`);
+            break;
+        }
+
+        lastCond = false;
+        continue;
+      }
+
+      switch (i[0]) {
+        case Opcodes.i32_const:
+          vals.push(read_signedLEB128(i.slice(1)).toString());
+          break;
+
+        case Opcodes.f64_const:
+          vals.push(read_ieee754_binary64(i.slice(1)).toExponential());
+          break;
+
+        case Opcodes.local_get:
+          vals.push(`${invLocals[i[1]]}`);
+          break;
+
+        case Opcodes.local_set:
+          line(`${invLocals[i[1]]} = ${vals.pop()}`);
+          break;
+
+        case Opcodes.local_tee:
+          vals.push(`${invLocals[i[1]]} = ${vals.pop()}`);
+          break;
+
+        case Opcodes.f64_trunc:
+          // vals.push(`trunc(${vals.pop()})`);
+          vals.push(`(int)(${vals.pop()})`); // this is ~10x faster with clang. what the fuck.
+          break;
+
+        case Opcodes.return:
+          line(`return${returns ? ` ${vals.pop()}` : ''}`);
+          break;
+
+        case Opcodes.if:
+          let cond = vals.pop();
+          if (!lastCond) {
+            if (cond.startsWith('(long)')) cond = `${cond.slice(6)} == 1e+0`;
+              else cond += ' == 1';
+          }
+
+          ifTernary = i[1] !== Blocktype.void;
+          if (ifTernary) {
+            ifTernary = cond;
+            break;
+          }
+
+          if (beginLoop) {
+            beginLoop = false;
+            line(`while (${cond}) {`, false);
+
+            depth++;
+            endNeedsCurly.push(true);
+            ignoreEnd.push(false, true);
+            break;
+          }
+
+          line(`if (${cond}) {`, false);
+
+          depth++;
+          endNeedsCurly.push(true);
+          ignoreEnd.push(false);
+          break;
+
+        case Opcodes.else:
+          if (ifTernary) break;
+
+          depth--;
+          line(`} else {`, false);
+          depth++;
+          break;
+
+        case Opcodes.loop:
+          // not doing properly, fake a while loop
+          beginLoop = true;
+          break;
+
+        case Opcodes.end:
+          if (ignoreEnd.pop()) break;
+
+          if (ifTernary) {
+            const b = vals.pop();
+            const a = vals.pop();
+            vals.push(`${ifTernary} ? ${a} : ${b}`);
+            break;
+          }
+
+          depth--;
+          if (endNeedsCurly.pop() === true) line('}', false);
+          break;
+
+        case Opcodes.call:
+          let func = funcs.find(x => x.index === i[1]);
+          if (!func) {
+            const importFunc = importFuncs[i[1]];
+            switch (importFunc.name) {
+              case 'print':
+                line(`printf("%f\\n", ${vals.pop()})`);
+                includes.set('stdio.h', true);
+                break;
+            }
+            break;
+          }
+
+          let args = [];
+          for (let j = 0; j < func.params.length; j++) args.unshift(vals.pop());
+
+          if (func.returns.length === 1) vals.push(`${sanitize(func.name)}(${args.join(', ')})`)
+            else line(`${sanitize(func.name)}(${args.join(', ')})`);
+
+          break;
+
+        case Opcodes.drop:
+          line(vals.pop());
+          break;
+
+        case Opcodes.br:
+          // ignore
+          // reset "stack"
+          vals = [];
+          break;
+
+        default:
+          log('2c', `unimplemented op: ${invOpcodes[i[0]]}`);
+          // todo(`unimplemented op: ${invOpcodes[i[0]]}`);
+      }
+
+      lastCond = false;
+    }
+
+    if (vals.length === 1 && returns) {
+      line(`return ${vals.pop()}`);
+    }
+
+    out += '}\n\n';
+  }
+
+  out = [...includes.keys()].map(x => `#include <${x}>`).join('\n') + '\n\n' + out;
+
+  return out;
+};

package/compiler/builtins.js

@@ -568,7 +568,6 @@ export const BuiltinFuncs = function() {
     params: [ Valtype.i32 ],
     locals: [],
     returns: [ Valtype.v128 ],
-    memory: true,
     wasm: [
       [ Opcodes.local_get, 0 ],
       [ ...Opcodes.v128_load, 0, 0 ]

package/compiler/codeGen.js

@@ -5,6 +5,7 @@ import { BuiltinFuncs, BuiltinVars, importedFuncs, NULL, UNDEFINED } from "./bui
 import { PrototypeFuncs } from "./prototype.js";
 import { number, i32x4 } from "./embedding.js";
 import parse from "./parse.js";
+import * as Rhemyn from "../rhemyn/compile.js";
 
 let globals = {};
 let globalInd = 0;
@@ -745,7 +746,7 @@ const generateBinaryExp = (scope, decl, _global, _name) => {
   return out;
 };
 
-const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes = [], globalInits, returns, returnType, memory, localNames = [], globalNames = [] }) => {
+const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes = [], globalInits, returns, returnType, localNames = [], globalNames = [] }) => {
   const existing = funcs.find(x => x.name === name);
   if (existing) return existing;
 
@@ -781,7 +782,6 @@ const asmFunc = (name, { wasm, params, locals: localTypes, globals: globalTypes
     returns,
     returnType: TYPES[returnType ?? 'number'],
     wasm,
-    memory,
     internal: true,
     index: currentFuncIndex++
   };
@@ -814,7 +814,8 @@ const TYPES = {
   bigint: 0xffffffffffff7,
 
   // these are not "typeof" types but tracked internally
-  _array: 0xffffffffffff8
+  _array: 0xfffffffffff0f,
+  _regexp: 0xfffffffffff1f
 };
 
 const TYPE_NAMES = {
@@ -849,6 +850,8 @@ const getType = (scope, _name) => {
 const getNodeType = (scope, node) => {
   if (node.type === 'Literal') {
     if (['number', 'boolean', 'string', 'undefined', 'object', 'function', 'symbol', 'bigint'].includes(node.value)) return TYPES.number;
+    if (node.regex) return TYPES._regexp;
+
     return TYPES[typeof node.value];
   }
 
@@ -882,6 +885,11 @@ const getNodeType = (scope, node) => {
 
     // literal.func()
     if (!name && node.callee.type === 'MemberExpression') {
+      if (node.callee.object.regex) {
+        const funcName = node.callee.property.name;
+        return Rhemyn[funcName] ? TYPES.boolean : TYPES.undefined;
+      }
+
       const baseType = getNodeType(scope, node.callee.object);
 
       const func = node.callee.property.name;
@@ -925,6 +933,11 @@ const getNodeType = (scope, node) => {
 const generateLiteral = (scope, decl, global, name) => {
   if (decl.value === null) return number(NULL);
 
+  if (decl.regex) {
+    scope.regex[name] = decl.regex;
+    return number(1);
+  }
+
   switch (typeof decl.value) {
     case 'number':
       return number(decl.value);
@@ -1084,6 +1097,25 @@ 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 func = Rhemyn[funcName](decl.callee.object.regex.pattern, currentFuncIndex++);
+
+      funcIndex[func.name] = func.index;
+      funcs.push(func);
+
+      return [
+        // make string arg
+        ...generate(scope, decl.arguments[0]),
+
+        // call regex func
+        Opcodes.i32_to_u,
+        [ Opcodes.call, func.index ],
+        Opcodes.i32_from
+      ];
+    }
+
     baseType = getNodeType(scope, decl.callee.object);
 
     const func = decl.callee.property.name;
@@ -1096,6 +1128,31 @@ const generateCall = (scope, decl, _global, _name) => {
     baseName = [...arrays.keys()].pop();
   }
 
+  if (protoName && baseType === TYPES.string && Rhemyn[protoName]) {
+    const func = Rhemyn[protoName](decl.arguments[0].regex.pattern, currentFuncIndex++);
+
+    funcIndex[func.name] = func.index;
+    funcs.push(func);
+
+    const pointer = arrays.get(baseName);
+    const [ local, isGlobal ] = lookupName(scope, baseName);
+
+    return [
+      ...out,
+
+      ...(pointer == null ? [
+        [ isGlobal ? Opcodes.global_get : Opcodes.local_get, local.idx ],
+        Opcodes.i32_to_u,
+      ] : [
+        ...number(pointer, Valtype.i32)
+      ]),
+
+      // call regex func
+      [ Opcodes.call, func.index ],
+      Opcodes.i32_from
+    ];
+  }
+
   if (protoFunc) {
     let pointer = arrays.get(baseName);
 
@@ -1705,19 +1762,19 @@ const generateAssignPat = (scope, decl) => {
 };
 
 let pages = new Map();
-const allocPage = reason => {
-  if (pages.has(reason)) return pages.get(reason);
+const allocPage = (reason, type) => {
+  if (pages.has(reason)) return pages.get(reason).ind;
 
-  let ind = pages.size;
-  pages.set(reason, ind);
+  const ind = pages.size;
+  pages.set(reason, { ind, type });
 
-  if (allocLog) log('alloc', `allocated new page of memory (${ind}) | ${reason}`);
+  if (allocLog) log('alloc', `allocated new page of memory (${ind}) | ${reason} (type: ${type})`);
 
   return ind;
 };
 
 const freePage = reason => {
-  let ind = pages.get(reason);
+  const { ind } = pages.get(reason);
   pages.delete(reason);
 
   if (allocLog) log('alloc', `freed page of memory (${ind}) | ${reason}`);
@@ -1749,7 +1806,7 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
   if (!arrays.has(name) || name === '$undeclared') {
     // 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}`) * pageSize);
+    arrays.set(name, allocPage(`${itemType === 'i16' ? 'string' : 'array'}: ${uniqueName}`, itemType) * pageSize);
   }
 
   const pointer = arrays.get(name);
@@ -1929,7 +1986,6 @@ const generateFunc = (scope, decl) => {
     localInd: 0,
     returns: [ valtypeBinary ],
     returnType: null,
-    memory: false,
     throws: false,
     name
   };

package/compiler/decompile.js

@@ -57,7 +57,7 @@ export default (wasm, name = '', ind = 0, locals = {}, params = [], returns = []
       out += ` ;; label @${depth}`;
     }
 
-    if (inst[0] === Opcodes.br) {
+    if (inst[0] === Opcodes.br || inst[0] === Opcodes.br_if) {
       out += ` ;; goto @${depth - inst[1]}`;
     }
 

package/compiler/index.js

@@ -4,6 +4,8 @@ import opt from './opt.js';
 import produceSections from './sections.js';
 import decompile from './decompile.js';
 import { BuiltinPreludes } from './builtins.js';
+import toc from './2c.js';
+
 
 globalThis.decompile = decompile;
 
@@ -15,7 +17,8 @@ const areaColors = {
   codegen: [ 20, 80, 250 ],
   opt: [ 250, 20, 80 ],
   sections: [ 20, 250, 80 ],
-  alloc: [ 250, 250, 20 ]
+  alloc: [ 250, 250, 20 ],
+  '2c': [ 20, 250, 250 ]
 };
 
 globalThis.log = (area, ...args) => console.log(`\u001b[90m[\u001b[0m${rgb(...areaColors[area], area)}\u001b[90m]\u001b[0m`, ...args);
@@ -36,10 +39,16 @@ const logFuncs = (funcs, globals, exceptions) => {
   console.log();
 };
 
+const getArg = name => process.argv.find(x => x.startsWith(`-${name}=`))?.slice(name.length + 2);
+
+const writeFileSync = (typeof process !== 'undefined' ? (await import('node:fs')).writeFileSync : undefined);
+const execSync = (typeof process !== 'undefined' ? (await import('node:child_process')).execSync : undefined);
+
 export default (code, flags) => {
   globalThis.optLog = process.argv.includes('-opt-log');
   globalThis.codeLog = process.argv.includes('-code-log');
   globalThis.allocLog = process.argv.includes('-alloc-log');
+  globalThis.regexLog = process.argv.includes('-regex-log');
 
   for (const x in BuiltinPreludes) {
     if (code.indexOf(x + '(') !== -1) code = BuiltinPreludes[x] + code;
@@ -72,5 +81,38 @@ export default (code, flags) => {
     // console.log([...pages.keys()].map(x => `\x1B[36m - ${x}\x1B[0m`).join('\n'));
   }
 
-  return { wasm: sections, funcs, globals, tags, exceptions, pages };
+  const out = { wasm: sections, funcs, globals, tags, exceptions, pages };
+
+  const target = getArg('target') ?? getArg('t') ?? 'wasm';
+  const outFile = getArg('o');
+
+  if (target === 'c') {
+    const c = toc(out);
+
+    if (outFile) {
+      writeFileSync(outFile, c);
+    } else {
+      console.log(c);
+    }
+
+    process.exit();
+  }
+
+  if (target === 'native') {
+    const compiler = getArg('compiler') ?? 'clang';
+    const cO = getArg('cO') ?? 'O3';
+
+    const tmpfile = 'tmp.c';
+    const args = [ compiler, tmpfile, '-o', outFile ?? (process.platform === 'win32' ? 'out.exe' : 'out'), '-' + cO ];
+
+    const c = toc(out);
+    writeFileSync(tmpfile, c);
+
+    // obvious command escape is obvious
+    execSync(args.join(' '), { stdio: 'inherit' });
+
+    process.exit();
+  }
+
+  return out;
 };

package/compiler/opt.js

@@ -142,7 +142,7 @@ export default (funcs, globals) => {
             depth--;
             if (depth <= 0) break;
           }
-          if (op === Opcodes.br) {
+          if (op === Opcodes.br || op === Opcodes.br_if) {
             hasBranch = true;
             break;
           }

package/compiler/parse.js

@@ -1,4 +1,5 @@
-const { parse } = (await import(globalThis.document ? 'https://esm.sh/acorn' : 'acorn'));
+import { parse } from 'acorn';
+// const { parse } = (await import(globalThis.document ? 'https://esm.sh/acorn' : 'acorn'));
 
 export default (input, flags) => {
   return parse(input, {

package/compiler/prototype.js

@@ -15,7 +15,8 @@ const TYPES = {
   bigint: 0xffffffffffff7,
 
   // these are not "typeof" types but tracked internally
-  _array: 0xffffffffffff8
+  _array: 0xfffffffffff0f,
+  _regexp: 0xfffffffffff1f
 };
 
 // todo: turn these into built-ins once arrays and these become less hacky

package/compiler/sections.js

@@ -76,6 +76,7 @@ export default (funcs, globals, tags, pages, flags) => {
       }
     }
   }
+  globalThis.importFuncs = importFuncs;
 
   if (optLog) log('sections', `treeshake: using ${importFuncs.length}/${importedFuncs.length} imports`);
 

package/compiler/wrap.js

@@ -1,10 +1,11 @@
 import compile from './index.js';
 import decompile from './decompile.js';
-import fs from 'node:fs';
+// import fs from 'node:fs';
 
 const bold = x => `\u001b[1m${x}\u001b[0m`;
 
 const typeBase = 0xffffffffffff0;
+const internalTypeBase = 0xfffffffffff0f;
 const TYPES = {
   [typeBase]: 'number',
   [typeBase + 1]: 'boolean',
@@ -16,7 +17,8 @@ const TYPES = {
   [typeBase + 7]: 'bigint',
 
   // internal
-  [typeBase + 8]: '_array'
+  [internalTypeBase]: '_array',
+  [internalTypeBase + 1]: '_regexp'
 };
 
 export default async (source, flags = [ 'module' ], customImports = {}, print = str => process.stdout.write(str)) => {
@@ -27,7 +29,7 @@ export default async (source, flags = [ 'module' ], customImports = {}, print =
 
   if (source.includes('export function')) flags.push('module');
 
-  fs.writeFileSync('out.wasm', Buffer.from(wasm));
+  // fs.writeFileSync('out.wasm', Buffer.from(wasm));
 
   times.push(performance.now() - t1);
   if (flags.includes('info')) console.log(bold(`compiled in ${times[0].toFixed(2)}ms`));