porffor 0.59.2 → 0.59.4

package/AGENT.md

@@ -1,22 +1,20 @@
 you are an assistant coder for Porffor - an early javascript and typescript to webassembly and native ahead-of-time compiler. the codebase is written in js and ts.
 
-IMPORTANT:
 - built-ins apis (Date, String.prototype, etc) are written in ts inside `compiler/builtins`
 - once you update a file inside that directory, you MUST run `./porf precompile` to compile to make your changes effective
-
-Test your work using the test262 tools available, iterate independently but do not get stuck on one chain of thought or approach. Paths for test262 tools should be relative to the 'test262/test' directory (e.g., 'built-ins/RegExp' NOT 'test262/test/built-ins/RegExp').
-
-You can also do the following via bash/shell commands:
-- To get an overview of the most failing directories, use the command: `node test262/fails.cjs`
-- To just evaluate code in the engine, use the command: `./porf -p "..."`
-
-## Code Style
-- After finishing, check if your work/diff could be simplified
-- Always use single quotes (unless double is required)
+- test your work using the test262 tools available, iterate independently but do not get stuck on one chain of thought or approach. paths for test262 tools should be relative to the 'test262/test' directory (e.g., 'built-ins/RegExp' NOT 'test262/test/built-ins/RegExp').
+- to get an overview of the most failing directories, use the command: `node test262/fails.cjs`
+- to just evaluate code in the engine, use the command: `./porf -p "..."`
+- after finishing, check if your work/diff could be simplified
+- always use single quotes (unless double is required)
 - 2-space indentation, LF line endings, no trailing whitespace
-- Built-in APIs in `compiler/builtins/` written in TypeScript
-- Inline code in built-ins, avoid helper functions
-- Use semicolons
-- Do not use trailing commas
-- Use const/let, avoid var
-- Follow existing naming: camelCase for variables, PascalCase for types
+- built-in APIs in `compiler/builtins/` written in TypeScript
+- inline code in built-ins, avoid helper functions
+- use semicolons
+- do not use trailing commas
+- use const/let, avoid var
+- follow existing naming: camelCase for variables, PascalCase for types
+
+memories:
+- The user prefers that prototype functions not have explicit return types in this codebase.
+- The user prefers not to use global variables in built-in functions.

package/compiler/builtins/regexp.ts

@@ -1349,7 +1349,7 @@ export const __RegExp_prototype_toString = (_this: RegExp) => {
 };
 
 
-export const RegExp = function (pattern: any, flags: any = undefined): RegExp {
+export const RegExp = function (pattern: any, flags: any): RegExp {
   let patternSrc, flagsSrc;
   if (Porffor.type(pattern) === Porffor.TYPES.regexp) {
     patternSrc = __RegExp_prototype_source$get(pattern);

package/compiler/builtins/typedarray.js

@@ -102,9 +102,8 @@ export const __${name}_from = (arg: any, mapFn: any): ${name} => {
   return new ${name}(arr);
 };
 
-export const __${name}_prototype_buffer$get = (_this: ${name}) => {
-  const out: ArrayBuffer = Porffor.wasm.i32.load(_this, 0, 4) - Porffor.wasm.i32.load(_this, 0, 8);
-  return out;
+export const __${name}_prototype_buffer$get = (_this: ${name}): any|ArrayBuffer => {
+  return Porffor.wasm.i32.load(_this, 0, 4) - Porffor.wasm.i32.load(_this, 0, 8) as ArrayBuffer;
 };
 
 export const __${name}_prototype_byteLength$get = (_this: ${name}) => {

package/compiler/builtins/uint8array_base64.ts

@@ -0,0 +1,634 @@
+// @porf --valtype=i32
+import type {} from './porffor.d.ts';
+
+export const __Porffor_uint8array_validate = (ta: any) => {
+  if (Porffor.type(ta) != Porffor.TYPES.uint8array) {
+    throw new TypeError('Method called on incompatible receiver');
+  }
+
+  if (Porffor.wasm.i32.load(Porffor.wasm.i32.load(Porffor.wasm`local.get ${ta}`, 0, 4), 0, 0) == 4294967295) {
+    throw new TypeError('Uint8Array has a detached ArrayBuffer');
+  }
+};
+
+export const __Uint8Array_prototype_toBase64 = (_this: Uint8Array, options: any = undefined) => {
+  let alphabet: string = 'base64';
+  let omitPadding: boolean = false;
+
+  if (Porffor.type(options) != Porffor.TYPES.undefined) {
+    if (Porffor.type(options) != Porffor.TYPES.object) {
+      throw new TypeError('Options must be an object');
+    }
+
+    const alphabetProp: any = options.alphabet;
+    if (Porffor.type(alphabetProp) != Porffor.TYPES.undefined) {
+      alphabet = alphabetProp;
+    }
+
+    const paddingProp: any = options.omitPadding;
+    if (Porffor.type(paddingProp) != Porffor.TYPES.undefined) {
+      omitPadding = !!paddingProp;
+    }
+  }
+
+  if (!Porffor.strcmp(alphabet, 'base64') && !Porffor.strcmp(alphabet, 'base64url')) {
+    throw new TypeError('Invalid alphabet');
+  }
+
+  __Porffor_uint8array_validate(_this);
+  const taPtr: i32 = Porffor.wasm`local.get ${_this}`;
+  const len: i32 = Porffor.wasm.i32.load(taPtr, 0, 0);
+  const bufferPtr: i32 = Porffor.wasm.i32.load(taPtr, 0, 4);
+
+  const output: bytestring = Porffor.allocate();
+  const outPtr: i32 = Porffor.wasm`local.get ${output}`;
+
+  let alphabetStr: bytestring;
+  if (Porffor.strcmp(alphabet, 'base64url')) {
+    alphabetStr = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+  } else {
+    alphabetStr = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+  }
+  const alphabetPtr: i32 = Porffor.wasm`local.get ${alphabetStr}`;
+
+  let i: i32 = 0;
+  let j: i32 = outPtr;
+
+  const fullChunks: i32 = (len / 3) * 3;
+  while (i < fullChunks) {
+    const b1: i32 = Porffor.wasm.i32.load8_u(bufferPtr + i++, 0, 4);
+    const b2: i32 = Porffor.wasm.i32.load8_u(bufferPtr + i++, 0, 4);
+    const b3: i32 = Porffor.wasm.i32.load8_u(bufferPtr + i++, 0, 4);
+
+    const enc1: i32 = b1 >> 2;
+    const enc2: i32 = ((b1 & 3) << 4) | (b2 >> 4);
+    const enc3: i32 = ((b2 & 15) << 2) | (b3 >> 6);
+    const enc4: i32 = b3 & 63;
+
+    Porffor.wasm.i32.store8(j++, Porffor.wasm.i32.load8_u(alphabetPtr + enc1, 0, 4), 0, 4);
+    Porffor.wasm.i32.store8(j++, Porffor.wasm.i32.load8_u(alphabetPtr + enc2, 0, 4), 0, 4);
+    Porffor.wasm.i32.store8(j++, Porffor.wasm.i32.load8_u(alphabetPtr + enc3, 0, 4), 0, 4);
+    Porffor.wasm.i32.store8(j++, Porffor.wasm.i32.load8_u(alphabetPtr + enc4, 0, 4), 0, 4);
+  }
+
+  const remaining: i32 = len - i;
+  if (remaining == 1) {
+    const b1: i32 = Porffor.wasm.i32.load8_u(bufferPtr + i, 0, 4);
+    const enc1: i32 = b1 >> 2;
+    const enc2: i32 = (b1 & 3) << 4;
+
+    Porffor.wasm.i32.store8(j++, Porffor.wasm.i32.load8_u(alphabetPtr + enc1, 0, 4), 0, 4);
+    Porffor.wasm.i32.store8(j++, Porffor.wasm.i32.load8_u(alphabetPtr + enc2, 0, 4), 0, 4);
+    if (!omitPadding) {
+    Porffor.wasm.i32.store8(j++, 61, 0, 4); // '='
+    Porffor.wasm.i32.store8(j++, 61, 0, 4); // '='
+    }
+  } else if (remaining == 2) {
+    const b1: i32 = Porffor.wasm.i32.load8_u(bufferPtr + i, 0, 4);
+    const b2: i32 = Porffor.wasm.i32.load8_u(bufferPtr + i + 1, 0, 4);
+    const enc1: i32 = b1 >> 2;
+    const enc2: i32 = ((b1 & 3) << 4) | (b2 >> 4);
+    const enc3: i32 = (b2 & 15) << 2;
+
+    Porffor.wasm.i32.store8(j++, Porffor.wasm.i32.load8_u(alphabetPtr + enc1, 0, 4), 0, 4);
+    Porffor.wasm.i32.store8(j++, Porffor.wasm.i32.load8_u(alphabetPtr + enc2, 0, 4), 0, 4);
+    Porffor.wasm.i32.store8(j++, Porffor.wasm.i32.load8_u(alphabetPtr + enc3, 0, 4), 0, 4);
+    if (!omitPadding) {
+    Porffor.wasm.i32.store8(j++, 61, 0, 4); // '='
+    }
+  }
+
+  output.length = j - Porffor.wasm`local.get ${output}`;
+  return output;
+};
+
+export const __Uint8Array_prototype_toHex = (_this: Uint8Array) => {
+  __Porffor_uint8array_validate(_this);
+  const taPtr: i32 = Porffor.wasm`local.get ${_this}`;
+  const len: i32 = Porffor.wasm.i32.load(taPtr, 0, 0);
+  const bufferPtr: i32 = Porffor.wasm.i32.load(taPtr, 0, 4);
+
+  const output: bytestring = Porffor.allocate();
+  const outPtr: i32 = Porffor.wasm`local.get ${output}`;
+
+  const hexChars: bytestring = '0123456789abcdef';
+  const hexPtr: i32 = Porffor.wasm`local.get ${hexChars}`;
+
+  let i: i32 = 0;
+  let j: i32 = outPtr;
+  while (i < len) {
+    const byte: i32 = Porffor.wasm.i32.load8_u(bufferPtr + i++, 0, 4);
+    Porffor.wasm.i32.store8(j++, Porffor.wasm.i32.load8_u(hexPtr + (byte >> 4), 0, 4), 0, 4);
+    Porffor.wasm.i32.store8(j++, Porffor.wasm.i32.load8_u(hexPtr + (byte & 15), 0, 4), 0, 4);
+  }
+
+  output.length = j - Porffor.wasm`local.get ${output}`;
+  return output;
+};
+
+// Returns packed: (charsRead << 16) | bytesWritten
+export const __Porffor_fromBase64 = (str: any, alphabet: any, lastChunkHandling: any, destPtr: i32, maxLength: i32) => {
+  const strPtr: i32 = Porffor.wasm`local.get ${str}`;
+  const strLen: i32 = str.length;
+
+  if (!Porffor.strcmp(alphabet, 'base64') && !Porffor.strcmp(alphabet, 'base64url')) {
+    throw new TypeError('Invalid alphabet');
+  }
+
+  const isBase64Url: boolean = Porffor.strcmp(alphabet, 'base64url');
+
+  let j: i32 = destPtr;
+
+  let i: i32 = 0;
+  while (i < strLen) {
+    let c1: i32 = 0, c2: i32 = 0, c3: i32 = 0, c4: i32 = 0;
+    let chunkLength: i32 = 0;
+    let chunkStartPos: i32 = i;
+
+    while (i < strLen) {
+      const ch: i32 = Porffor.wasm.i32.load8_u(strPtr + i++, 0, 4);
+      if (ch >= 65 && ch <= 90) { // A-Z
+        c1 = ch - 65;
+        chunkLength = 1;
+        break;
+      }
+      if (ch >= 97 && ch <= 122) { // a-z
+        c1 = ch - 71;
+        chunkLength = 1;
+        break;
+      }
+      if (ch >= 48 && ch <= 57) { // 0-9
+        c1 = ch + 4;
+        chunkLength = 1;
+        break;
+      }
+      if (ch == 43) { // +
+        if (isBase64Url) {
+          throw new SyntaxError('Invalid base64url character');
+        }
+        c1 = 62;
+        chunkLength = 1;
+        break;
+      }
+      if (ch == 47) { // /
+        if (isBase64Url) {
+          throw new SyntaxError('Invalid base64url character');
+        }
+        c1 = 63;
+        chunkLength = 1;
+        break;
+      }
+      if (ch == 45) { // -
+        if (!isBase64Url) {
+          throw new SyntaxError('Invalid base64 character');
+        }
+        c1 = 62;
+        chunkLength = 1;
+        break;
+      }
+      if (ch == 95) { // _
+        if (!isBase64Url) {
+          throw new SyntaxError('Invalid base64 character');
+        }
+        c1 = 63;
+        chunkLength = 1;
+        break;
+      }
+      if (ch == 61) { // =
+        return (i << 16) | (j - destPtr);
+      }
+    }
+
+    while (i < strLen) {
+      const ch: i32 = Porffor.wasm.i32.load8_u(strPtr + i++, 0, 4);
+      if (ch >= 65 && ch <= 90) { // A-Z
+        c2 = ch - 65;
+        chunkLength = 2;
+        break;
+      }
+      if (ch >= 97 && ch <= 122) { // a-z
+        c2 = ch - 71;
+        chunkLength = 2;
+        break;
+      }
+      if (ch >= 48 && ch <= 57) { // 0-9
+        c2 = ch + 4;
+        chunkLength = 2;
+        break;
+      }
+      if (ch == 43) { // +
+        if (isBase64Url) {
+          throw new SyntaxError('Invalid base64url character');
+        }
+        c2 = 62;
+        chunkLength = 2;
+        break;
+      }
+      if (ch == 47) { // /
+        if (isBase64Url) {
+          throw new SyntaxError('Invalid base64url character');
+        }
+        c2 = 63;
+        chunkLength = 2;
+        break;
+      }
+      if (ch == 45) { // -
+        if (!isBase64Url) {
+          throw new SyntaxError('Invalid base64 character');
+        }
+        c2 = 62;
+        chunkLength = 2;
+        break;
+      }
+      if (ch == 95) { // _
+        if (!isBase64Url) {
+          throw new SyntaxError('Invalid base64 character');
+        }
+        c2 = 63;
+        chunkLength = 2;
+        break;
+      }
+      if (ch == 61) { // =
+        return (i << 16) | (j - destPtr);
+      }
+    }
+
+    while (i < strLen) {
+      const ch: i32 = Porffor.wasm.i32.load8_u(strPtr + i++, 0, 4);
+      if (ch >= 65 && ch <= 90) { // A-Z
+        c3 = ch - 65;
+        chunkLength = 3;
+        break;
+      }
+      if (ch >= 97 && ch <= 122) { // a-z
+        c3 = ch - 71;
+        chunkLength = 3;
+        break;
+      }
+      if (ch >= 48 && ch <= 57) { // 0-9
+        c3 = ch + 4;
+        chunkLength = 3;
+        break;
+      }
+      if (ch == 43) { // +
+        if (isBase64Url) {
+          throw new SyntaxError('Invalid base64url character');
+        }
+        c3 = 62;
+        chunkLength = 3;
+        break;
+      }
+      if (ch == 47) { // /
+        if (isBase64Url) {
+          throw new SyntaxError('Invalid base64url character');
+        }
+        c3 = 63;
+        chunkLength = 3;
+        break;
+      }
+      if (ch == 45) { // -
+        if (!isBase64Url) {
+          throw new SyntaxError('Invalid base64 character');
+        }
+        c3 = 62;
+        chunkLength = 3;
+        break;
+      }
+      if (ch == 95) { // _
+        if (!isBase64Url) {
+          throw new SyntaxError('Invalid base64 character');
+        }
+        c3 = 63;
+        chunkLength = 3;
+        break;
+      }
+      if (ch == 61) { // =
+        if (j - destPtr + 1 > maxLength) {
+          return (chunkStartPos << 16) | (j - destPtr); // Not enough space
+        }
+        if (Porffor.strcmp(lastChunkHandling, 'strict') && (c2 & 15) != 0) {
+          throw new SyntaxError('Invalid base64 padding');
+        }
+        const b1: i32 = (c1 << 2) | (c2 >> 4);
+        Porffor.wasm.i32.store8(j++, b1, 0, 4);
+
+        // Check if there's a second padding character and consume it
+        if (i < strLen && Porffor.wasm.i32.load8_u(strPtr + i, 0, 4) == 61) {
+          i++;
+        }
+
+        return (i << 16) | (j - destPtr);
+      }
+    }
+
+    while (i < strLen) {
+      const ch: i32 = Porffor.wasm.i32.load8_u(strPtr + i++, 0, 4);
+      if (ch >= 65 && ch <= 90) { // A-Z
+        c4 = ch - 65;
+        chunkLength = 4;
+        break;
+      }
+      if (ch >= 97 && ch <= 122) { // a-z
+        c4 = ch - 71;
+        chunkLength = 4;
+        break;
+      }
+      if (ch >= 48 && ch <= 57) { // 0-9
+        c4 = ch + 4;
+        chunkLength = 4;
+        break;
+      }
+      if (ch == 43) { // +
+        if (isBase64Url) {
+          throw new SyntaxError('Invalid base64url character');
+        }
+        c4 = 62;
+        chunkLength = 4;
+        break;
+      }
+      if (ch == 47) { // /
+        if (isBase64Url) {
+          throw new SyntaxError('Invalid base64url character');
+        }
+        c4 = 63;
+        chunkLength = 4;
+        break;
+      }
+      if (ch == 45) { // -
+        if (!isBase64Url) {
+          throw new SyntaxError('Invalid base64 character');
+        }
+        c4 = 62;
+        chunkLength = 4;
+        break;
+      }
+      if (ch == 95) { // _
+        if (!isBase64Url) {
+          throw new SyntaxError('Invalid base64 character');
+        }
+        c4 = 63;
+        chunkLength = 4;
+        break;
+      }
+      if (ch == 61) { // =
+        if (j - destPtr + 2 > maxLength) {
+          return (chunkStartPos << 16) | (j - destPtr); // Not enough space
+        }
+        if (Porffor.strcmp(lastChunkHandling, 'strict') && (c3 & 3) != 0) {
+          throw new SyntaxError('Invalid base64 padding');
+        }
+        const b1: i32 = (c1 << 2) | (c2 >> 4);
+        const b2: i32 = ((c2 & 15) << 4) | (c3 >> 2);
+        Porffor.wasm.i32.store8(j++, b1, 0, 4);
+        Porffor.wasm.i32.store8(j++, b2, 0, 4);
+        return (i << 16) | (j - destPtr);
+      }
+    }
+
+    // Only check if we have space for 3 bytes if we actually have a complete 4-character chunk
+    if (chunkLength == 4) {
+      if (j - destPtr + 3 > maxLength) {
+        return (chunkStartPos << 16) | (j - destPtr); // Stop if not enough space
+      }
+
+    const b1: i32 = (c1 << 2) | (c2 >> 4);
+    const b2: i32 = ((c2 & 15) << 4) | (c3 >> 2);
+    const b3: i32 = ((c3 & 3) << 6) | c4;
+
+    Porffor.wasm.i32.store8(j++, b1, 0, 4);
+    Porffor.wasm.i32.store8(j++, b2, 0, 4);
+    Porffor.wasm.i32.store8(j++, b3, 0, 4);
+    }
+  }
+
+  // Handle end-of-string with partial chunk according to lastChunkHandling
+  if (chunkLength > 0) {
+    if (Porffor.strcmp(lastChunkHandling, 'stop-before-partial')) {
+      return (chunkStartPos << 16) | (j - destPtr); // Don't decode partial chunk
+    }
+
+    if (Porffor.strcmp(lastChunkHandling, 'strict')) {
+      throw new SyntaxError('Invalid base64 string');
+    }
+
+    // 'loose' handling - decode partial chunk
+    if (chunkLength == 1) {
+      throw new SyntaxError('Invalid base64 string'); // 1 char is always invalid
+    }
+
+    if (chunkLength == 2) {
+      if (j - destPtr + 1 > maxLength) {
+        return (chunkStartPos << 16) | (j - destPtr); // Not enough space for 1 byte
+      }
+      if (Porffor.strcmp(lastChunkHandling, 'strict') && (c2 & 15) != 0) {
+        throw new SyntaxError('Invalid base64 padding');
+      }
+      const b1: i32 = (c1 << 2) | (c2 >> 4);
+      Porffor.wasm.i32.store8(j++, b1, 0, 4);
+    } else if (chunkLength == 3) {
+      if (j - destPtr + 2 > maxLength) {
+        return (chunkStartPos << 16) | (j - destPtr); // Not enough space for 2 bytes
+      }
+      if (Porffor.strcmp(lastChunkHandling, 'strict') && (c3 & 3) != 0) {
+        throw new SyntaxError('Invalid base64 padding');
+      }
+      const b1: i32 = (c1 << 2) | (c2 >> 4);
+      const b2: i32 = ((c2 & 15) << 4) | (c3 >> 2);
+      Porffor.wasm.i32.store8(j++, b1, 0, 4);
+      Porffor.wasm.i32.store8(j++, b2, 0, 4);
+    }
+  }
+
+  return (strLen << 16) | (j - destPtr);
+};
+
+export const __Uint8Array_fromBase64 = (str: any, options: any = undefined) => {
+  if (Porffor.type(str) != Porffor.TYPES.bytestring) {
+    throw new TypeError('First argument must be a string');
+  }
+
+  let alphabet: string = 'base64';
+  let lastChunkHandling: string = 'loose';
+
+  if (Porffor.type(options) != Porffor.TYPES.undefined) {
+    if (Porffor.type(options) != Porffor.TYPES.object) {
+      throw new TypeError('Options must be an object');
+    }
+
+    const alphabetProp: any = options.alphabet;
+    if (Porffor.type(alphabetProp) != Porffor.TYPES.undefined) {
+      alphabet = alphabetProp;
+    }
+
+    const lastChunkProp: any = options.lastChunkHandling;
+    if (Porffor.type(lastChunkProp) != Porffor.TYPES.undefined) {
+      lastChunkHandling = lastChunkProp;
+    }
+  }
+
+  if (!Porffor.strcmp(alphabet, 'base64') && !Porffor.strcmp(alphabet, 'base64url')) {
+    throw new TypeError('Invalid alphabet');
+  }
+
+  if (!Porffor.strcmp(lastChunkHandling, 'loose') && !Porffor.strcmp(lastChunkHandling, 'strict') && !Porffor.strcmp(lastChunkHandling, 'stop-before-partial')) {
+    throw new TypeError('Invalid lastChunkHandling');
+  }
+
+  // Calculate exact output size based on input length and padding
+  let exactSize: i32 = 0;
+  const strLen: i32 = str.length;
+
+  if (strLen == 0) {
+    exactSize = 0;
+  } else {
+    // Count padding characters from the end
+    let paddingCount: i32 = 0;
+    const strPtr: i32 = Porffor.wasm`local.get ${str}`;
+    let i: i32 = strLen - 1;
+    while (i >= 0 && Porffor.wasm.i32.load8_u(strPtr + i, 0, 4) == 61) {
+      paddingCount++;
+      i--;
+    }
+
+    // Calculate exact size: 4 chars -> 3 bytes, minus padding
+    const nonPaddingChars: i32 = strLen - paddingCount;
+    exactSize = (nonPaddingChars * 3) / 4;
+  }
+
+  const ta: Uint8Array = new Uint8Array(exactSize);
+  const taPtr: i32 = Porffor.wasm`local.get ${ta}`;
+  const bufferPtr: i32 = Porffor.wasm.i32.load(taPtr, 0, 4);
+
+  __Porffor_fromBase64(str, alphabet, lastChunkHandling, bufferPtr, exactSize);
+
+  return ta;
+};
+
+export const __Uint8Array_prototype_setFromBase64 = (_this: Uint8Array, str: any, options: any = undefined) => {
+  if (Porffor.type(str) != Porffor.TYPES.bytestring) {
+    throw new TypeError('First argument must be a string');
+  }
+
+  let alphabet: string = 'base64';
+  let lastChunkHandling: string = 'loose';
+
+  if (Porffor.type(options) != Porffor.TYPES.undefined) {
+    if (Porffor.type(options) != Porffor.TYPES.object) {
+      throw new TypeError('Options must be an object');
+    }
+
+    const alphabetProp: any = options.alphabet;
+    if (Porffor.type(alphabetProp) != Porffor.TYPES.undefined) {
+      alphabet = alphabetProp;
+    }
+
+    const lastChunkProp: any = options.lastChunkHandling;
+    if (Porffor.type(lastChunkProp) != Porffor.TYPES.undefined) {
+      lastChunkHandling = lastChunkProp;
+    }
+  }
+
+  if (!Porffor.strcmp(alphabet, 'base64') && !Porffor.strcmp(alphabet, 'base64url')) {
+    throw new TypeError('Invalid alphabet');
+  }
+
+  if (!Porffor.strcmp(lastChunkHandling, 'loose') && !Porffor.strcmp(lastChunkHandling, 'strict') && !Porffor.strcmp(lastChunkHandling, 'stop-before-partial')) {
+    throw new TypeError('Invalid lastChunkHandling');
+  }
+
+  __Porffor_uint8array_validate(_this);
+  const taPtr: i32 = Porffor.wasm`local.get ${_this}`;
+  const byteLength: i32 = Porffor.wasm.i32.load(taPtr, 0, 0);
+  const bufferPtr: i32 = Porffor.wasm.i32.load(taPtr, 0, 4);
+
+  const result: i32 = __Porffor_fromBase64(str, alphabet, lastChunkHandling, bufferPtr, byteLength);
+  const charsRead: i32 = result >> 16;
+  const bytesWritten: i32 = result & 0xFFFF;
+
+  const resultObj: object = {};
+  resultObj.read = charsRead;
+  resultObj.written = bytesWritten;
+
+  return resultObj;
+};
+
+// Returns packed: (charsRead << 16) | bytesWritten
+export const __Porffor_fromHex = (str: bytestring, destPtr: i32, maxLength: i32) => {
+  const strPtr: i32 = Porffor.wasm`local.get ${str}`;
+  const strLen: i32 = str.length;
+
+  if ((strLen & 1) != 0) {
+    throw new SyntaxError('Hex string must have even length');
+  }
+
+  let j: i32 = destPtr;
+
+  let i: i32 = 0;
+  const maxBytes: i32 = strLen / 2;
+  const limit: i32 = maxBytes < maxLength ? maxBytes : maxLength;
+
+  while (i < limit) {
+    const h1: i32 = Porffor.wasm.i32.load8_u(strPtr + i * 2, 0, 4);
+    const h2: i32 = Porffor.wasm.i32.load8_u(strPtr + i * 2 + 1, 0, 4);
+
+    let v1: i32 = -1;
+    let v2: i32 = -1;
+
+    if (h1 >= 48 && h1 <= 57) v1 = h1 - 48; // 0-9
+    else if (h1 >= 97 && h1 <= 102) v1 = h1 - 87; // a-f
+    else if (h1 >= 65 && h1 <= 70) v1 = h1 - 55; // A-F
+
+    if (h2 >= 48 && h2 <= 57) v2 = h2 - 48; // 0-9
+    else if (h2 >= 97 && h2 <= 102) v2 = h2 - 87; // a-f
+    else if (h2 >= 65 && h2 <= 70) v2 = h2 - 55; // A-F
+
+    if (v1 == -1 || v2 == -1) {
+      throw new SyntaxError('Invalid hex character');
+    }
+
+    const byte: i32 = (v1 << 4) | v2;
+    Porffor.wasm.i32.store8(j++, byte, 0, 4);
+
+    i++;
+  }
+
+  const charsRead: i32 = i * 2;
+  return (charsRead << 16) | (j - destPtr);
+};
+
+export const __Uint8Array_fromHex = (str: any) => {
+  if (Porffor.type(str) != Porffor.TYPES.bytestring) {
+    throw new TypeError('First argument must be a string');
+  }
+
+  // Hex decoding: 2 chars -> 1 byte exactly
+  const exactSize: i32 = str.length / 2;
+  const ta: Uint8Array = new Uint8Array(exactSize);
+  const taPtr: i32 = Porffor.wasm`local.get ${ta}`;
+  const bufferPtr: i32 = Porffor.wasm.i32.load(taPtr, 0, 4);
+
+  __Porffor_fromHex(str, bufferPtr, exactSize);
+
+  return ta;
+};
+
+export const __Uint8Array_prototype_setFromHex = (_this: Uint8Array, str: any) => {
+  if (Porffor.type(str) != Porffor.TYPES.bytestring) {
+    throw new TypeError('First argument must be a string');
+  }
+
+  __Porffor_uint8array_validate(_this);
+  const taPtr: i32 = Porffor.wasm`local.get ${_this}`;
+  const byteLength: i32 = Porffor.wasm.i32.load(taPtr, 0, 0);
+  const bufferPtr: i32 = Porffor.wasm.i32.load(taPtr, 0, 4);
+
+  const result: i32 = __Porffor_fromHex(str, bufferPtr, byteLength);
+  const charsRead: i32 = result >> 16;
+  const bytesWritten: i32 = result & 0xFFFF;
+
+  const resultObj: object = {};
+  resultObj.read = charsRead;
+  resultObj.written = bytesWritten;
+
+  return resultObj;
+};