Porffor API Reference

Porffor.malloc(bytes?: i32): any

// Allocate an array
const arr: any[] = Porffor.malloc();
arr.length = 10;

// Allocate with specific size (advanced)
const buffer: any = Porffor.malloc(1024);

Porffor.memorySize(): i32

Porffor.wasm`...instructions...`

// Load operations
Porffor.wasm.i32.load(pointer: any, align: i32, offset: i32): i32
Porffor.wasm.i32.load16_u(pointer: any, align: i32, offset: i32): i32
Porffor.wasm.i32.load8_u(pointer: any, align: i32, offset: i32): i32

// Store operations
Porffor.wasm.i32.store(pointer: any, value: i32, align: i32, offset: i32): i32
Porffor.wasm.i32.store16(pointer: any, value: i32, align: i32, offset: i32): i32
Porffor.wasm.i32.store8(pointer: any, value: i32, align: i32, offset: i32): i32

// Create constant
Porffor.wasm.i32.const(value: i32): i32

// Store character in ByteString (8-bit)
const ptr: i32 = Porffor.wasm`local.get ${str}`;
Porffor.wasm.i32.store8(ptr, 65, 0, 4); // Write 'A'

// Store character in String (16-bit)
Porffor.wasm.i32.store16(ptr, 65, 0, 4); // Write 'A'

// Load character from ByteString
const charCode: i32 = Porffor.wasm.i32.load8_u(ptr, 0, 4);

// Load character from String
const charCode: i32 = Porffor.wasm.i32.load16_u(ptr, 0, 4);

// Store object length
Porffor.wasm.i32.store(ptr, length, 0, 0);

Porffor.wasm.f64.load(pointer: any, align: i32, offset: i32): f64
Porffor.wasm.f64.store(pointer: any, value: f64, align: i32, offset: i32): f64
Porffor.wasm.f64.eq(a: f64, b: f64): boolean

const ptr: i32 = Porffor.wasm`local.get ${arr}`;
Porffor.wasm.f64.store(ptr, 3.14159, 0, 0);
const value: f64 = Porffor.wasm.f64.load(ptr, 0, 0);

Porffor.type(x: any): i32

if (Porffor.type(value) == Porffor.TYPES.string) {
  // value is a string
}

const TYPES = {
  number: i32,
  boolean: i32,
  string: i32,
  undefined: i32,
  object: i32,
  function: i32,
  symbol: i32,
  bigint: i32,
  
  // Internal types
  array: i32,
  regexp: i32,
  bytestring: i32,
  date: i32,
  set: i32,
  // ... more types
}

const checkType = (val: any) => {
  const t = Porffor.type(val);
  
  if (t == Porffor.TYPES.number) return 'number';
  if (t == Porffor.TYPES.string) return 'string';
  if (t == Porffor.TYPES.bytestring) return 'bytestring';
  if (t == Porffor.TYPES.array) return 'array';
  
  return 'other';
};

Porffor.typeName(type: i32): bytestring

const t = Porffor.type(value);
console.log(Porffor.typeName(t)); // "string", "number", etc.

Porffor.object.isObject(arg: any): boolean
Porffor.object.isObjectOrNull(arg: any): boolean
Porffor.object.isObjectOrSymbol(arg: any): boolean

Porffor.object.get(obj: any, key: any): any
Porffor.object.set(obj: object, key: any, value: any): any
Porffor.object.define(obj: object, key: any, value: any, flags: i32): void
Porffor.object.delete(obj: object, key: any): boolean

Porffor.object.lookup(obj: object, target: any): i32

Porffor.object.preventExtensions(obj: object): void
Porffor.object.isInextensible(obj: object): boolean

// Check/set property flags
Porffor.object.overrideAllFlags(obj: object, overrideOr: i32, overrideAnd: i32): void
Porffor.object.checkAllFlags(obj: object, dataAnd: i32, accessorAnd: i32, dataExpected: i32, accessorExpected: i32): boolean
Porffor.object.isEnumerable(entryPtr: i32): boolean

Porffor.object.packAccessor(get: any, set: any): f64
Porffor.object.accessorGet(entryPtr: i32): Function
Porffor.object.accessorSet(entryPtr: i32): Function

Porffor.array.fastPush(arr: any[], el: any): i32

const arr: any[] = [];
Porffor.array.fastPush(arr, 'hello');
Porffor.array.fastPush(arr, 42);

Porffor.array.fastIndexOf(arr: any[], el: any): i32

Porffor.array.fastRemove(arr: any[], i: i32): void

Porffor.bytestring.appendStr(str: bytestring, appendage: bytestring): i32
Porffor.bytestring.appendChar(str: bytestring, char: i32): i32
Porffor.bytestring.append2Char(str: bytestring, char1: i32, char2: i32): i32
Porffor.bytestring.appendPadNum(str: bytestring, num: number, len: number): i32

let result: bytestring = '';
Porffor.bytestring.appendStr(result, 'Hello');
Porffor.bytestring.appendChar(result, 32); // space
Porffor.bytestring.appendStr(result, 'World');

Porffor.s(...args: any): string        // UTF-16 string
Porffor.bs(...args: any): bytestring   // ByteString

Porffor.number.getExponent(v: f64): i32

Porffor.funcLut.flags(func: Function): i32
Porffor.funcLut.length(func: Function): i32
Porffor.funcLut.name(func: Function): bytestring

function myFunc(a: number, b: number) { return a + b; }

console.log(Porffor.funcLut.name(myFunc));   // "myFunc"
console.log(Porffor.funcLut.length(myFunc)); // 2

Porffor.clone(source: any, destination: any): void

Porffor.print(x: any): i32
Porffor.printStatic(str: string): void

Porffor.randomByte(): i32

Porffor.fastOr(...args: any): boolean   // Evaluates all conditions
Porffor.fastAnd(...args: any): boolean  // Evaluates all conditions

// Regular || short-circuits, this doesn't
if (Porffor.fastOr(
  value < 0,
  value > 100,
  !Number.isInteger(value)
)) {
  throw new RangeError('Invalid value');
}

Porffor.set.read(ptr: any, index: number): i32
Porffor.set.write(ptr: any, index: number, value: any): boolean

Porffor.arraybuffer.detach(buffer: any): void

type i32 = number;      // 32-bit integer (use for pointers)
type i64 = number;      // 64-bit integer
type f64 = number;      // 64-bit float (standard number)
type bytestring = string; // ASCII/Latin-1 optimized string

ecma262.ToIntegerOrInfinity(argument: unknown): number
ecma262.ToIndex(value: unknown): number
ecma262.ToString(argument: unknown): bytestring
ecma262.ToNumber(argument: unknown): number
ecma262.ToNumeric(argument: unknown): number
ecma262.ToPropertyKey(argument: unknown): any
ecma262.IsConstructor(argument: unknown): boolean

export const __Array_prototype_at = (_this: any[], index: any) => {
  const len: i32 = _this.length;
  index = ecma262.ToIntegerOrInfinity(index);
  
  const relativeIndex: i32 = index;
  const k: i32 = relativeIndex >= 0 ? relativeIndex : len + relativeIndex;
  
  if (k < 0 || k >= len) return undefined;
  return _this[k];
};