porffor 0.2.0-e04e26f → 0.2.0-e62542f

package/CONTRIBUTING.md

@@ -0,0 +1,254 @@
+# Contributing to Porffor
+
+Hello! Thanks for your potential interest in contributing to Porffor :)
+
+This document hopes to help you understand Porffor-specific TS, specifically for writing built-ins (inside `compiler/builtins/*.ts` eg `btoa`, `String.prototype.trim`, ...). This guide isn't really meant for modifying the compiler itself yet (eg `compiler/codegen.js`), as built-ins are ~easier to implement and more useful at the moment.
+
+I mostly presume decent JS knowledge, with some basic TS too but nothing complicated. Knowing low-level stuff generally (pointers, etc) and/or Wasm (bytecode) is also a plus but hopefully not required.
+
+If you have any questions you can ask in [the Porffor Discord](https://discord.gg/6crs9Znx9R), please feel free to ask anything if you get stuck :)
+
+Please read this entire document before beginning as there are important things throughout.
+
+<br>
+
+## Setup
+
+1. Clone the repo and enter the repo (`git clone https://github.com/CanadaHonk/porffor.git`)
+2. `npm install`
+
+The repo comes with easy alias scripts for Unix and Windows, which you can use like so:
+- Unix: `./porf path/to/script.js`
+- Windows: `.\porf path/to/script.js`
+
+You can also swap out `node` in the alias to use another runtime like Deno (`deno run -A ...`) or Bun (`bun ...`), or just use it yourself (eg `node runner/index.js ...`, `bun runner/index.js ...`). Node, Deno, Bun should work.
+
+
+### Precompile
+
+**If you update any file inside `compiler/builtins` you will need to do this for it to update inside Porffor otherwise your changes will have no effect.** Run `node compiler/precompile.js` to precompile. It may error during this, if so, you might have an error in your code or there could be a compiler error with Porffor (feel free to ask for help as soon as you encounter any errors with it).
+
+<br>
+
+## Types
+
+Porffor has usual JS types (or at least the ones it supports), but also internal types for various reasons.
+
+### ByteString
+
+The most important and widely used internal type is ByteString. Regular strings in Porffor are UTF-16 encoded, so each character uses 2 bytes. ByteStrings are special strings which are used when the characters in a string only use ASCII/LATIN-1 characters, so the lower byte of the UTF-16 characters are unused. Instead of wasting memory with all the unused memory, ByteStrings instead use 1 byte per character. This halves memory usage of such strings and also makes operating on them faster. The downside is that many Porffor built-ins have to be written twice, slightly different, for both `String` and `ByteString` types.
+
+### i32
+
+This is complicated internally but essentially, only use it for pointers. (This is not signed or unsigned, instead it is the Wasm valtype `i32` so the signage is ~instruction dependant).
+
+<br>
+
+## Pointers
+
+Pointers are the main (and most difficult) unique feature you ~need to understand when dealing with objects (arrays, strings, ...).
+
+We'll explain things per common usage you will likely need to know:
+
+## Commonly used Wasm code
+
+### Get a pointer
+
+```js
+Porffor.wasm`local.get ${foobar}`
+```
+
+Gets the pointer to the variable `foobar`. You don't really need to worry about how it works in detail, but essentially it gets the pointer as a number (type) instead of as the object it is.
+
+### Store a character in a ByteString
+
+```js
+Porffor.wasm.i32.store8(pointer, characterCode, 0, 4)
+```
+
+Stores the character code `characterCode` at the pointer `pointer` **for a ByteString**.[^1]
+
+### Store a character in a String
+
+```js
+Porffor.wasm.i32.store16(pointer, characterCode, 0, 4)
+```
+
+Stores the character code `characterCode` at the pointer `pointer` **for a String**.[^1]
+
+### Load a character from a ByteString
+
+```js
+Porffor.wasm.i32.load8_u(pointer, 0, 4)
+```
+
+Loads the character code at the pointer `pointer` **for a ByteString**.[^1]
+
+### Load a character from a String
+
+```js
+Porffor.wasm.i32.load16_u(pointer, 0, 4)
+```
+
+Loads the character code at the pointer `pointer` **for a String**.[^1]
+
+### Manually store the length of an object
+
+```js
+Porffor.wasm.i32.store(pointer, length, 0, 0)
+```
+
+Stores the length `length` at pointer `pointer`, setting the length of an object. This is mostly unneeded today as you can just do `obj.length = length`. [^2]
+
+<br>
+
+## Example
+
+Here is the code for `ByteString.prototype.toUpperCase()`:
+
+```ts
+export const __ByteString_prototype_toUpperCase = (_this: bytestring) => {
+  const len: i32 = _this.length;
+
+  let out: bytestring = '';
+  Porffor.wasm.i32.store(out, len, 0, 0);
+
+  let i: i32 = Porffor.wasm`local.get ${_this}`,
+      j: i32 = Porffor.wasm`local.get ${out}`;
+
+  const endPtr: i32 = i + len;
+  while (i < endPtr) {
+    let chr: i32 = Porffor.wasm.i32.load8_u(i++, 0, 4);
+
+    if (chr >= 97) if (chr <= 122) chr -= 32;
+
+    Porffor.wasm.i32.store8(j++, chr, 0, 4);
+  }
+
+  return out;
+};
+```
+
+Now let's go through it section by section:
+
+```ts
+export const __ByteString_prototype_toUpperCase = (_this: bytestring) => {
+```
+
+Here we define a built-in for Porffor. Notably:
+- We do not use `a.b.c`, instead we use `__a_b_c`
+- We use a `_this` argument, as `this` does not exist in Porffor yet
+- We use an arrow function
+
+---
+
+```ts
+  const len: i32 = _this.length;
+
+  let out: bytestring = '';
+  Porffor.wasm.i32.store(out, len, 0, 0);
+```
+
+This sets up the `out` variable we are going to write to for the output of this function. We set the length in advance to be the same as `_this`, as `foo.length == foo.toLowerCase().length`, because we will later be manually writing to it using Wasm intrinsics, which will not update the length themselves.
+
+---
+
+```ts
+  let i: i32 = Porffor.wasm`local.get ${_this}`,
+      j: i32 = Porffor.wasm`local.get ${out}`;
+```
+
+Get the pointers for `_this` and `out` as `i32`s (~`number`s).
+
+---
+
+```ts
+  const endPtr: i32 = i + len;
+  while (i < endPtr) {
+```
+
+Set up an end target pointer as the pointer variable for `_this` plus the length of it. Loop below until that pointer reaches the end target, so we iterate through the entire string.
+
+---
+
+```ts
+    let chr: i32 = Porffor.wasm.i32.load8_u(i++, 0, 4);
+```
+
+Read the character (code) from the current `_this` pointer variable, and increment it so next iteration it reads the next character, etc.
+
+---
+
+```ts
+    if (chr >= 97) if (chr <= 122) chr -= 32;
+```
+
+If the character code is >= 97 (`a`) and <= 122 (`z`), decrease it by 32, making it an upper case character. eg: 97 (`a`) - 32 = 65 (`A`).
+
+---
+
+```ts
+    Porffor.wasm.i32.store8(j++, chr, 0, 4);
+```
+
+Store the character code into the `out` pointer variable, and increment it.
+
+<br>
+
+## Porffor-specific TS notes
+
+- For declaring variables, you must use explicit type annotations currently (eg `let a: number = 1`, not `let a = 1`)
+- You might spot `Porffor.fastOr`/`Porffor.fastAnd`, these are non-short circuiting versions of `||`/`&&`, taking any number of conditions as arguments. You shouldn't don't need to use or worry about these.
+- **There are ~no objects, you cannot use them/literals.**
+- Attempt to avoid string/array-heavy code and use more variables instead if possible, easier on memory and CPU/perf.
+
+<br>
+
+## Formatting/linting
+
+There is 0 setup for this (right now). You can try looking through the other built-ins files but do not worry about it a lot, I honestly do not mind going through and cleaning up after a PR as long as the code itself is good :^)
+
+<br>
+
+## Commit (message) style
+
+You should ideally have one commit per notable change (using amend/force push). Commit messages should be like `${file}: ${description}`. Don't be afraid to use long titles if needed, but try and be short if possible. Bonus points for detail in commit description. ~~Gold star for jokes in description too.~~
+
+Examples:
+```
+builtins/date: impl toJSON
+builtins/date: fix ToIntegerOrInfinity returning -0
+codegen: fix inline wasm for unreachable
+builtins/array: wip toReversed
+builtins/tostring_number: impl radix
+```
+
+<br>
+
+## Test262
+
+Make sure you have Test262 cloned already **inside of `test262/`** (`git clone https://github.com/tc39/test262.git test262/test262`).
+
+Run `node test262` to run all the tests and get an output of total overall test results. The main thing you want to pay attention to is the emoji summary (lol):
+```
+🧪 50005 | 🤠 7007 (-89) | ❌ 1914 (-32) | 💀 13904 (-61) | 📝 23477 (-120) | ⏰ 2 | 🏗 2073 (+302) | 💥 1628
+```
+
+To break this down:
+🧪 total 🤠 pass ❌ fail 💀 runtime error 📝 todo (error) ⏰ timeout 🏗️ wasm compile error 💥 compile error
+
+The diff compared to the last commit (with test262 data) is shown in brackets. Basically, you can passes 🤠 up, and errors 💀📝🏗💥 down. It is fine if some errors change balance/etc, as long as they are not new failures.
+
+It will also log new passes/fails. Be careful as sometimes the overall passes can increase, but other files have also regressed into failures which you might miss. Also keep in mind some tests may have been false positives before, but we can investigate the diff together :)
+
+### Debugging tips
+
+- Use `node test262 path/to/tests` to run specific test262 dirs/files (eg `node test262 built-ins/Date`).
+- Use `--log-errors` to log the errors of individual tests.
+- Use `--debug-asserts` to log expected/actual of assertion failures (experimental).
+
+<br>
+
+[^1]: The `0, 4` args are necessary for the Wasm instruction, but you don't need to worry about them (`0` alignment, `4` byte offset for length).
+
+[^2]: The `0, 4` args are necessary for the Wasm instruction, but you don't need to worry about them (`0` alignment, `0` byte offset).

package/README.md

@@ -14,60 +14,68 @@ Porffor is primarily built from scratch, the only thing that is not is the parse
 Expect nothing to work! Only very limited JS is currently supported. See files in `bench` for examples.
 
 ### Setup
-1. Clone this repo (`git clone https://github.com/CanadaHonk/porffor.git`)
-2. `npm install` - for parser(s)
+**`npm install -g porffor`**. It's that easy (hopefully) :)
 
-### Running a file
-The repos comes with easy alias files for Unix and Windows, which you can use like so:
-- Unix: `./porf path/to/script.js`
-- Windows: `.\porf path/to/script.js`
+### Trying a REPL
+**`porf`**. Just run it with no script file argument.
 
-Please note that further examples below will just use `./porf`, you need to use `.\porf` on Windows. You can also swap out `node` in the alias to use another runtime like Deno (`deno run -A`) or Bun (`bun ...`), or just use it yourself (eg `node runner/index.js ...`, `bun runner/index.js ...`). Node and Bun should work great, Deno support is WIP.
+### Running a JS file
+**`porf path/to/script.js`**
 
-### Trying a REPL
-**`./porf`**. Just run it with no script file argument.
+### Compiling to Wasm
+**`porf wasm path/to/script.js out.wasm`**. Currently it does not use an import standard like WASI, so it is mostly unusable on its own.
 
 ### Compiling to native binaries
 > [!WARNING]
 > Compiling to native binaries uses [2c](#2c), Porffor's own Wasm -> C compiler, which is experimental.
 
-**`./porf native path/to/script.js out(.exe)`**. You can specify the compiler with `-compiler=clang/zig/gcc`, and which opt level to use with `-cO=O3` (`Ofast` by default). Output binaries are also stripped by default.
+**`porf native path/to/script.js out(.exe)`**. You can specify the compiler with `--compiler=clang/zig/gcc`, and which opt level to use with `--cO=O3` (`Ofast` by default). Output binaries are also stripped by default.
 
 ### Compiling to C
 > [!WARNING]
 > Compiling to C uses [2c](#2c), Porffor's own Wasm -> C compiler, which is experimental.
 
-**`./porf c path/to/script.js (out.c)`**. When not including an output file, it will be printed to stdout instead.
+**`porf c path/to/script.js (out.c)`**. When not including an output file, it will be printed to stdout instead.
+
+### Profiling a JS file
+> [!WARNING]
+> Very experimental WIP feature!
+
+**`porf profile path/to/script.js`**
+
+### Debugging a JS file
+> [!WARNING]
+> Very experimental WIP feature!
+
+**`porf debug path/to/script.js`**
+
+### Profiling the generated Wasm of a JS file
+> [!WARNING]
+> Very experimental WIP feature!
+
+**`porf debug-wasm path/to/script.js`**
 
-### Compiling to a Wasm binary
-**`./porf compile path/to/script.js out.wasm`**. Currently it does not use an import standard like WASI, so it is mostly unusable.
 
 ### Options
-- `-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
-- `-parser=acorn|@babel/parser|meriyah|hermes-parser` (default: `acorn`) to set which parser to use
-- `-parse-types` to enable parsing type annotations/typescript. if `-parser` is unset, changes default to `@babel/parser`. does not type check
-- `-opt-types` to perform optimizations using type annotations as compiler hints. does not type check
-- `-valtype=i32|i64|f64` (default: `f64`) to set valtype
+- `--parser=acorn|@babel/parser|meriyah|hermes-parser` (default: `acorn`) to set which parser to use
+- `--parse-types` to enable parsing type annotations/typescript. if `-parser` is unset, changes default to `@babel/parser`. does not type check
+- `--opt-types` to perform optimizations using type annotations as compiler hints. does not type check
+- `--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). unstable
 - `-O3` to enable advanceder opt (precompute const math). unstable
-- `-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
-- `-ast-log` to log AST
-- `-opt-funcs` to log funcs after opt
-- `-sections` to log sections as hex
-- `-opt-no-inline` to not inline any funcs
-- `-tail-call` to enable tail calls (experimental + not widely implemented)
-- `-compile-hints` to enable V8 compilation hints (experimental + doesn't seem to do much?)
+- `--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
+- `--ast-log` to log AST
+- `--opt-funcs` to log funcs after opt
+- `--sections` to log sections as hex
+- `--opt-no-inline` to not inline any funcs
+- `--tail-call` to enable tail calls (experimental + not widely implemented)
+- `--compile-hints` to enable V8 compilation hints (experimental + doesn't seem to do much?)
 
 ## Limitations
 - No full object support yet
@@ -151,24 +159,28 @@ These include some early (stage 1/0) and/or dead (last commit years ago) proposa
 - Array member setting (`arr[0] = 2`, `arr[0] += 2`, etc)
 - Array constructor (`Array(5)`, `new Array(1, 2, 3)`)
 - Labelled statements (`foo: while (...)`)
-- `do...while`
+- `do...while` loops
 
 ### Built-ins
 
-- `NaN` and `Infinity` (f64 only)
-- `isNaN()` and `isFinite()` (f64 only)
-- Most of `Number` (`MAX_VALUE`, `MIN_VALUE`, `MAX_SAFE_INTEGER`, `MIN_SAFE_INTEGER`, `POSITIVE_INFINITY`, `NEGATIVE_INFINITY`, `EPSILON`, `NaN`, `isNaN`, `isFinite`, `isInteger`, `isSafeInteger`) (some f64 only)
-- Some `Math` funcs (`sqrt`, `abs`, `floor`, `sign`, `round`, `trunc`, `clz32`, `fround`, `random`) (f64 only)
+- `NaN` and `Infinity`
+- `isNaN()` and `isFinite()`
+- Most of `Number` (`MAX_VALUE`, `MIN_VALUE`, `MAX_SAFE_INTEGER`, `MIN_SAFE_INTEGER`, `POSITIVE_INFINITY`, `NEGATIVE_INFINITY`, `EPSILON`, `NaN`, `isNaN`, `isFinite`, `isInteger`, `isSafeInteger`)
+- Some `Math` funcs (`sqrt`, `abs`, `floor`, `sign`, `round`, `trunc`, `clz32`, `fround`, `random`)
 - Basic `globalThis` support
 - Basic `Boolean` and `Number`
 - Basic `eval` for literals
 - `Math.random()` using self-made xorshift128+ PRNG
 - Some of `performance` (`now()`, `timeOrigin`)
-- Some of `Array.prototype` (`at`, `push`, `pop`, `shift`, `fill`)
+- Some of `Array.prototype` (`at`, `push`, `pop`, `shift`, `fill`, `slice`, `indexOf`, `lastIndexOf`, `includes`, `with`, `reverse`, `toReversed`)
 - Some of `Array` (`of`, `isArray`)
-- Some of `String.prototype` (`at`, `charAt`, `charCodeAt`)
+- Most of `String.prototype` (`at`, `charAt`, `charCodeAt`, `toUpperCase`, `toLowerCase`, `startsWith`, `endsWith`, `indexOf`, `lastIndexOf`, `includes`, `padStart`, `padEnd`, `substring`, `substr`, `slice`, `trimStart`, `trimEnd`, `trim`, `toString`, `big`, `blink`, `bold`, `fixed`, `italics`, `small`, `strike`, `sub`, `sup`,  `trimLeft`, `trimRight`, )
 - Some of `crypto` (`randomUUID`)
 - `escape`
+- `btoa`
+- Most of `Number.prototype` (`toString`, `toFixed`, `toExponential`)
+- `parseInt`
+- Spec-compliant `Date`
 
 ### Custom
 
@@ -186,7 +198,7 @@ Mostly for reducing size. I do not really care about compiler perf/time as long
 ### Traditional opts
 - Inlining functions (WIP, limited)
 - Inline const math ops
-- Tail calls (behind flag `-tail-call`)
+- Tail calls (behind flag `--tail-call`)
 
 ### Wasm transforms
 - `local.set`, `local.get` -> `local.tee`
@@ -272,8 +284,6 @@ No particular order and no guarentees, just what could happen soon™
   - Run precompiled Wasm file if given
 - Docs
   - Update codebase readme section
-- REPL
-  - Basic polyfill of `node:repl` for non-Node runtimes to work
 - Cool proposals
   - [Optional Chaining Assignment](https://github.com/tc39/proposal-optional-chaining-assignment)
   - [Modulus and Additional Integer Math](https://github.com/tc39/proposal-integer-and-modulus-math)
@@ -293,6 +303,15 @@ No particular order and no guarentees, just what could happen soon™
 ## VSCode extension
 There is a vscode extension in `vscode-ext` which tweaks JS syntax highlighting to be nicer with porffor features (eg highlighting wasm inside of inline asm).
 
+## Wasm proposals used
+Porffor intentionally does not use Wasm proposals which are not commonly implemented yet (eg GC) so it can be used in as many places as possible.
+
+- Multi-value **(required)**
+- Non-trapping float-to-int conversions **(required)**
+- Bulk memory operations (required, but uncommonly used)
+- Exception handling (optional, for errors)
+- Tail calls (opt-in, off by default)
+
 ## Isn't this the same as AssemblyScript/other Wasm langs?
 No. they are not alike at all internally and have very different goals/ideals:
 - Porffor is made as a generic JS engine, not for Wasm stuff specifically

package/asur/index.js

@@ -1244,7 +1244,7 @@ paused = _paused;`);
 });
 
 export const instantiate = async (binary, importImpls) => {
-  const _vm = process?.argv?.includes('-wasm-debug') ? await wasmDebugVm() : vm;
+  const _vm = process?.argv?.includes('--wasm-debug') ? await wasmDebugVm() : vm;
 
   const parsed = parse(binary);
   const exports = {};

package/compiler/assemble.js

@@ -154,7 +154,7 @@ export default (funcs, globals, tags, pages, data, flags) => {
 
   const exports = funcs.filter(x => x.export).map((x, i) => [ ...encodeString(x.name === 'main' ? 'm' : x.name), ExportDesc.func, x.index ]);
 
-  if (Prefs.alwaysMemory && pages.size === 0) pages.set('-always-memory', 0);
+  if (Prefs.alwaysMemory && pages.size === 0) pages.set('--always-memory', 0);
   if (optLevel === 0) pages.set('O0 precaution', 0);
 
   const usesMemory = pages.size > 0;

package/compiler/builtins/annexb_string.js

@@ -1,5 +1,5 @@
 export default () => {
-  let out = `// @porf -funsafe-no-unlikely-proto-checks -valtype=i32
+  let out = `// @porf --funsafe-no-unlikely-proto-checks --valtype=i32
 `;
 
   const annexB_noArgs = (a0, a1) => out += `
@@ -31,7 +31,7 @@ ${[...a1].map((x, i) => `  Porffor.wasm.i32.store16(outPtr, ${x.charCodeAt(0)},
 
   return out;
 };
-export const ___bytestring_prototype_${a0} = (_this: bytestring) => {
+export const __ByteString_prototype_${a0} = (_this: bytestring) => {
   let out: bytestring = Porffor.bs\`<${a1}>\`;
 
   let outPtr: i32 = Porffor.wasm\`local.get \${out}\` + ${2 + a1.length};

package/compiler/builtins/annexb_string.ts

@@ -1,12 +1,11 @@
-// @porf -funsafe-no-unlikely-proto-checks -valtype=i32
+// @porf --funsafe-no-unlikely-proto-checks --valtype=i32
 
-// todo: trimLeft, trimRight
 export const __String_prototype_trimLeft = (_this: string) => {
   return __String_prototype_trimStart(_this);
 };
 
-export const ___bytestring_prototype_trimLeft = (_this: string) => {
-  return ___bytestring_prototype_trimStart(_this);
+export const __ByteString_prototype_trimLeft = (_this: string) => {
+  return __ByteString_prototype_trimStart(_this);
 };
 
 
@@ -14,6 +13,6 @@ export const __String_prototype_trimRight = (_this: string) => {
   return __String_prototype_trimEnd(_this);
 };
 
-export const ___bytestring_prototype_trimEnd = (_this: string) => {
-  return ___bytestring_prototype_trimRight(_this);
+export const __ByteString_prototype_trimEnd = (_this: string) => {
+  return __ByteString_prototype_trimRight(_this);
 };

package/compiler/builtins/array.ts

@@ -1,10 +1,10 @@
-// @porf -funsafe-no-unlikely-proto-checks
+// @porf --funsafe-no-unlikely-proto-checks
 
 export const __Array_isArray = (x: unknown): boolean =>
-  // Porffor.wasm`local.get ${x+1}` == Porffor.TYPES._array;
-  Porffor.rawType(x) == Porffor.TYPES._array;
+  // Porffor.wasm`local.get ${x+1}` == Porffor.TYPES.array;
+  Porffor.rawType(x) == Porffor.TYPES.array;
 
-export const ___array_prototype_slice = (_this: any[], start: number, end: number) => {
+export const __Array_prototype_slice = (_this: any[], start: number, end: number) => {
   const len: i32 = _this.length;
   if (Porffor.rawType(end) == Porffor.TYPES.undefined) end = len;
 
@@ -44,7 +44,7 @@ export const ___array_prototype_slice = (_this: any[], start: number, end: numbe
   return out;
 };
 
-export const ___array_prototype_indexOf = (_this: any[], searchElement: any, position: number) => {
+export const __Array_prototype_indexOf = (_this: any[], searchElement: any, position: number) => {
   const len: i32 = _this.length;
   if (position > 0) {
     if (position > len) position = len;
@@ -58,7 +58,7 @@ export const ___array_prototype_indexOf = (_this: any[], searchElement: any, pos
   return -1;
 };
 
-export const ___array_prototype_lastIndexOf = (_this: any[], searchElement: any, position: number) => {
+export const __Array_prototype_lastIndexOf = (_this: any[], searchElement: any, position: number) => {
   const len: i32 = _this.length;
   if (position > 0) {
     if (position > len) position = len;
@@ -72,7 +72,7 @@ export const ___array_prototype_lastIndexOf = (_this: any[], searchElement: any,
   return -1;
 };
 
-export const ___array_prototype_includes = (_this: any[], searchElement: any, position: number) => {
+export const __Array_prototype_includes = (_this: any[], searchElement: any, position: number) => {
   const len: i32 = _this.length;
   if (position > 0) {
     if (position > len) position = len;
@@ -86,7 +86,7 @@ export const ___array_prototype_includes = (_this: any[], searchElement: any, po
   return false;
 };
 
-export const ___array_prototype_with = (_this: any[], index: number, value: any) => {
+export const __Array_prototype_with = (_this: any[], index: number, value: any) => {
   const len: i32 = _this.length;
   if (index < 0) {
     index = len + index;
@@ -111,7 +111,7 @@ export const ___array_prototype_with = (_this: any[], index: number, value: any)
   return out;
 };
 
-export const ___array_prototype_reverse = (_this: any[]) => {
+export const __Array_prototype_reverse = (_this: any[]) => {
   const len: i32 = _this.length;
 
   let start: i32 = 0;
@@ -127,7 +127,7 @@ export const ___array_prototype_reverse = (_this: any[]) => {
 };
 
 // todo: this has memory/allocation bugs so sometimes crashes :(
-export const ___array_prototype_toReversed = (_this: any[]) => {
+export const __Array_prototype_toReversed = (_this: any[]) => {
   const len: i32 = _this.length;
 
   let start: i32 = 0;

package/compiler/builtins/base64.ts

@@ -1,82 +1,4 @@
-// @porf -funsafe-no-unlikely-proto-checks -valtype=i32
-
-// while (len >= 8) {
-//   Porffor.wasm`
-// local tmp i64
-// local.get ${i}
-// i64.load 0 4
-// local.set tmp
-
-// local k i64
-// i64.const 0
-// local.set k
-
-// loop 64
-// local.get ${j}
-
-// local.get ${keyStrPtr}
-
-// local.get tmp
-
-// ;; k * 6
-// i64.const 58
-
-// local.get k
-// i64.const 6
-// i64.mul
-
-// i64.sub
-
-// ;; tmp >> (58 - (k * 6))
-// i64.shr_u
-
-// ;; (tmp >> (58 - (k * 6))) & 0x3f
-// i64.const 63
-// i64.and
-
-// i32.wrap_i64
-
-// ;; keyStrPtr + ...
-// i32.add
-
-// ;; load character from keyStr
-// i32.load8_u 0 4
-
-// ;; store in output at j
-// i32.store8 0 4
-
-// local.get ${j}
-// i32.const 1
-// i32.add
-// local.set ${j}
-
-// local.get k
-// i64.const 1
-// i64.add
-// local.tee k
-
-// i64.const 8
-// i64.lt_s
-// br_if 0
-// end
-
-// `;
-
-//   // len -= 6;
-//   i += 6;
-// }
-
-//     // while (k < 8) {
-//     //   Porffor.wasm.i32.store8(j++, Porffor.wasm.i32.load8_u(keyStrPtr + Porffor.wasm.i32.wrap_i64(Porffor.wasm.i64.and(
-//     //     Porffor.wasm.i64.shr_u(tmp, Porffor.wasm.i64.extend_i32_u(58 - k * 6)),
-//     //     Porffor.wasm.i64.const(0x3f)
-//     //   )), 0, 4), 0, 4);
-//     //   k += 1;
-//     // }
-
-//     i += 6;
-//     len -= 6;
-//   }
+// @porf --funsafe-no-unlikely-proto-checks --valtype=i32
 
 export const btoa = (input: bytestring): bytestring => {
   const keyStr: bytestring = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
@@ -89,6 +11,8 @@ export const btoa = (input: bytestring): bytestring => {
   let i: i32 = Porffor.wasm`local.get ${input}`,
       j: i32 = Porffor.wasm`local.get ${output}`;
 
+  // todo/perf: add some per 6 char variant using bitwise magic
+
   const endPtr = i + len;
   while (i < endPtr) {
     const chr1: i32 = Porffor.wasm.i32.load8_u(i++, 0, 4);
@@ -116,6 +40,7 @@ export const btoa = (input: bytestring): bytestring => {
   return output;
 };
 
+// todo: impl atob by converting below to "porf ts"
 /* var atob = function (input) {
   const keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
 

package/compiler/builtins/crypto.ts

@@ -1,4 +1,4 @@
-// @porf -funsafe-no-unlikely-proto-checks -valtype=i32
+// @porf --funsafe-no-unlikely-proto-checks --valtype=i32
 
 export const __crypto_randomUUID = (): bytestring => {
   let bytes: bytestring = '................';