porffor 0.2.0-fdf0fc5 → 0.14.0-0ad2c8a7c

package/compiler/builtins/array.ts

@@ -1,4 +1,4 @@
-// @porf --funsafe-no-unlikely-proto-checks
+import type {} from './porffor.d.ts';
 
 export const __Array_isArray = (x: unknown): boolean =>
   // Porffor.wasm`local.get ${x+1}` == Porffor.TYPES.array;
@@ -29,14 +29,16 @@ export const __Array_prototype_slice = (_this: any[], start: number, end: number
   let outPtr: i32 = Porffor.wasm`local.get ${out}`;
   let thisPtr: i32 = Porffor.wasm`local.get ${_this}`;
 
-  const thisPtrEnd: i32 = thisPtr + end * 8;
+  const thisPtrEnd: i32 = thisPtr + end * 9;
 
-  thisPtr += start * 8;
+  thisPtr += start * 9;
 
   while (thisPtr < thisPtrEnd) {
     Porffor.wasm.f64.store(outPtr, Porffor.wasm.f64.load(thisPtr, 0, 4), 0, 4);
-    thisPtr += 8;
-    outPtr += 8;
+    Porffor.wasm.i32.store8(outPtr + 8, Porffor.wasm.i32.load8_u(thisPtr + 8, 0, 4), 0, 4);
+
+    thisPtr += 9;
+    outPtr += 9;
   }
 
   out.length = end - start;
@@ -91,14 +93,12 @@ export const __Array_prototype_with = (_this: any[], index: number, value: any)
   if (index < 0) {
     index = len + index;
     if (index < 0) {
-      // todo: throw RangeError: Invalid index
-      return null;
+      throw new RangeError('Invalid index');
     }
   }
 
   if (index > len) {
-    // todo: throw RangeError: Invalid index
-    return null;
+    throw new RangeError('Invalid index');
   }
 
   // todo: allocator is bad here?
@@ -146,4 +146,80 @@ export const __Array_prototype_toReversed = (_this: any[]) => {
 
 export const __Array_prototype_valueOf = (_this: any[]) => {
   return _this;
+};
+
+
+export const __Array_prototype_forEach = (_this: any[], callbackFn: any) => {
+  const len: i32 = _this.length;
+  let i: i32 = 0;
+  while (i < len) {
+    callbackFn(_this[i], i++, _this);
+  }
+};
+
+export const __Array_prototype_filter = (_this: any[], callbackFn: any) => {
+  const out: any[] = [];
+
+  const len: i32 = _this.length;
+  let i: i32 = 0;
+  while (i < len) {
+    const el: any = _this[i];
+    if (Boolean(callbackFn(el, i++, _this))) out.push(el);
+  }
+
+  return out;
+};
+
+export const __Array_prototype_map = (_this: any[], callbackFn: any) => {
+  const out: any[] = [];
+
+  const len: i32 = _this.length;
+  let i: i32 = 0;
+  while (i < len) {
+    out.push(callbackFn(_this[i], i++, _this));
+  }
+
+  return out;
+};
+
+export const __Array_prototype_find = (_this: any[], callbackFn: any) => {
+  const len: i32 = _this.length;
+  let i: i32 = 0;
+  while (i < len) {
+    const el: any = _this[i];
+    if (Boolean(callbackFn(el, i++, _this))) return el;
+  }
+};
+
+export const __Array_prototype_findLast = (_this: any[], callbackFn: any) => {
+  let i: i32 = _this.length;
+  while (i > 0) {
+    const el: any = _this[--i];
+    if (Boolean(callbackFn(el, i, _this))) return el;
+  }
+};
+
+export const __Array_prototype_findIndex = (_this: any[], callbackFn: any) => {
+  const len: i32 = _this.length;
+  let i: i32 = 0;
+  while (i < len) {
+    if (Boolean(callbackFn(_this[i], i++, _this))) return i;
+  }
+};
+
+export const __Array_prototype_findLastIndex = (_this: any[], callbackFn: any) => {
+  let i: i32 = _this.length;
+  while (i > 0) {
+    if (Boolean(callbackFn(_this[--i], i, _this))) return i;
+  }
+};
+
+export const __Array_prototype_every = (_this: any[], callbackFn: any) => {
+  const len: i32 = _this.length;
+  let i: i32 = 0;
+  while (i < len) {
+    if (!Boolean(callbackFn(_this[i], i++, _this))) return false;
+  }
+
+  return true;
 };

package/compiler/builtins/base64.ts

@@ -1,4 +1,5 @@
-// @porf --funsafe-no-unlikely-proto-checks --valtype=i32
+// @porf --valtype=i32
+import type {} from './porffor.d.ts';
 
 export const btoa = (input: bytestring): bytestring => {
   const keyStr: bytestring = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';

package/compiler/builtins/boolean.ts

@@ -1,4 +1,4 @@
-// @porf --funsafe-no-unlikely-proto-checks
+import type {} from './porffor.d.ts';
 
 // 20.3.3.2 Boolean.prototype.toString ()
 // https://tc39.es/ecma262/#sec-boolean.prototype.tostring
@@ -17,4 +17,4 @@ export const __Boolean_prototype_toString = (_this: boolean) => {
 export const __Boolean_prototype_valueOf = (_this: boolean) => {
   // 1. Return ? ThisBooleanValue(this value).
   return _this;
-};
+};

package/compiler/builtins/console.ts

@@ -0,0 +1,4 @@
+export const __console_clear = (): void => {
+  const clear: bytestring = '\x1b[1;1H\x1b[J';
+  Porffor.print(clear);
+};

package/compiler/builtins/crypto.ts

@@ -1,4 +1,5 @@
-// @porf --funsafe-no-unlikely-proto-checks --valtype=i32
+// @porf --valtype=i32
+import type {} from './porffor.d.ts';
 
 export const __crypto_randomUUID = (): bytestring => {
   let bytes: bytestring = '................';

package/compiler/builtins/date.ts

@@ -1,4 +1,4 @@
-// @porf --funsafe-no-unlikely-proto-checks
+import type {} from './porffor.d.ts';
 
 // 21.4.1.3 Day (t)
 // https://tc39.es/ecma262/multipage/numbers-and-dates.html#sec-day
@@ -1774,8 +1774,7 @@ export const __Date_prototype_toISOString = (_this: Date) => {
 
   // 4. If tv is NaN, throw a RangeError exception.
   if (Number.isNaN(tv)) {
-    // todo throw
-    return;
+    throw new RangeError('Invalid time value');
   }
 
   // 5. Assert: tv is an integral Number.

package/compiler/builtins/error.js

@@ -0,0 +1,22 @@
+export default () => {
+  let out = '';
+
+  const error = name => out += `export const ${name} = (message: bytestring) => {
+  return {};
+};
+
+export const ${name}$constructor = (message: bytestring) => {
+  return {};
+};`;
+
+  error('Error');
+  error('AggregateError');
+  error('TypeError');
+  error('ReferenceError');
+  error('SyntaxError');
+  error('RangeError');
+  error('EvalError');
+  error('URIError');
+
+  return out;
+};

package/compiler/builtins/escape.ts

@@ -1,6 +1,5 @@
-// @porf --funsafe-no-unlikely-proto-checks --valtype=i32
-
-import type {} from './porffor';
+// @porf --valtype=i32
+import type {} from './porffor.d.ts';
 
 export const escape = (input: string|bytestring): bytestring => {
   // we have no byte array yet so use bytestring with 0x00 and 0x01 via escape characters

package/compiler/builtins/function.ts

@@ -1,4 +1,4 @@
-// // @porf --funsafe-no-unlikely-proto-checks
+import type {} from './porffor.d.ts';
 
 export const __Function_prototype_toString = (_this: Function) => {
   // todo: actually use source

package/compiler/builtins/int.ts

@@ -1,4 +1,4 @@
-// @porf --funsafe-no-unlikely-proto-checks
+import type {} from './porffor.d.ts';
 
 // radix: number|any for rawType check
 // export const parseInt = (input: string|bytestring, radix: number|any): f64 => {

package/compiler/builtins/math.ts

@@ -0,0 +1,410 @@
+import type {} from './porffor.d.ts';
+
+// todo: use any and Number(x) in all these later
+// todo: specify the rest of this file later
+// todo/perf: make i32 variants later
+// todo/perf: add a compiler pref for accuracy vs perf (epsilion?)
+
+export const __Math_exp = (x: number): number => {
+  if (!Number.isFinite(x)) {
+    if (x == -Infinity) return 0;
+    return x;
+  }
+
+  if (x < 0) {
+    // exp(-x) = 1 / exp(+x)
+    return 1 / Math.exp(-x);
+  }
+
+  const k: number = Math.floor(x / Math.LN2);
+  const r: number = x - k * Math.LN2;
+
+  // Taylor series via Horner's method
+  let term: number = r;
+  let sum: number = 1 + r;
+  let i: number = 2;
+
+  while (Math.abs(term) > 1e-15) {
+    term *= r / i;
+    sum += term;
+    i++;
+  }
+
+  return sum * (1 << k);
+};
+
+export const __Math_log2 = (y: number): number => {
+  if (y <= 0) return NaN;
+  if (!Number.isFinite(y)) return y;
+
+  // approx using log knowledge
+  let x: number = y;
+  let exponent: number = 0;
+
+  while (x >= 2) {
+    x /= 2;
+    exponent++;
+  }
+
+  while (x < 1) {
+    x *= 2;
+    exponent--;
+  }
+
+  // 1 <= x < 2 -> 0 <= x < 1
+  x -= 1;
+
+  // refine with Newton-Raphson method
+  let delta: number;
+  do {
+    const e_x: number = Math.exp(x * Math.LN2);
+    delta = (e_x - y) / (e_x * Math.LN2);
+    x -= delta;
+  } while (Math.abs(delta) > 1e-15);
+
+  return x + exponent;
+};
+
+export const __Math_log = (y: number): number => {
+  if (y <= 0) {
+    if (y == 0) return -Infinity;
+    return NaN;
+  }
+  if (!Number.isFinite(y)) return y;
+
+  // guess using log knowledge
+  let x: number = y > 1 ? Math.log2(y) : 0;
+
+  // refine with Newton-Raphson method
+  let delta: number;
+  do {
+    const e_x: number = Math.exp(x);
+    delta = (e_x - y) / e_x;
+    x -= delta;
+  } while (Math.abs(delta) > 1e-15);
+
+  return x;
+};
+
+export const __Math_log10 = (x: number): number => {
+  if (x <= 0) {
+    if (x == 0) return -Infinity;
+    return NaN;
+  }
+  if (!Number.isFinite(x)) return x;
+
+  return Math.log(x) / Math.LN10;
+};
+
+// 21.3.2.26 Math.pow (base, exponent)
+// https://tc39.es/ecma262/#sec-math.pow
+export const __Math_pow = (base: number, exponent: number): number => {
+  // 1. Set base to ? ToNumber(base).
+  // 2. Set exponent to ? ToNumber(exponent).
+  // todo
+
+  // 3. Return Number::exponentiate(base, exponent).
+
+  // Number::exponentiate (base, exponent)
+  // https://tc39.es/ecma262/#sec-numeric-types-number-exponentiate
+  // 1. If exponent is NaN, return NaN.
+  if (Number.isNaN(exponent)) return NaN;
+
+  // 2. If exponent is either +0𝔽 or -0𝔽, return 1𝔽.
+  if (exponent == 0) return 1;
+
+  if (!Number.isFinite(base)) {
+    // 3. If base is NaN, return NaN.
+    if (Number.isNaN(base)) return base;
+
+    // 4. If base is +∞𝔽, then
+    if (base == Infinity) {
+      // a. If exponent > +0𝔽, return +∞𝔽. Otherwise, return +0𝔽.
+      if (exponent > 0) return base;
+      return 0;
+    }
+
+    // 5. If base is -∞𝔽, then
+    const isOdd = exponent % 2 == 1;
+
+    // a. If exponent > +0𝔽, then
+    if (exponent > 0) {
+      // i. If exponent is an odd integral Number, return -∞𝔽. Otherwise, return +∞𝔽.
+      if (isOdd) return -Infinity;
+      return Infinity;
+    }
+
+    // b. Else,
+    // i. If exponent is an odd integral Number, return -0𝔽. Otherwise, return +0𝔽.
+    if (isOdd) return -0;
+    return 0;
+  }
+
+  if (base == 0) {
+    // 6. If base is +0𝔽, then
+    if (1 / base == Infinity) {
+      // a. If exponent > +0𝔽, return +0𝔽. Otherwise, return +∞𝔽.
+      if (exponent > 0) return 0;
+      return Infinity;
+    }
+
+    // 7. If base is -0𝔽, then
+    const isOdd = exponent % 2 == 1;
+
+    // a. If exponent > +0𝔽, then
+    if (exponent > 0) {
+      // i. If exponent is an odd integral Number, return -0𝔽. Otherwise, return +0𝔽.
+      if (isOdd) return -0;
+      return 0;
+    }
+
+    // b. Else,
+    // i. If exponent is an odd integral Number, return -∞𝔽. Otherwise, return +∞𝔽.
+    if (isOdd) return -Infinity;
+    return Infinity;
+  }
+
+  // 8. Assert: base is finite and is neither +0𝔽 nor -0𝔽.
+  // todo
+
+  // 9. If exponent is +∞𝔽, then
+  if (exponent == Infinity) {
+    const abs = Math.abs(base);
+
+    // a. If abs(ℝ(base)) > 1, return +∞𝔽.
+    if (abs > 1) return Infinity;
+
+    // b. If abs(ℝ(base)) = 1, return NaN.
+    if (abs == 1) return NaN;
+
+    // c. If abs(ℝ(base)) < 1, return +0𝔽.
+    return 0;
+  }
+
+  // 10. If exponent is -∞𝔽, then
+  if (exponent == -Infinity) {
+    const abs = Math.abs(base);
+
+    // a. If abs(ℝ(base)) > 1, return +0𝔽.
+    if (abs > 1) return 0;
+
+    // b. If abs(ℝ(base)) = 1, return NaN.
+    if (abs == 1) return NaN;
+
+    // c. If abs(ℝ(base)) < 1, return +∞𝔽.
+    return Infinity;
+  }
+
+  // 11. Assert: exponent is finite and is neither +0𝔽 nor -0𝔽.
+  // todo
+
+  // 12. If base < -0𝔽 and exponent is not an integral Number, return NaN.
+  if (base < 0) if (!Number.isInteger(exponent)) return NaN;
+
+  // 13. Return an implementation-approximated Number value representing the result of raising ℝ(base) to the ℝ(exponent) power.
+  return Math.exp(exponent * Math.log(base));
+};
+
+
+export const __Math_expm1 = (x: number): number => {
+  if (!Number.isFinite(x)) {
+    if (x == -Infinity) return -1;
+    return x;
+  }
+
+  // use exp(x) - 1 for large x (perf)
+  if (Math.abs(x) > 1e-5) return Math.exp(x) - 1;
+
+  // Taylor series
+  let sum: number = x;
+  let term: number = x;
+  let i: number = 2;
+
+  while (Math.abs(term) > 1e-15) {
+    term *= x / i;
+    sum += term;
+    i++;
+  }
+
+  return sum;
+};
+
+export const __Math_log1p = (x: number): number => {
+  if (x == -1) return -Infinity; // log(0) = -inf
+  if (!Number.isFinite(x)) return x;
+
+  // use exp(x) - 1 for large x (perf)
+  if (Math.abs(x) > 1e-5) return Math.log(1 + x);
+
+  // Taylor series
+  let sum: number = 0;
+  let term: number = x;
+  let i: number = 2;
+
+  while (Math.abs(term) > 1e-15) {
+    term *= -x / i;
+    sum += term;
+    i++;
+  }
+
+  return sum;
+};
+
+
+export const __Math_sqrt = (y: number): number => {
+  if (y <= 0) {
+    if (y == 0) return 0;
+    return NaN;
+  }
+  if (!Number.isFinite(y)) return y;
+
+  // Babylonian method
+  let x: number = y;
+  let prev: number;
+
+  do {
+    prev = x;
+    x = 0.5 * (x + y / x);
+  } while (Math.abs(prev - x) > 1e-15);
+
+  return x;
+};
+
+export const __Math_cbrt = (y: number): number => {
+  if (y == 0) return 0; // cbrt(0) = 0
+  if (!Number.isFinite(y)) return y;
+
+  // Babylonian method
+  let x = Math.abs(y);
+
+  let prev: number;
+
+  do {
+    prev = x;
+    x = (2 * x + y / (x * x)) / 3;
+  } while (Math.abs(prev - x) > 1e-15);
+
+  return y < 0 ? -x : x;
+};
+
+
+// todo: varargs
+export const __Math_hypot = (x: number, y: number): number => Math.sqrt(x * x + y * y);
+
+export const __Math_sin = (x: number): number => {
+  // -inf <= x <= inf -> 0 <= x <= 2pi
+  const piX2: number = Math.PI * 2;
+  x %= piX2;
+  if (x < 0) x += piX2;
+
+  const x2: number = x * x;
+
+  return x * (
+    1 + x2 * (
+      -1.66666666666666307295e-1 + x2 * (
+        8.33333333332211858878e-3 + x2 * (
+          -1.98412698295895385996e-4 + x2 * (
+            2.75573136213857245213e-6 + x2 * (
+              -2.50507477628578072866e-8 + x2 * (
+                1.58962301576546568060e-10
+              )
+            )
+          )
+        )
+      )
+    )
+  );
+
+  // todo: investigate which is better (consider perf and accuracy)
+  // const x2 = x * x;
+  // const x4 = x2 * x2;
+  // const x6 = x4 * x2;
+  // const x8 = x4 * x4;
+  // const x10 = x6 * x4;
+  // const x12 = x6 * x6;
+  // const x14 = x12 * x2;
+
+  // return x * (
+  //   1 - x2 / 6 + x4 / 120 - x6 / 5040 + x8 / 362880 - x10 / 39916800 + x12 / 6227020800 - x14 / 1307674368000
+  // );
+};
+
+export const __Math_cos = (x: number): number => Math.sin(x - Math.PI / 2);
+export const __Math_tan = (x: number): number => Math.sin(x) / Math.cos(x);
+
+export const __Math_sinh = (x: number): number => (Math.exp(x) - Math.exp(-x)) / 2;
+export const __Math_cosh = (x: number): number => (Math.exp(x) + Math.exp(-x)) / 2;
+export const __Math_tanh = (x: number): number => Math.sinh(x) / Math.cosh(x);
+
+
+export const __Math_asinh = (x: number): number => Math.log(x + Math.sqrt(x * x + 1));
+export const __Math_acosh = (x: number): number => {
+  if (x < 1) return NaN;
+  return Math.log(x + Math.sqrt(x * x - 1));
+};
+export const __Math_atanh = (x: number): number => {
+  if (Math.abs(x) >= 1) return NaN;
+  return 0.5 * Math.log((1 + x) / (1 - x));
+};
+
+
+export const __Math_asin = (x: number): number => {
+  if (x <= -1) {
+    if (x == -1) return -Math.PI / 2;
+    return NaN;
+  }
+  if (x >= 1) {
+    if (x == 1) return Math.PI / 2;
+    return NaN;
+  }
+
+  // Taylor series
+  let sum: number = x;
+  let term: number = x;
+  let n: number = 1;
+
+  while (Math.abs(term) > 1e-15) {
+    term *= x * x * (2 * n - 1) * (2 * n - 1) / ((2 * n) * (2 * n + 1));
+    sum += term / (2 * n + 1);
+    n++;
+  }
+
+  return sum;
+};
+
+export const __Math_acos = (x: number): number => Math.asin(x) - Math.PI / 2;
+
+export const __Math_atan = (x: number): number => {
+  if (x == Infinity) return Math.PI / 2
+  if (x == -Infinity) return -Math.PI / 2;
+
+  // Taylor series
+  let sum: number = x;
+  let term: number = x;
+  let n: number = 1;
+
+  while (Math.abs(term) > 1e-15) {
+    term *= -x * x * (2 * n - 1) / ((2 * n) * (2 * n + 1));
+    sum += term;
+    n++;
+  }
+
+  return sum;
+};
+
+export const __Math_atan2 = (y: number, x: number): number => {
+  if (x == 0) {
+    if (y > 0) return Math.PI / 2;
+    if (y < 0) return -Math.PI / 2;
+
+    return NaN;
+  }
+
+  const ratio = y / x;
+  if (x > 0) {
+    return Math.atan(ratio);
+  }
+
+  if (y >= 0) return Math.atan(ratio) + Math.PI;
+  return Math.atan(ratio) - Math.PI;
+};

package/compiler/builtins/number.ts

@@ -1,4 +1,4 @@
-// @porf --funsafe-no-unlikely-proto-checks
+import type {} from './porffor.d.ts';
 
 // radix: number|any for rawType check
 export const __Number_prototype_toString = (_this: number, radix: number|any) => {
@@ -20,8 +20,7 @@ export const __Number_prototype_toString = (_this: number, radix: number|any) =>
 
   radix |= 0;
   if (radix < 2 || radix > 36) {
-    // todo: throw RangeError: toString() radix argument must be between 2 and 36
-    return out;
+    throw new RangeError('toString() radix argument must be between 2 and 36');
   }
 
   if (_this == 0) {
@@ -254,8 +253,7 @@ export const __Number_prototype_toFixed = (_this: number, fractionDigits: number
 
   fractionDigits |= 0;
   if (fractionDigits < 0 || fractionDigits > 100) {
-    // todo: throw RangeError: toFixed() digits argument must be between 0 and 100
-    return out;
+    throw new RangeError('toFixed() fractionDigits argument must be between 0 and 100');
   }
 
   // if negative value
@@ -349,8 +347,7 @@ export const __Number_prototype_toExponential = (_this: number, fractionDigits:
   } else {
     fractionDigits |= 0;
     if (fractionDigits < 0 || fractionDigits > 100) {
-      // todo: throw RangeError: toExponential() digits argument must be between 0 and 100
-      return out;
+      throw new RangeError('toExponential() fractionDigits argument must be between 0 and 100');
     }
   }
 

package/compiler/builtins/object.ts

@@ -1,4 +1,4 @@
-// // @porf --funsafe-no-unlikely-proto-checks
+import type {} from './porffor.d.ts';
 
 export const __Object_prototype_toString = (_this: object) => {
   let out: bytestring = '[object Object]';