porffor 0.55.17 → 0.55.18

package/compiler/codegen.js

@@ -136,7 +136,12 @@ const funcRef = func => {
       }
     }
 
-    if (func.returns.length === 1) {
+    if (func.returns.length === 0) {
+      // add to stack if returns nothing
+      wasm.push(number(UNDEFINED));
+    }
+
+    if (func.returns.length < 2) {
       // add built-in returnType if only returns a value
       wasm.push(number(func.returnType ?? TYPES.number, Valtype.i32));
     }
@@ -353,6 +358,9 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
 
       return cacheAst(decl, [ number(UNDEFINED) ]);
 
+    case 'TSAsExpression':
+      return cacheAst(decl, generate(scope, decl.expression));
+
     default:
       // ignore typescript nodes
       if (decl.type.startsWith('TS') ||
@@ -539,12 +547,10 @@ const generateYield = (scope, decl) => {
     ...getNodeType(scope, arg),
 
     [ Opcodes.call, includeBuiltin(scope, scope.async ? '__Porffor_AsyncGenerator_yield' : '__Porffor_Generator_yield').index ],
-    [ Opcodes.drop ],
-    [ Opcodes.drop ],
 
     // return generator
     [ Opcodes.local_get, scope.locals['#generator_out'].idx ],
-    number(scope.async ? TYPES.__porffor_asyncgenerator : TYPES.__porffor_generator, Valtype.i32),
+    ...(scope.returnType != null ? [] : [ number(scope.async ? TYPES.__porffor_asyncgenerator : TYPES.__porffor_generator, Valtype.i32) ]),
     [ Opcodes.return ],
 
     // use undefined as yield expression value
@@ -565,8 +571,9 @@ const generateReturn = (scope, decl) => {
       ...generate(scope, arg),
       ...getNodeType(scope, arg),
 
+      // return generator
       [ Opcodes.call, includeBuiltin(scope, scope.async ? '__Porffor_AsyncGenerator_return' : '__Porffor_Generator_return').index ],
-      // returns generator
+      ...(scope.returnType != null ? [] : [ number(scope.async ? TYPES.__porffor_asyncgenerator : TYPES.__porffor_generator, Valtype.i32) ]),
       [ Opcodes.return ]
     ];
   }
@@ -581,16 +588,18 @@ const generateReturn = (scope, decl) => {
       number(TYPES.promise, Valtype.i32),
 
       [ Opcodes.call, includeBuiltin(scope, '__Porffor_promise_resolve').index ],
-      [ Opcodes.drop ],
-      [ Opcodes.drop ],
 
       // return promise
       [ Opcodes.local_get, scope.locals['#async_out_promise'].idx ],
-      number(TYPES.promise, Valtype.i32),
+      ...(scope.returnType != null ? [] : [ number(TYPES.promise, Valtype.i32) ]),
       [ Opcodes.return ]
     ];
   }
 
+  if (scope.returns.length === 0) return [
+    [ Opcodes.return ]
+  ];
+
   if (
     scope.constr && // only do this in constructors
     !globalThis.precompile // skip in precompiled built-ins, we should not require this and handle it ourselves
@@ -650,7 +659,7 @@ const generateReturn = (scope, decl) => {
       ]),
 
       [ Opcodes.local_get, localTmp(scope, '#return') ],
-      [ Opcodes.local_get, localTmp(scope, '#return#type', Valtype.i32) ],
+      ...(scope.returnType != null ? [] : [ [ Opcodes.local_get, localTmp(scope, '#return#type', Valtype.i32) ] ]),
       [ Opcodes.return ]
     ];
   }
@@ -757,8 +766,7 @@ const compareStrings = (scope, left, right, leftType, rightType, noConv = false)
     Opcodes.i32_to_u,
     ...rightType,
 
-    [ Opcodes.call, includeBuiltin(scope, '__Porffor_strcmp').index ],
-    [ Opcodes.drop ]
+    [ Opcodes.call, includeBuiltin(scope, '__Porffor_strcmp').index ]
   ];
 
   return [
@@ -771,7 +779,6 @@ const compareStrings = (scope, left, right, leftType, rightType, noConv = false)
     ...rightType,
 
     [ Opcodes.call, includeBuiltin(scope, '__Porffor_compareStrings').index ],
-    [ Opcodes.drop ],
 
     // convert valtype result to i32 as i32 output expected
     Opcodes.i32_trunc_sat_f64_u
@@ -1527,6 +1534,11 @@ const getNodeType = (scope, node) => {
   let guess = null;
   const ret = (() => {
     if (node._type) return node._type;
+
+    if (node.type === 'TSAsExpression') {
+      return extractTypeAnnotation(node).type;
+    }
+
     if (node.type === 'Literal') {
       if (node.regex) return TYPES.regexp;
 
@@ -1549,7 +1561,7 @@ const getNodeType = (scope, node) => {
     }
 
     if (node.type === 'CallExpression' || node.type === 'NewExpression') {
-      const name = node.callee.name;
+      let name = node.callee.name;
 
       // hack: special primitive object types
       if (node.type === 'NewExpression') {
@@ -1558,8 +1570,13 @@ const getNodeType = (scope, node) => {
         if (name === 'String') return TYPES.stringobject;
       }
 
+      // hack: try reading from member if call
+      if (name == null && node.callee.type === 'MemberExpression' && node.callee.property.name === 'call') {
+        name = node.callee.object.name;
+      }
+
       if (name == null) {
-        // iife
+        // unknown name
         return getLastType(scope);
       }
 
@@ -1568,7 +1585,7 @@ const getNodeType = (scope, node) => {
         if (func.returnType != null) return func.returnType;
       }
 
-      if (Object.hasOwn(builtinFuncs, name) && !builtinFuncs[name].typedReturns) return builtinFuncs[name].returnType ?? TYPES.number;
+      if (Object.hasOwn(builtinFuncs, name) && builtinFuncs[name].returnType != null) return builtinFuncs[name].returnType;
       if (Object.hasOwn(internalConstrs, name) && internalConstrs[name].type != null) return internalConstrs[name].type;
 
       // check if this is a prototype function
@@ -1971,8 +1988,6 @@ const createThisArg = (scope, decl) => {
       number(TYPES.number, Valtype.i32),
 
       [ Opcodes.call, includeBuiltin(scope, '__Porffor_object_expr_initWithFlags').index ],
-      [ Opcodes.drop ],
-      [ Opcodes.drop ],
 
       [ Opcodes.local_get, tmp ],
       number(TYPES.object, Valtype.i32)
@@ -2083,14 +2098,15 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
   }
 
   if (name === 'Function') {
-    const known = knownValue(scope, decl.arguments[0]);
-    if (known !== unknownValue) {
-      // new Function('with known/literal string')
-      const code = String(known);
+    const knowns = decl.arguments.map(x => knownValue(scope, x));
+    if (knowns.every(x => x !== unknownValue)) {
+      // new Function('with known/literal strings')
+      const code = String(knowns[knowns.length - 1]);
+      const args = knowns.slice(0, -1).map(x => String(x));
 
       let parsed;
       try {
-        parsed = objectHack(parse(`(function(){${code}})`));
+        parsed = objectHack(parse(`(function(${args.join(',')}){${code}})`));
       } catch (e) {
         if (e.name === 'SyntaxError') {
           // throw syntax errors of evals at runtime instead
@@ -2609,7 +2625,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
 
   const userFunc = func && !func.internal;
   const typedParams = userFunc || func?.typedParams;
-  const typedReturns = (userFunc && func.returnType == null) || builtinFuncs[name]?.typedReturns;
+  const typedReturns = func && func.returnType == null;
   let paramCount = countParams(func, name);
 
   let paramOffset = 0;
@@ -2709,17 +2725,19 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     // );
   } else out.push(...setLastType(scope));
 
-  if (builtinFuncs[name] && builtinFuncs[name].returns?.[0] === Valtype.i32 && valtypeBinary !== Valtype.i32) {
-    out.push(Opcodes.i32_from);
+  if (
+    func?.returns?.length === 0 ||
+    (idx === importedFuncs[name] && importedFuncs[importedFuncs[name]]?.returns === 0)
+  ) {
+    out.push(number(UNDEFINED));
   }
 
-  if (builtinFuncs[name] && builtinFuncs[name].returns?.[0] === Valtype.f64 && valtypeBinary === Valtype.i32 && !globalThis.noi32F64CallConv) {
-    out.push(Opcodes.i32_trunc_sat_f64_s);
+  if (func?.returns?.[0] === Valtype.i32 && valtypeBinary !== Valtype.i32) {
+    out.push(Opcodes.i32_from);
   }
 
-  if ((builtinFuncs[name] && builtinFuncs[name].returns?.length === 0) ||
-      (idx === importedFuncs[name] && importedFuncs[importedFuncs[name]]?.returns === 0)) {
-    out.push(number(UNDEFINED));
+  if (func?.returns?.[0] === Valtype.f64 && valtypeBinary === Valtype.i32 && !globalThis.noi32F64CallConv) {
+    out.push(Opcodes.i32_trunc_sat_f64_s);
   }
 
   return out;
@@ -3143,6 +3161,7 @@ const extractTypeAnnotation = decl => {
     type = a.typeName.name;
   } else if (a.type.endsWith('Keyword')) {
     type = a.type.slice(2, -7).toLowerCase();
+    if (type === 'void') type = 'undefined';
   } else if (a.type === 'TSArrayType') {
     type = 'array';
     elementType = extractTypeAnnotation(a.elementType).type;
@@ -4155,7 +4174,6 @@ const generateUnary = (scope, decl) => {
           ...toPropertyKey(scope, generate(scope, property), getNodeType(scope, property), decl.argument.computed, true),
 
           [ Opcodes.call, includeBuiltin(scope, scope.strict ? '__Porffor_object_deleteStrict' : '__Porffor_object_delete').index ],
-          [ Opcodes.drop ],
           Opcodes.i32_from_u
         ];
 
@@ -5616,10 +5634,7 @@ const generateObject = (scope, decl, global = false, name = '$undeclared') => {
         ...(kind !== 'init' ? [ Opcodes.i32_to_u ] : []),
         ...getNodeType(scope, value),
 
-        [ Opcodes.call, includeBuiltin(scope, `__Porffor_object_expr_${kind}`).index ],
-
-        [ Opcodes.drop ],
-        [ Opcodes.drop ]
+        [ Opcodes.call, includeBuiltin(scope, `__Porffor_object_expr_${kind}`).index ]
       );
     }
   }
@@ -6264,10 +6279,7 @@ const generateClass = (scope, decl) => {
       ...(initKind !== 'value' && initKind !== 'method' ? [ Opcodes.i32_to_u ] : []),
       ...getNodeType(outScope, value),
 
-      [ Opcodes.call, includeBuiltin(outScope, `__Porffor_object_class_${initKind}`).index ],
-
-      [ Opcodes.drop ],
-      [ Opcodes.drop ]
+      [ Opcodes.call, includeBuiltin(outScope, `__Porffor_object_class_${initKind}`).index ]
     );
   }
 
@@ -6575,9 +6587,10 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
                   number(0),
                   number(TYPES.undefined, Valtype.i32),
                   [ Opcodes.call, includeBuiltin(scope, '__Array_from').index ],
+                  [ Opcodes.local_set, func.locals[name].idx ],
 
+                  number(TYPES.array, Valtype.i32),
                   [ Opcodes.local_set, func.locals[name].idx + 1 ],
-                  [ Opcodes.local_set, func.locals[name].idx ],
                 [ Opcodes.end ]
               );
             }
@@ -6664,9 +6677,7 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
         // inject promise job runner func at the end of main if promises are made
         if (Object.hasOwn(funcIndex, 'Promise') || Object.hasOwn(funcIndex, '__Promise_resolve') || Object.hasOwn(funcIndex, '__Promise_reject')) {
           wasm.push(
-            [ Opcodes.call, includeBuiltin(func, '__Porffor_promise_runJobs').index ],
-            [ Opcodes.drop ],
-            [ Opcodes.drop ]
+            [ Opcodes.call, includeBuiltin(func, '__Porffor_promise_runJobs').index ]
           );
         }
       } else {
@@ -6687,14 +6698,12 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
           number(TYPES.array, Valtype.i32),
 
           [ Opcodes.call, includeBuiltin(func, func.async ? '__Porffor_AsyncGenerator' : '__Porffor_Generator').index ],
-          [ Opcodes.drop ],
           [ Opcodes.local_set, func.locals['#generator_out'].idx ]
         );
       } else if (func.async) {
         // make promise at the start
         wasm.unshift(
           [ Opcodes.call, includeBuiltin(func, '__Porffor_promise_create').index ],
-          [ Opcodes.drop ],
           [ Opcodes.local_set, func.locals['#async_out_promise'].idx ],
 
           // wrap in try for later catch
@@ -6704,18 +6713,15 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
         // reject with thrown value if caught error
         wasm.push(
           [ Opcodes.catch, 0 ],
+            [ Opcodes.local_get, func.locals['#async_out_promise'].idx ],
+            number(TYPES.promise, Valtype.i32),
 
-          [ Opcodes.local_get, func.locals['#async_out_promise'].idx ],
-          number(TYPES.promise, Valtype.i32),
-
-          [ Opcodes.call, includeBuiltin(func, '__Porffor_promise_reject').index ],
-          [ Opcodes.drop ],
-          [ Opcodes.drop ],
+            [ Opcodes.call, includeBuiltin(func, '__Porffor_promise_reject').index ],
           [ Opcodes.end ],
 
           // return promise at the end of func
           [ Opcodes.local_get, func.locals['#async_out_promise'].idx ],
-          number(TYPES.promise, Valtype.i32),
+          ...(scope.returnType != null ? [] : [ number(TYPES.promise, Valtype.i32) ]),
           [ Opcodes.return ]
         );
 
@@ -6732,10 +6738,9 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
 
   if (typedInput && decl.returnType) {
     const { type } = extractTypeAnnotation(decl.returnType);
-    if (type != null && !Prefs.indirectCalls) {
-    // if (type != null) {
+    if (type != null) {
       func.returnType = type;
-      func.returns = [ valtypeBinary ];
+      func.returns = func.returnType === TYPES.undefined && !func.async && !func.generator ? [] : [ valtypeBinary ];
     }
   }
 

package/compiler/precompile.js

@@ -17,11 +17,10 @@ globalThis.precompile = true;
 globalThis.valtypeOverrides = {
   returns: {
     __Porffor_object_get: [ Valtype.f64, Valtype.i32 ],
-    __Porffor_object_getExplicit: [ Valtype.f64, Valtype.i32 ],
     __Porffor_object_readValue: [ Valtype.f64, Valtype.i32 ],
     __Porffor_object_set: [ Valtype.f64, Valtype.i32 ],
     __Porffor_object_setStrict: [ Valtype.f64, Valtype.i32 ],
-    __Porffor_object_packAccessor: [ Valtype.f64, Valtype.i32 ]
+    __Porffor_object_packAccessor: [ Valtype.f64 ]
   },
   params: {
     __Porffor_object_set: [ Valtype.i32, Valtype.i32, Valtype.i32, Valtype.i32, Valtype.f64, Valtype.i32 ],
@@ -209,7 +208,7 @@ const precompile = async () => {
   }
 
   const total = performance.now() - t;
-  console.log(`\r${' '.repeat(80)}\r\u001b[2m${`[${total.toFixed(2)}ms]`.padEnd(12, ' ')}\u001b[0m\u001b[92mcompiled ${fileCount} files/${funcs.length} funcs\u001b[0m \u001b[90m(${['parse', 'codegen', 'opt'].map(x => `${x}: ${((timing[x] / total) * 100).toFixed(0)}%`).join(', ')})\u001b[0m`);
+  console.log(`\r${' '.repeat(80)}\r\u001b[2m${`[${total.toFixed(2)}ms]`.padEnd(12, ' ')}\u001b[0m\u001b[92mcompiled ${funcs.length} funcs from ${fileCount} files\u001b[0m \u001b[90m(${['parse', 'codegen', 'opt'].map(x => `${x}: ${((timing[x] / total) * 100).toFixed(0)}%`).join(', ')})\u001b[0m`);
 
   const comptimeFlagChecks = {
     hasFunc: x => `hasFunc('${x}')`
@@ -258,7 +257,7 @@ ${funcs.map(x => {
 
   return `this${name} = {
 wasm:${rewriteWasm(x.wasm)},
-params:${JSON.stringify(x.params)},typedParams:1,returns:${JSON.stringify(x.returns)},${x.returnType != null ? `returnType:${JSON.stringify(x.returnType)}` : 'typedReturns:1'},
+params:${JSON.stringify(x.params)},typedParams:1,returns:${JSON.stringify(x.returns)},${x.returnType != null ? `returnType:${JSON.stringify(x.returnType)},` : ''}
 locals:${JSON.stringify(locals.slice(x.params.length).map(x => x[1].type))},localNames:${JSON.stringify(locals.map(x => x[0]))},
 ${usedTypes.length > 0 ? `usedTypes:${JSON.stringify(usedTypes)},` : ''}
 ${x.globalInits ? `globalInits:{${Object.keys(x.globalInits).map(y => `${y}:${rewriteWasm(x.globalInits[y])}`).join(',')}},` : ''}${x.data && Object.keys(x.data).length > 0 ? `data:${JSON.stringify(x.data)},` : ''}

package/compiler/wrap.js

@@ -335,20 +335,6 @@ ${flags & 0b0001 ? `    get func idx: ${get}
       return out;
     }
 
-    case TYPES.bigint: {
-      const negative = read(Uint8Array, memory, value, 1)[0] !== 0;
-      const len = read(Uint16Array, memory, value + 2, 1)[0];
-      const digits = read(Uint32Array, memory, value + 4, len);
-
-      console.log(digits);
-
-      let result = 0n;
-      for (let i = 0; i < digits.length; i++) {
-        result = result * 0x100000000n + BigInt(digits[i]);
-      }
-      return negative ? -result : result;
-    }
-
     default: return value;
   }
 };
@@ -382,8 +368,8 @@ export default (source, module = undefined, customImports = {}, print = str => p
 
     const noAnsi = s => s && s.replace(/\u001b\[[0-9]+m/g, '');
     let longest = 0;
-    for (let j = 0; j < disassemble.length; j++) {
-      longest = Math.max(longest, noAnsi(disassemble[j])?.length ?? 0);
+    for (let j = 0; j < disasm.length; j++) {
+      longest = Math.max(longest, noAnsi(disasm[j])?.length ?? 0);
     }
 
     if (middleIndex != -1) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "porffor",
   "description": "An ahead-of-time JavaScript compiler",
-  "version": "0.55.17",
+  "version": "0.55.18",
   "author": "Oliver Medhurst <honk@goose.icu>",
   "license": "MIT",
   "scripts": {},

package/r.cjs

@@ -1,3 +1,5 @@
+Array.from.call(null, 0);
+
 // let o = { set foo(x) { console.log('set foo', x); }, __proto__: { set bar(x) { console.log('set bar', x); } } };
 
 // o.foo = 1;

package/runner/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import fs from 'node:fs';
-globalThis.version = '0.55.17';
+globalThis.version = '0.55.18';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {

package/compiler/builtins/bigint.ts

@@ -1,233 +0,0 @@
-import type {} from './porffor.d.ts';
-
-// digits is an array of u32s as digits in base 2^32
-export const __Porffor_bigint_fromDigits = (negative: boolean, digits: i32[]): bigint => {
-  const len: i32 = digits.length;
-  if (len > 16383) throw new RangeError('Maximum BigInt size exceeded'); // (65536 - 4) / 4
-
-  // const ptr: i32 = Porffor.allocate();
-  const ptr: i32 = Porffor.wasm`local.get ${digits}`;
-
-  Porffor.wasm.i32.store8(ptr, negative ? 1 : 0, 0, 0);
-  Porffor.wasm.i32.store16(ptr, len, 0, 2);
-
-  for (let i: i32 = 0; i < len; i++) {
-    Porffor.wasm.i32.store(ptr + i * 4, digits[i], 0, 4);
-  }
-
-  const out: bigint = ptr;
-  return out;
-};
-
-export const __Porffor_bigint_fromNumber = (n: number): bigint => {
-  if (!Number.isInteger(n) || !Number.isFinite(n)) throw new RangeError('Cannot convert non-integer to BigInt');
-
-  const negative: boolean = n < 0;
-  n = Math.abs(n);
-
-  const digits: i32[] = Porffor.allocate();
-  while (n > 0) {
-    digits.unshift(n % 0x100000000);
-    n = Math.trunc(n / 0x100000000);
-  }
-
-  return __Porffor_bigint_fromDigits(negative, digits);
-};
-
-export const __Porffor_bigint_toNumber = (ptr: i32): number => {
-  const negative: boolean = Porffor.wasm.i32.load8_u(ptr, 0, 0) != 0;
-  const len: i32 = Porffor.wasm.i32.load16_u(ptr, 0, 2);
-
-  let out: number = 0;
-  for (let i: i32 = 0; i < len; i++) {
-    const d: i32 = Porffor.wasm.i32.load(ptr + i * 4, 0, 4);
-    out = out * 0x100000000 + d;
-  }
-
-  if (negative) out = -out;
-  return out;
-};
-
-export const __Porffor_bigint_fromString = (n: string|bytestring): bigint => {
-  const len: i32 = n.length;
-
-  let negative: boolean = false;
-  let end: i32 = 0;
-  if (n[0] === '-') {
-    negative = true;
-    end = 1;
-  } else if (n[0] === '+') {
-    end = 1;
-  }
-
-  // n -> digits (base 2^32) (most to least significant)
-  // 4294967294 -> [ 4294967294 ]
-  // 4294967295 -> [ 4294967295 ]
-  // 4294967296 -> [ 1, 0 ]
-  // 4294967297 -> [ 1, 1 ]
-  // 4294967298 -> [ 1, 2 ]
-  // 9007199254740992 -> [ 2097152 ]
-  // 9007199254740993 -> [ 2097152, 1 ]
-  // 9007199254740994 -> [ 2097152, 2 ]
-  // 9007199254740995 -> [ 2097152, 3 ]
-
-  const digits: i32[] = Porffor.allocate();
-
-  const base = 0x100000000; // 2^32
-
-  for (let i: i32 = end; i < len; i++) {
-    const char: i32 = n.charCodeAt(i);
-    const digit: i32 = char - 48;
-    if (digit < 0 || digit > 9) throw new SyntaxError('Invalid characters in BigInt string');
-
-    // Multiply current digits by 10 and add the new digit
-    let carry: i32 = digit;
-    for (let j: i32 = 0; j < digits.length; j++) {
-      const value: i32 = digits[j] * 10 + carry;
-      digits[j] = value % base;
-      carry = Math.trunc(value / base);
-    }
-
-    // If there's a carry left, push it as a new digit
-    if (carry > 0) {
-      digits.push(carry);
-    }
-  }
-
-  return __Porffor_bigint_fromDigits(negative, digits);
-};
-
-export const __Porffor_bigint_toString = (ptr: i32, radix: number): string => {
-  // todo
-  // return '';
-};
-
-export const __Porffor_bigint_add = (a: i32, b: i32, sub: boolean): bigint => {
-  const aNegative: boolean = Porffor.wasm.i32.load8_u(a, 0, 0) != 0;
-  const aLen: i32 = Porffor.wasm.i32.load16_u(a, 0, 2);
-
-  let bNegative: boolean = Porffor.wasm.i32.load8_u(b, 0, 0) != 0;
-  if (sub) bNegative = !bNegative;
-  const bLen: i32 = Porffor.wasm.i32.load16_u(b, 0, 2);
-
-  const maxLen: i32 = Math.max(aLen, bLen);
-  const digits: i32[] = Porffor.allocate();
-
-  // fast path: same sign
-  let negative: boolean = false;
-  let carry: i32 = 0;
-  if (aNegative == bNegative) {
-    negative = aNegative;
-
-    for (let i: i32 = 0; i < maxLen; i++) {
-      let aDigit: i32 = 0;
-      const aOffset: i32 = aLen - i;
-      if (aOffset > 0) aDigit = Porffor.wasm.i32.load(a + aOffset * 4, 0, 0);
-
-      let bDigit: i32 = 0;
-      const bOffset: i32 = bLen - i;
-      if (bOffset > 0) bDigit = Porffor.wasm.i32.load(b + bOffset * 4, 0, 0);
-
-      let sum: i32 = aDigit + bDigit + carry;
-      if (sum >= 0x100000000) {
-        sum -= 0x100000000;
-        carry = 1;
-      } else if (sum < 0) {
-        sum += 0x100000000;
-        carry = 1;
-      } else {
-        carry = 0;
-      }
-
-      digits.unshift(sum);
-    }
-  } else {
-    let aLarger: i32 = 0;
-    for (let i: i32 = 0; i < maxLen; i++) {
-      let aDigit: i32 = 0;
-      const aOffset: i32 = aLen - i;
-      if (aOffset > 0) aDigit = Porffor.wasm.i32.load(a + aOffset * 4, 0, 0);
-
-      let bDigit: i32 = 0;
-      const bOffset: i32 = bLen - i;
-      if (bOffset > 0) bDigit = Porffor.wasm.i32.load(b + bOffset * 4, 0, 0);
-
-      let sum: i32 = carry;
-      if (aNegative) sum -= aDigit;
-        else sum += aDigit;
-      if (bNegative) sum -= bDigit;
-        else sum += bDigit;
-
-      if (aDigit != bDigit) aLarger = aDigit > bDigit ? 1 : -1;
-
-      if (sum >= 0x100000000) {
-        sum -= 0x100000000;
-        carry = 1;
-      } else if (sum < 0) {
-        sum += 0x100000000;
-        carry = -1;
-      } else {
-        carry = 0;
-      }
-
-      digits.unshift(sum);
-    }
-
-    if (aLarger == 1) negative = aNegative;
-      else if (aLarger == -1) negative = bNegative;
-  }
-
-  if (carry != 0) {
-    digits.unshift(Math.abs(carry));
-    if (carry < 0) negative = !negative;
-  }
-
-  return __Porffor_bigint_fromDigits(negative, digits);
-};
-
-export const __Porffor_bigint_sub = (a: i32, b: i32): bigint => {
-  return __Porffor_bigint_add(a, b, true);
-};
-
-export const __Porffor_bigint_mul = (a: i32, b: i32): bigint => {
-  // todo
-  // return 0n;
-};
-
-export const __Porffor_bigint_div = (a: i32, b: i32): bigint => {
-  // todo
-  // return 0n;
-};
-
-export const __Porffor_bigint_rem = (a: i32, b: i32): bigint => {
-  // todo
-  // return 0n;
-};
-
-export const __Porffor_bigint_eq = (a: i32, b: i32): boolean => {
-  // todo
-  // return false;
-};
-
-export const __Porffor_bigint_ne = (a: i32, b: i32): boolean => {
-  return !__Porffor_bigint_eq(a, b);
-};
-
-export const __Porffor_bigint_gt = (a: i32, b: i32): boolean => {
-  // todo
-  // return false;
-};
-
-export const __Porffor_bigint_ge = (a: i32, b: i32): boolean => {
-  // todo
-  // return false;
-};
-
-export const __Porffor_bigint_lt = (a: i32, b: i32): boolean => {
-  return !__Porffor_bigint_ge(a, b);
-};
-
-export const __Porffor_bigint_le = (a: i32, b: i32): boolean => {
-  return !__Porffor_bigint_gt(a, b);
-};
-