porffor 0.17.0-048c6f2ee → 0.17.0-0564424f4

package/compiler/builtins/string_f64.ts

@@ -1,10 +1,8 @@
-// todo: support non-bytestring properly
-export const String = (value: any): bytestring => {
-  if (Porffor.rawType(value) == Porffor.TYPES.symbol) return __Symbol_prototype_toString(value);
-  return __ecma262_ToString(value);
-};
+import type {} from './porffor.d.ts';
 
+// todo: support non-bytestring properly
 // todo: support constructor/string objects properly
-export const String$constructor = (value: any): bytestring => {
+export const String = function (value: any): bytestring {
+  if (!new.target && Porffor.rawType(value) == Porffor.TYPES.symbol) return __Symbol_prototype_toString(value);
   return __ecma262_ToString(value);
 };

package/compiler/builtins/symbol.ts

@@ -17,7 +17,8 @@ export const __Porffor_symbol_descStore = (op: boolean, value: any): any => {
 
 export const Symbol = (description: any): Symbol => {
   // 1-based so always truthy as numeric value
-  return __Porffor_symbol_descStore(true, description) + 1;
+  const ptr: Symbol = __Porffor_symbol_descStore(true, description) + 1;
+  return ptr;
 };
 
 export const __Symbol_prototype_description$get = (_this: Symbol) => {

package/compiler/builtins/typedarray.js

@@ -0,0 +1,94 @@
+export default async () => {
+  let out = '';
+
+  const arrayCode = (await import('node:fs')).readFileSync(globalThis.precompileCompilerPath + '/builtins/array.ts', 'utf8');
+  const typedArrayFuncs = [...arrayCode.matchAll(/\/\/ @porf-typed-array[\s\S]+?^};$/gm)].map(x => x[0]);
+
+  const constr = name => out += `export const ${name} = function (arg: any): ${name} {
+  if (!new.target) throw new TypeError("Constructor ${name} requires 'new'");
+
+  const out: ${name} = Porffor.allocate();
+  let len: i32 = 0;
+
+  const type: i32 = Porffor.rawType(arg);
+  if (Porffor.fastOr(
+    type == Porffor.TYPES.array,
+    type == Porffor.TYPES.string, type == Porffor.TYPES.bytestring,
+    type == Porffor.TYPES.set
+  )) {
+    let i: i32 = 0;
+    for (const x of arg) {
+      out[i++] = x;
+    }
+    len = i;
+  } else if (type == Porffor.TYPES.number) {
+    len = arg;
+  }
+
+  out.length = len;
+  return out;
+};
+
+export const __${name}_prototype_byteLength$get = (_this: ${name}) => {
+  return _this.length * ${name}.BYTES_PER_ELEMENT;
+};
+
+export const __${name}_prototype_at = (_this: ${name}, index: number) => {
+  const len: i32 = _this.length;
+  index |= 0;
+  if (index < 0) {
+    index = len + index;
+    if (index < 0) return undefined;
+  }
+  if (index >= len) return undefined;
+
+  return _this[index];
+};
+
+export const __${name}_prototype_slice = (_this: ${name}, 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: ${name} = Porffor.allocate();
+
+  if (start > end) return out;
+
+  let i: i32 = start;
+  let j: i32 = 0;
+  while (i < end) {
+    out[j++] = _this[i++];
+  }
+
+  out.length = end - start;
+  return out;
+};
+
+${typedArrayFuncs.reduce((acc, x) => acc + x.replace('// @porf-typed-array\n', '').replaceAll('Array', name).replaceAll('any[]', name) + '\n\n', '')}
+`;
+
+  constr('Uint8Array');
+  constr('Int8Array');
+  constr('Uint8ClampedArray');
+  constr('Uint16Array');
+  constr('Int16Array');
+  constr('Uint32Array');
+  constr('Int32Array');
+  constr('Float32Array');
+  constr('Float64Array');
+
+  return out;
+};

package/compiler/builtins/z_ecma262.ts

@@ -1,4 +1,5 @@
 // general widely used ecma262/spec functions
+import type {} from './porffor.d.ts';
 
 // 7.1.5 ToIntegerOrInfinity (argument)
 // https://tc39.es/ecma262/#sec-tointegerorinfinity

package/compiler/builtins.js

@@ -160,6 +160,16 @@ export const BuiltinVars = function() {
   this.__performance_timeOrigin = [
     [ Opcodes.call, importedFuncs.timeOrigin ]
   ];
+
+  this.__Uint8Array_BYTES_PER_ELEMENT = number(1);
+  this.__Int8Array_BYTES_PER_ELEMENT = number(1);
+  this.__Uint8ClampedArray_BYTES_PER_ELEMENT = number(1);
+  this.__Uint16Array_BYTES_PER_ELEMENT = number(2);
+  this.__Int16Array_BYTES_PER_ELEMENT = number(2);
+  this.__Uint32Array_BYTES_PER_ELEMENT = number(4);
+  this.__Int32Array_BYTES_PER_ELEMENT = number(4);
+  this.__Float32Array_BYTES_PER_ELEMENT = number(4);
+  this.__Float64Array_BYTES_PER_ELEMENT = number(8);
 };
 
 export const BuiltinFuncs = function() {
@@ -184,6 +194,21 @@ export const BuiltinFuncs = function() {
     ]
   };
 
+  this['f64_**'] = this['i32_**'] = {
+    params: [ valtypeBinary, valtypeBinary ],
+    locals: [],
+    returns: [ valtypeBinary ],
+    returnType: TYPES.number,
+    wasm: (scope, { builtin }) => [
+      [ Opcodes.local_get, 0 ],
+      ...number(TYPES.number, Valtype.i32),
+      [ Opcodes.local_get, 1 ],
+      ...number(TYPES.number, Valtype.i32),
+      [ Opcodes.call, builtin('__Math_pow') ],
+      [ Opcodes.drop ],
+    ]
+  };
+
   // add bitwise ops by converting operands to i32 first
   for (const [ char, op ] of [ ['&', Opcodes.i32_and], ['|', Opcodes.i32_or], ['^', Opcodes.i32_xor], ['<<', Opcodes.i32_shl], ['>>', Opcodes.i32_shr_s], ['>>>', Opcodes.i32_shr_u] ]) {
     this[`f64_${char}`] = {