porffor 0.2.0-623cdf0 → 0.2.0-67434d5

package/byg/index.js

@@ -0,0 +1,237 @@
+import fs from 'node:fs';
+
+const noAnsi = s => s.replace(/\u001b\[[0-9]+m/g, '');
+const printLine = (line, number, breakpoint = false, current = false, selected = false) => {
+  // console.log(`\x1b[${breakpoint ? (selected ? '106' : '46') : (selected ? '47' : '100')}m\x1b[${selected ? '30' : '97'}m${number.toFixed(0).padStart(4, ' ')}\x1b[${breakpoint ? (selected ? '96' : '36') : (selected ? '37' : '90')}m\x1b[${current ? '47' : '40'}m▌ \x1b[${current ? '47' : '40'}m\x1b[${current ? '30' : '37'}m${current ? noAnsi(line) : line}\x1b[0K`);
+  console.log(`\x1b[${breakpoint ? (selected ? '43' : '103') : (selected ? '47' : '100')}m\x1b[${selected || breakpoint ? '30' : '97'}m${number.toFixed(0).padStart(4, ' ')}\x1b[${breakpoint ? (selected ? '33' : '93') : (selected ? '37' : '90')}m\x1b[${current ? '47' : '40'}m▌ \x1b[${current ? '47' : '40'}m\x1b[${current ? '30' : '37'}m${current ? noAnsi(line) : line}\x1b[0K`);
+};
+
+const box = (x, y, width, height, title = '', content = [], color = ['90', '100', '37', '35', '45'], padding = true) => {
+  if (padding) {
+    width += 1;
+    height += 1;
+
+    // top
+    process.stdout.write(`\x1b[48m\x1b[${y + 1};${x + 1}H\x1b[${color[0]}m` + '▄'.repeat(width));
+
+    // bottom
+    process.stdout.write(`\x1b[${y + height + 1};${x + 1}H▝` + '▀'.repeat(width - 1) + '▘');
+
+    // left
+    process.stdout.write(`\x1b[${y + 1};${x + 1}H▗` + '\x1b[1B\x1b[1D▐'.repeat(height - 1));
+
+    // right
+    process.stdout.write(`\x1b[${y + 1};${x + width + 1}H▖` + '\x1b[1B\x1b[1D▌'.repeat(height - 1));
+
+    x += 1;
+    y += 1;
+    width -= 1;
+    height -= 1;
+  }
+
+  // bg
+  process.stdout.write(`\x1b[${y + 1};${x + 1}H\x1b[${color[1]}m` + ' '.repeat(width) + (`\x1b[1B\x1b[${width}D` + ' '.repeat(width)).repeat(Math.max(0, height - 1)));
+
+  // title
+  // if (title) process.stdout.write(`\x1b[${y + 1};${x + ((width - title.length) / 2 | 0) + 1}H\x1b[${color[1]}m\x1b[${color[2]}m\x1b[1m${title}\x1b[22m`);
+  // if (title) process.stdout.write(`\x1b[${y};${x}H\x1b[${color[3]}▗\x1b[${color[4]}m\x1b[${color[2]}m\x1b[1m${' '.repeat((width - title.length) / 2 | 0)}${title}${' '.repeat(width - (((width - title.length) / 2 | 0)) - title.length)}\x1b[0m\x1b[${color[4]}m▖`);
+  if (title) process.stdout.write(`\x1b[${y};${x}H\x1b[0m\x1b[${color[3]}m▐\x1b[${color[4]}m\x1b[${color[2]}m\x1b[1m${' '.repeat((width - title.length) / 2 | 0)}${title}${' '.repeat(width - (((width - title.length) / 2 | 0)) - title.length)}\x1b[0m\x1b[${color[3]}m▌`);
+
+  // content
+  process.stdout.write(`\x1b[${y + (title ? 1 : 1)};${x + 1}H\x1b[${color[1]}m\x1b[${color[2]}m${content.join(`\x1b[1B\x1b[${x + 1}G`)}`);
+};
+
+const controls = {
+  'ret': 'resume  ',
+  'b': 'breakpoint  ',
+  's': 'step over',
+  'i': 'step in',
+  'o': 'step out  ',
+};
+
+const controlInfo = Object.keys(controls).reduce((acc, x, i) => acc + `\x1B[45m\x1B[97m${x}\x1b[105m\x1b[37m ${controls[x]}  `, '');
+const plainControlInfo = noAnsi(controlInfo);
+
+globalThis.termWidth = process.stdout.columns || 80;
+globalThis.termHeight = process.stdout.rows || 24;
+
+export default ({ lines, pause, breakpoint }) => {
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  process.stdin.setEncoding('utf8');
+
+  process.stdin.on('data', s => {
+    // ctrl c
+    if (s === '\u0003') {
+      process.exit();
+    }
+
+    // process.stdout.write(s);
+
+    if (!paused) pause();
+  });
+
+  const stdin = fs.openSync('/dev/stdin', 'r+');
+  const readCharSync = () => {
+    const buffer = Buffer.alloc(1);
+    fs.readSync(stdin, buffer, 0, 1);
+    return buffer.toString('utf8');
+  };
+
+  const tooManyLines = lines.length > (termHeight - 1);
+  const breakpoints = {};
+
+  process.on('exit', () => {
+    process.stdout.write('\x1b[0m');
+    // console.clear();
+  });
+
+  console.clear();
+
+  let paused = true;
+  return (_paused, currentLine, text, boxes = []) => {
+    paused = _paused;
+
+    let scrollOffset = 0;
+    let currentLinePos = currentLine;
+
+    const draw = () => {
+      console.clear();
+      process.stdout.write(`\x1b[1;1H`);
+
+      if (tooManyLines) {
+        const edgePadding = (termHeight / 2) - 1;
+        let beforePadding = currentLine - edgePadding;
+        let afterPadding = currentLine + edgePadding + 1;
+
+        if (beforePadding < 0) {
+          afterPadding += Math.abs(beforePadding);
+          beforePadding = 0;
+        }
+
+        beforePadding += scrollOffset;
+        afterPadding += scrollOffset;
+
+        if (afterPadding > lines.length) {
+          beforePadding -= afterPadding - lines.length;
+          afterPadding = lines.length;
+        }
+
+        for (let i = Math.max(0, beforePadding); i < Math.max(0, beforePadding) + (termHeight - 1); i++) {
+          printLine(lines[i], i + 1, !!breakpoints[i], currentLine === i, currentLine + scrollOffset === i);
+        }
+
+        currentLinePos = currentLine - beforePadding;
+      } else {
+        for (let i = 0; i < lines.length; i++) {
+          printLine(lines[i], i + 1, !!breakpoints[i], currentLine === i, currentLine + scrollOffset === i);
+        }
+      }
+
+      for (const x of boxes) {
+        const y = x.y({ currentLinePos });
+        const height = x.height;
+        if (y < 0 || y >= termHeight) continue;
+
+        // crop box if > termHeight
+        // if (y + height >= termHeight) {
+        //   const excess = y + height - termHeight;
+        //   height -= excess;
+
+        //   content = content.slice(0, height - 2);
+        // }
+
+        box(x.x, y, x.width, height, x.title, x.content);
+      }
+
+      // text += ` | rss: ${(process.memoryUsage.rss() / 1024 / 1024).toFixed(2)}mb`;
+
+      process.stdout.write(`\x1b[${termHeight};1H\x1b[105m\x1b[37m${text}${' '.repeat(termWidth - plainControlInfo.length - noAnsi(text).length - 1)}${controlInfo} \x1b[0m`);
+    };
+
+    draw();
+
+    let lastSpecial = false;
+    while (true) {
+      const char = readCharSync();
+
+      if (char === '[') {
+        lastSpecial = true;
+        continue;
+      }
+
+      switch (char.toLowerCase()) {
+        case '\r': {
+          paused = false;
+          return 'resume';
+        }
+
+        case 's': {
+          return 'stepOver';
+        }
+
+        case 'i': {
+          return 'stepIn';
+        }
+
+        case 'o': {
+          return 'stepOut';
+        }
+
+        case 'b': {
+          if (!lastSpecial) { // b pressed normally
+            breakpoints[currentLine + scrollOffset] = !breakpoints[currentLine + scrollOffset];
+            draw();
+
+            breakpoint(currentLine + scrollOffset, breakpoints[currentLine + scrollOffset]);
+            break;
+          }
+
+          // arrow down
+          // if (screenOffset + termHeight <= lines.length) scrollOffset++;
+          if (scrollOffset < lines.length - currentLine - 1) scrollOffset++;
+          draw();
+          break;
+        }
+
+        case 'a': {
+          if (!lastSpecial) break;
+
+          // arrow up
+          // if (screenOffset > 0) scrollOffset--;
+          if (scrollOffset > -currentLine) scrollOffset--;
+          draw();
+
+          break;
+        }
+
+        case '5': {
+          if (!lastSpecial) break;
+
+          // page up
+          // scrollOffset -= Math.min(screenOffset, termHeight - 1);
+          scrollOffset -= Math.min(scrollOffset + currentLine, termHeight - 1);
+          draw();
+          break;
+        }
+
+        case '6': {
+          if (!lastSpecial) break;
+
+          // page down
+          // scrollOffset += Math.min((lines.length + 1) - (screenOffset + termHeight), termHeight - 1);
+          scrollOffset += Math.min(lines.length - (scrollOffset + currentLine) - 1, termHeight - 1);
+          draw();
+          break;
+        }
+
+        case 'q':
+        case '\u0003': {
+          process.exit();
+        }
+      }
+
+      lastSpecial = false;
+    }
+  };
+};

package/compiler/2c.js

@@ -17,12 +17,12 @@ const CValtype = {
   undefined: 'void'
 };
 
-const alwaysPreface = `typedef unsigned char i8;
-typedef unsigned short i16;
-typedef long i32;
-typedef unsigned long u32;
-typedef long long i64;
-typedef unsigned long long u64;
+const alwaysPreface = `typedef uint8_t i8;
+typedef uint16_t i16;
+typedef int32_t i32;
+typedef uint32_t u32;
+typedef int64_t i64;
+typedef uint64_t u64;
 typedef float f32;
 typedef double f64;
 
@@ -31,8 +31,7 @@ f64 NAN = 0e+0/0e+0;
 struct ReturnValue {
   ${CValtype.f64} value;
   ${CValtype.i32} type;
-};
-\n`;
+};\n\n`;
 
 // todo: is memcpy/etc safe with host endianness?
 
@@ -115,7 +114,7 @@ const todo = msg => {
     }
   }
 
-  throw new TodoError(`todo: ${msg}`);
+  throw new TodoError(msg);
 };
 
 const removeBrackets = str => {
@@ -148,7 +147,8 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
   const includes = new Map(), unixIncludes = new Map(), winIncludes = new Map();
   const prepend = new Map(), prependMain = new Map();
 
-  // presume all <i32 work is unsigned
+  includes.set('stdint.h', true);
+
   let out = ``;
 
   for (const x in globals) {
@@ -164,7 +164,7 @@ export default ({ funcs, globals, tags, data, exceptions, pages }) => {
   }
 
   if (data.length > 0) {
-    prependMain.set('_data', data.map(x => `memcpy(_memory + ${x.offset}, (char[]){${x.bytes.join(',')}}, ${x.bytes.length});`).join('\n'));
+    prependMain.set('_data', data.map(x => `memcpy(_memory + ${x.offset}, (unsigned char[]){${x.bytes.join(',')}}, ${x.bytes.length});`).join('\n'));
   }
 
   // for (const [ x, p ] of pages) {
@@ -624,7 +624,7 @@ _time_out = _time.tv_nsec / 1000000. + _time.tv_sec * 1000.;`);
 
   const makeIncludes = includes => [...includes.keys()].map(x => `#include <${x}>\n`).join('');
 
-  out = alwaysPreface + platformSpecific(makeIncludes(winIncludes), makeIncludes(unixIncludes), false) + '\n' + makeIncludes(includes) + '\n' + [...prepend.values()].join('\n') + '\n\n' + out;
+  out = platformSpecific(makeIncludes(winIncludes), makeIncludes(unixIncludes), false) + '\n' + makeIncludes(includes) + '\n' + alwaysPreface + [...prepend.values()].join('\n') + '\n\n' + out;
 
   return out.trim();
 };

package/compiler/{sections.js → assemble.js}

@@ -1,8 +1,9 @@
 import { Valtype, FuncType, Empty, ExportDesc, Section, Magic, ModuleVersion, Opcodes, PageSize } from './wasmSpec.js';
-import { encodeVector, encodeString, encodeLocal, unsignedLEB128, signedLEB128 } from './encoding.js';
-import { number } from './embedding.js';
+import { encodeVector, encodeString, encodeLocal, unsignedLEB128, signedLEB128, ieee754_binary64, unsignedLEB128_into, signedLEB128_into, ieee754_binary64_into } from './encoding.js';
+// import { number } from './embedding.js';
 import { importedFuncs } from './builtins.js';
 import { log } from "./log.js";
+import Prefs from './prefs.js';
 
 const createSection = (type, data) => [
   type,
@@ -26,12 +27,12 @@ export default (funcs, globals, tags, pages, data, flags) => {
 
   const optLevel = parseInt(process.argv.find(x => x.startsWith('-O'))?.[2] ?? 1);
 
-  const compileHints = process.argv.includes('-compile-hints');
-  if (compileHints) log.warning('sections', 'compile hints is V8 only w/ experimental arg! (you used -compile-hints)');
+  const compileHints = Prefs.compileHints;
+  if (compileHints) log.warning('assemble', 'compile hints is V8 only w/ experimental arg! (you used -compile-hints)');
 
   const getType = (params, returns) => {
     const hash = `${params.join(',')}_${returns.join(',')}`;
-    if (optLog) log('sections', `getType(${JSON.stringify(params)}, ${JSON.stringify(returns)}) -> ${hash} | cache: ${typeCache[hash]}`);
+    if (Prefs.optLog) log('assemble', `getType(${JSON.stringify(params)}, ${JSON.stringify(returns)}) -> ${hash} | cache: ${typeCache[hash]}`);
     if (optLevel >= 1 && typeCache[hash] !== undefined) return typeCache[hash];
 
     const type = [ FuncType, ...encodeVector(params), ...encodeVector(returns) ];
@@ -44,7 +45,7 @@ export default (funcs, globals, tags, pages, data, flags) => {
 
   let importFuncs = [];
 
-  if (optLevel < 1) {
+  if (optLevel < 1 || !Prefs.treeshakeWasmImports) {
     importFuncs = importedFuncs;
   } else {
     let imports = new Map();
@@ -79,11 +80,11 @@ export default (funcs, globals, tags, pages, data, flags) => {
   }
   globalThis.importFuncs = importFuncs;
 
-  if (optLog) log('sections', `treeshake: using ${importFuncs.length}/${importedFuncs.length} imports`);
+  if (Prefs.optLog) log('assemble', `treeshake: using ${importFuncs.length}/${importedFuncs.length} imports`);
 
   const importSection = importFuncs.length === 0 ? [] : createSection(
     Section.import,
-    encodeVector(importFuncs.map(x => [ 0, ...encodeString(x.import), ExportDesc.func, getType(new Array(x.params).fill(valtypeBinary), new Array(x.returns).fill(valtypeBinary)) ]))
+    encodeVector(importFuncs.map(x => [ 0, ...encodeString(x.import), ExportDesc.func, getType(new Array(x.params).fill(x.name.startsWith('profile') ? Valtype.i32 : valtypeBinary), new Array(x.returns).fill(valtypeBinary)) ]))
   );
 
   const funcSection = createSection(
@@ -95,18 +96,65 @@ export default (funcs, globals, tags, pages, data, flags) => {
   // https://github.com/WebAssembly/design/issues/1473#issuecomment-1431274746
   const chSection = !compileHints ? [] : customSection(
     'compilationHints',
-    // for now just do everything as optimise eager
+    // for now just do everything as optimize eager
     encodeVector(funcs.map(_ => chHint(0x02, 0x02, 0x02)))
   );
 
-  const globalSection = Object.keys(globals).length === 0 ? [] : createSection(
-    Section.global,
-    encodeVector(Object.keys(globals).map(x => [ globals[x].type, 0x01, ...number(globals[x].init ?? 0, globals[x].type).flat(), Opcodes.end ]))
-  );
+  // const t0 = performance.now();
+
+  // specially optimized assembly for globals as this version is much (>5x) faster than traditional createSection(...)
+  const globalsValues = Object.values(globals);
+
+  let globalSection = [];
+  if (globalsValues.length > 0) {
+    let data = unsignedLEB128(globalsValues.length);
+    for (let i = 0; i < globalsValues.length; i++) {
+      const global = globalsValues[i];
+
+      switch (global.type) {
+        case Valtype.i32:
+          if (i > 0) data.push(Opcodes.end, Valtype.i32, 0x01, Opcodes.i32_const);
+            else data.push(Valtype.i32, 0x01, Opcodes.i32_const);
+
+          signedLEB128_into(global.init ?? 0, data);
+          break;
+
+        case Valtype.i64:
+          if (i > 0) data.push(Opcodes.end, Valtype.i64, 0x01, Opcodes.i64_const);
+            else data.push(Valtype.i64, 0x01, Opcodes.i64_const);
+
+          signedLEB128_into(global.init ?? 0, data);
+          break;
+
+        case Valtype.f64:
+          if (i > 0) data.push(Opcodes.end, Valtype.f64, 0x01, Opcodes.f64_const);
+            else data.push(Valtype.f64, 0x01, Opcodes.f64_const);
+
+          ieee754_binary64_into(global.init ?? 0, data);
+          break;
+      }
+    }
+
+    data.push(Opcodes.end);
+
+    globalSection.push(Section.global);
+
+    unsignedLEB128_into(data.length, globalSection);
+    globalSection = globalSection.concat(data);
+  }
+
+  // if (Prefs.profileCompiler) {
+  //   const log = console.log;
+  //   console.log = function () {
+  //     log.apply(this, arguments);
+  //     console.log = log;
+  //     console.log(`  a. assembled global section in ${(performance.now() - t0).toFixed(2)}ms\n`);
+  //   };
+  // }
 
   const exports = funcs.filter(x => x.export).map((x, i) => [ ...encodeString(x.name === 'main' ? 'm' : x.name), ExportDesc.func, x.index ]);
 
-  if (process.argv.includes('-always-memory') && 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;
@@ -169,7 +217,7 @@ export default (funcs, globals, tags, pages, data, flags) => {
     unsignedLEB128(data.length)
   );
 
-  if (process.argv.includes('-sections')) console.log({
+  if (Prefs.sections) console.log({
     typeSection: typeSection.map(x => x.toString(16)),
     importSection: importSection.map(x => x.toString(16)),
     funcSection: funcSection.map(x => x.toString(16)),

package/compiler/builtins/annexb_string.js

@@ -0,0 +1,72 @@
+export default () => {
+  let out = `// @porf -funsafe-no-unlikely-proto-checks -valtype=i32
+`;
+
+  const annexB_noArgs = (a0, a1) => out += `
+export const __String_prototype_${a0} = (_this: string) => {
+  let out: string = Porffor.s\`<${a1}>\`;
+
+  let outPtr: i32 = Porffor.wasm\`local.get \${out}\` + ${(2 + a1.length) * 2};
+
+  let thisPtr: i32 = Porffor.wasm\`local.get \${_this}\`;
+  let thisLen: i32 = _this.length;
+  let endPtr: i32 = thisPtr + thisLen * 2;
+
+  while (thisPtr < endPtr) {
+    let chr: i32 = Porffor.wasm.i32.load16_u(thisPtr, 0, 4);
+    Porffor.wasm.i32.store16(outPtr, chr, 0, 4);
+
+    thisPtr += 2;
+    outPtr += 2;
+  }
+
+  Porffor.wasm.i32.store16(outPtr, 60, 0, 4); // <
+  Porffor.wasm.i32.store16(outPtr, 47, 0, 6); // /
+
+${[...a1].map((x, i) => `  Porffor.wasm.i32.store16(outPtr, ${x.charCodeAt(0)}, 0, ${8 + i * 2}); // ${x}`).join('\n')}
+
+  Porffor.wasm.i32.store16(outPtr, 62, 0, ${8 + a1.length * 2}); // >
+
+  out.length = thisLen + ${a1.length * 2 + 2 + 3};
+
+  return out;
+};
+export const ___bytestring_prototype_${a0} = (_this: bytestring) => {
+  let out: bytestring = Porffor.bs\`<${a1}>\`;
+
+  let outPtr: i32 = Porffor.wasm\`local.get \${out}\` + ${2 + a1.length};
+
+  let thisPtr: i32 = Porffor.wasm\`local.get \${_this}\`;
+  let thisLen: i32 = _this.length;
+  let endPtr: i32 = thisPtr + thisLen;
+
+  while (thisPtr < endPtr) {
+    let chr: i32 = Porffor.wasm.i32.load8_u(thisPtr++, 0, 4);
+    Porffor.wasm.i32.store8(outPtr++, chr, 0, 4);
+  }
+
+  Porffor.wasm.i32.store8(outPtr, 60, 0, 4); // <
+  Porffor.wasm.i32.store8(outPtr, 47, 0, 5); // /
+
+${[...a1].map((x, i) => `  Porffor.wasm.i32.store8(outPtr, ${x.charCodeAt(0)}, 0, ${6 + i}); // ${x}`).join('\n')}
+
+  Porffor.wasm.i32.store8(outPtr, 62, 0, ${6 + a1.length}); // >
+
+  out.length = thisLen + ${a1.length * 2 + 2 + 3};
+
+  return out;
+};
+`;
+
+  annexB_noArgs('big', 'big');
+  annexB_noArgs('blink', 'blink');
+  annexB_noArgs('bold', 'b');
+  annexB_noArgs('fixed', 'tt');
+  annexB_noArgs('italics', 'i');
+  annexB_noArgs('small', 'small');
+  annexB_noArgs('strike', 'strike');
+  annexB_noArgs('sub', 'sub');
+  annexB_noArgs('sup', 'sup');
+
+  return out;
+};

package/compiler/builtins/annexb_string.ts

@@ -0,0 +1,19 @@
+// @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 __String_prototype_trimRight = (_this: string) => {
+  return __String_prototype_trimEnd(_this);
+};
+
+export const ___bytestring_prototype_trimEnd = (_this: string) => {
+  return ___bytestring_prototype_trimRight(_this);
+};

package/compiler/builtins/array.ts

@@ -0,0 +1,145 @@
+// @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;
+
+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;
+
+  start |= 0;
+  end |= 0;
+
+  if (start < 0) {
+    start = len + start;
+    if (start < 0) start = 0;
+  }
+  if (start > len) start = len;
+  if (end < 0) {
+    end = len + end;
+    if (end < 0) end = 0;
+  }
+  if (end > len) end = len;
+
+  let out: any[] = [];
+
+  if (start > end) return out;
+
+  let outPtr: i32 = Porffor.wasm`local.get ${out}`;
+  let thisPtr: i32 = Porffor.wasm`local.get ${_this}`;
+
+  const thisPtrEnd: i32 = thisPtr + end * 8;
+
+  thisPtr += start * 8;
+
+  while (thisPtr < thisPtrEnd) {
+    Porffor.wasm.f64.store(outPtr, Porffor.wasm.f64.load(thisPtr, 0, 4), 0, 4);
+    thisPtr += 8;
+    outPtr += 8;
+  }
+
+  out.length = end - start;
+
+  return out;
+};
+
+export const ___array_prototype_indexOf = (_this: any[], searchElement: any, position: number) => {
+  const len: i32 = _this.length;
+  if (position > 0) {
+    if (position > len) position = len;
+      else position |= 0;
+  } else position = 0;
+
+  for (let i: i32 = position; i < len; i++) {
+    if (_this[i] == searchElement) return i;
+  }
+
+  return -1;
+};
+
+export const ___array_prototype_lastIndexOf = (_this: any[], searchElement: any, position: number) => {
+  const len: i32 = _this.length;
+  if (position > 0) {
+    if (position > len) position = len;
+      else position |= 0;
+  } else position = 0;
+
+  for (let i: i32 = len - 1; i >= position; i--) {
+    if (_this[i] == searchElement) return i;
+  }
+
+  return -1;
+};
+
+export const ___array_prototype_includes = (_this: any[], searchElement: any, position: number) => {
+  const len: i32 = _this.length;
+  if (position > 0) {
+    if (position > len) position = len;
+      else position |= 0;
+  } else position = 0;
+
+  for (let i: i32 = position; i < len; i++) {
+    if (_this[i] == searchElement) return true;
+  }
+
+  return false;
+};
+
+export const ___array_prototype_with = (_this: any[], index: number, value: any) => {
+  const len: i32 = _this.length;
+  if (index < 0) {
+    index = len + index;
+    if (index < 0) {
+      // todo: throw RangeError: Invalid index
+      return null;
+    }
+  }
+
+  if (index > len) {
+    // todo: throw RangeError: Invalid index
+    return null;
+  }
+
+  // todo: allocator is bad here?
+  let out: any[] = [];
+
+  Porffor.clone(_this, out);
+
+  out[index] = value;
+
+  return out;
+};
+
+export const ___array_prototype_reverse = (_this: any[]) => {
+  const len: i32 = _this.length;
+
+  let start: i32 = 0;
+  let end: i32 = len - 1;
+
+  while (start < end) {
+    const tmp: i32 = _this[start];
+    _this[start++] = _this[end];
+    _this[end--] = tmp;
+  }
+
+  return _this;
+};
+
+// todo: this has memory/allocation bugs so sometimes crashes :(
+export const ___array_prototype_toReversed = (_this: any[]) => {
+  const len: i32 = _this.length;
+
+  let start: i32 = 0;
+  let end: i32 = len - 1;
+
+  let out: any[] = [];
+  out.length = len;
+
+  while (start < end) {
+    out[start] = _this[end];
+    out[end--] = _this[start++];
+  }
+
+  return out;
+};