@fraczak/k 6.3.3 → 6.5.0

package/browser/shims/assert.mjs

@@ -0,0 +1,19 @@
+export function assert(val, msg) {
+  if (!val) throw new Error(msg || "Assertion failed");
+}
+
+assert.equal = function(a, b, msg) {
+  if (a != b) throw new Error(msg || `${a} != ${b}`);
+};
+
+assert.strictEqual = function(a, b, msg) {
+  if (a !== b) throw new Error(msg || `${a} !== ${b}`);
+};
+
+assert.deepEqual = function(a, b, msg) {
+  if (JSON.stringify(a) !== JSON.stringify(b)) throw new Error(msg || "Deep equality assertion failed");
+};
+
+assert.ok = assert;
+
+export default assert;

package/browser/shims/buffer.mjs

@@ -0,0 +1,224 @@
+export class Buffer extends Uint8Array {
+  static from(data, encoding) {
+    if (typeof data === "string") {
+      return new Buffer(new TextEncoder().encode(data));
+    }
+    if (data instanceof Uint8Array || Array.isArray(data) || data instanceof ArrayBuffer) {
+      return new Buffer(data);
+    }
+    if (data?.buffer instanceof ArrayBuffer) {
+      return new Buffer(data.buffer, data.byteOffset, data.byteLength);
+    }
+    return new Buffer(data || 0);
+  }
+
+  static isBuffer(val) {
+    return val instanceof Uint8Array;
+  }
+
+  static alloc(size, fill = 0) {
+    const buf = new Buffer(size);
+    if (fill !== 0) buf.fill(fill);
+    return buf;
+  }
+
+  static concat(list, totalLength) {
+    const total = totalLength ?? list.reduce((acc, c) => acc + (c?.length || 0), 0);
+    const result = new Buffer(total);
+    let offset = 0;
+    for (const chunk of list) {
+      if (!chunk) continue;
+      result.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return result;
+  }
+
+  static compare(a, b) {
+    const len = Math.min(a.length, b.length);
+    for (let i = 0; i < len; i++) {
+      if (a[i] !== b[i]) return a[i] < b[i] ? -1 : 1;
+    }
+    return a.length === b.length ? 0 : a.length < b.length ? -1 : 1;
+  }
+
+  toString(encoding = "utf8") {
+    if (encoding === "hex") {
+      return Array.from(this).map(b => b.toString(16).padStart(2, "0")).join("");
+    }
+    return new TextDecoder("utf-8").decode(this);
+  }
+
+  writeUInt32BE(val, offset = 0) {
+    new DataView(this.buffer, this.byteOffset, this.byteLength).setUint32(offset, Number(val), false);
+    return offset + 4;
+  }
+
+  readUInt32BE(offset = 0) {
+    return new DataView(this.buffer, this.byteOffset, this.byteLength).getUint32(offset, false);
+  }
+
+  writeUInt32LE(val, offset = 0) {
+    new DataView(this.buffer, this.byteOffset, this.byteLength).setUint32(offset, Number(val), true);
+    return offset + 4;
+  }
+
+  readUInt32LE(offset = 0) {
+    return new DataView(this.buffer, this.byteOffset, this.byteLength).getUint32(offset, true);
+  }
+
+  writeInt32BE(val, offset = 0) {
+    new DataView(this.buffer, this.byteOffset, this.byteLength).setInt32(offset, Number(val), false);
+    return offset + 4;
+  }
+
+  readInt32BE(offset = 0) {
+    return new DataView(this.buffer, this.byteOffset, this.byteLength).getInt32(offset, false);
+  }
+
+  writeInt32LE(val, offset = 0) {
+    new DataView(this.buffer, this.byteOffset, this.byteLength).setInt32(offset, Number(val), true);
+    return offset + 4;
+  }
+
+  readInt32LE(offset = 0) {
+    return new DataView(this.buffer, this.byteOffset, this.byteLength).getInt32(offset, true);
+  }
+
+  writeUInt16BE(val, offset = 0) {
+    new DataView(this.buffer, this.byteOffset, this.byteLength).setUint16(offset, Number(val), false);
+    return offset + 2;
+  }
+
+  readUInt16BE(offset = 0) {
+    return new DataView(this.buffer, this.byteOffset, this.byteLength).getUint16(offset, false);
+  }
+
+  writeUInt16LE(val, offset = 0) {
+    new DataView(this.buffer, this.byteOffset, this.byteLength).setUint16(offset, Number(val), true);
+    return offset + 2;
+  }
+
+  readUInt16LE(offset = 0) {
+    return new DataView(this.buffer, this.byteOffset, this.byteLength).getUint16(offset, true);
+  }
+
+  writeInt16BE(val, offset = 0) {
+    new DataView(this.buffer, this.byteOffset, this.byteLength).setInt16(offset, Number(val), false);
+    return offset + 2;
+  }
+
+  readInt16BE(offset = 0) {
+    return new DataView(this.buffer, this.byteOffset, this.byteLength).getInt16(offset, false);
+  }
+
+  writeInt16LE(val, offset = 0) {
+    new DataView(this.buffer, this.byteOffset, this.byteLength).setInt16(offset, Number(val), true);
+    return offset + 2;
+  }
+
+  readInt16LE(offset = 0) {
+    return new DataView(this.buffer, this.byteOffset, this.byteLength).getInt16(offset, true);
+  }
+
+  writeUInt8(val, offset = 0) {
+    new DataView(this.buffer, this.byteOffset, this.byteLength).setUint8(offset, Number(val));
+    return offset + 1;
+  }
+
+  readUInt8(offset = 0) {
+    return new DataView(this.buffer, this.byteOffset, this.byteLength).getUint8(offset);
+  }
+
+  writeInt8(val, offset = 0) {
+    new DataView(this.buffer, this.byteOffset, this.byteLength).setInt8(offset, Number(val));
+    return offset + 1;
+  }
+
+  readInt8(offset = 0) {
+    return new DataView(this.buffer, this.byteOffset, this.byteLength).getInt8(offset);
+  }
+
+  writeDoubleBE(val, offset = 0) {
+    new DataView(this.buffer, this.byteOffset, this.byteLength).setFloat64(offset, Number(val), false);
+    return offset + 8;
+  }
+
+  readDoubleBE(offset = 0) {
+    return new DataView(this.buffer, this.byteOffset, this.byteLength).getFloat64(offset, false);
+  }
+
+  writeDoubleLE(val, offset = 0) {
+    new DataView(this.buffer, this.byteOffset, this.byteLength).setFloat64(offset, Number(val), true);
+    return offset + 8;
+  }
+
+  readDoubleLE(offset = 0) {
+    return new DataView(this.buffer, this.byteOffset, this.byteLength).getFloat64(offset, true);
+  }
+
+  writeFloatBE(val, offset = 0) {
+    new DataView(this.buffer, this.byteOffset, this.byteLength).setFloat32(offset, Number(val), false);
+    return offset + 4;
+  }
+
+  readFloatBE(offset = 0) {
+    return new DataView(this.buffer, this.byteOffset, this.byteLength).getFloat32(offset, false);
+  }
+
+  writeFloatLE(val, offset = 0) {
+    new DataView(this.buffer, this.byteOffset, this.byteLength).setFloat32(offset, Number(val), true);
+    return offset + 4;
+  }
+
+  readFloatLE(offset = 0) {
+    return new DataView(this.buffer, this.byteOffset, this.byteLength).getFloat32(offset, true);
+  }
+
+  writeBigUInt64BE(val, offset = 0) {
+    new DataView(this.buffer, this.byteOffset, this.byteLength).setBigUint64(offset, BigInt(val), false);
+    return offset + 8;
+  }
+
+  readBigUInt64BE(offset = 0) {
+    return new DataView(this.buffer, this.byteOffset, this.byteLength).getBigUint64(offset, false);
+  }
+
+  writeBigUInt64LE(val, offset = 0) {
+    new DataView(this.buffer, this.byteOffset, this.byteLength).setBigUint64(offset, BigInt(val), true);
+    return offset + 8;
+  }
+
+  readBigUInt64LE(offset = 0) {
+    return new DataView(this.buffer, this.byteOffset, this.byteLength).getBigUint64(offset, true);
+  }
+
+  writeBigInt64BE(val, offset = 0) {
+    new DataView(this.buffer, this.byteOffset, this.byteLength).setBigInt64(offset, BigInt(val), false);
+    return offset + 8;
+  }
+
+  readBigInt64BE(offset = 0) {
+    return new DataView(this.buffer, this.byteOffset, this.byteLength).getBigInt64(offset, false);
+  }
+
+  writeBigInt64LE(val, offset = 0) {
+    new DataView(this.buffer, this.byteOffset, this.byteLength).setBigInt64(offset, BigInt(val), true);
+    return offset + 8;
+  }
+
+  readBigInt64LE(offset = 0) {
+    return new DataView(this.buffer, this.byteOffset, this.byteLength).getBigInt64(offset, true);
+  }
+
+  subarray(start, end) {
+    const sub = super.subarray(start, end);
+    return new Buffer(sub.buffer, sub.byteOffset, sub.byteLength);
+  }
+}
+
+if (typeof globalThis !== "undefined") {
+  globalThis.Buffer = Buffer;
+}
+
+export default Buffer;

package/browser/shims/crypto.mjs

@@ -0,0 +1,103 @@
+import { Buffer } from "./buffer.mjs";
+
+function sha256(input) {
+  const K = [
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+  ];
+  const H = [
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
+    0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
+  ];
+  const bytes = typeof input === "string" ? new TextEncoder().encode(input) : input;
+  const bitLen = bytes.length * 8;
+  const padLen = ((bytes.length + 8) >> 6) + 1;
+  const words = new Uint32Array(padLen * 16);
+  for (let i = 0; i < bytes.length; i++) {
+    words[i >> 2] |= bytes[i] << (24 - (i % 4) * 8);
+  }
+  words[bytes.length >> 2] |= 0x80 << (24 - (bytes.length % 4) * 8);
+  words[words.length - 2] = Math.floor(bitLen / 0x100000000);
+  words[words.length - 1] = bitLen >>> 0;
+
+  const w = new Uint32Array(64);
+  for (let c = 0; c < words.length; c += 16) {
+    for (let i = 0; i < 16; i++) w[i] = words[c + i];
+    for (let i = 16; i < 64; i++) {
+      const s0 = ((w[i - 15] >>> 7) | (w[i - 15] << 25)) ^
+                 ((w[i - 15] >>> 18) | (w[i - 15] << 14)) ^
+                 (w[i - 15] >>> 3);
+      const s1 = ((w[i - 2] >>> 17) | (w[i - 2] << 15)) ^
+                 ((w[i - 2] >>> 19) | (w[i - 2] << 13)) ^
+                 (w[i - 2] >>> 10);
+      w[i] = (w[i - 16] + s0 + w[i - 7] + s1) | 0;
+    }
+    let a = H[0], b = H[1], c0 = H[2], d = H[3], e = H[4], f = H[5], g = H[6], h = H[7];
+    for (let i = 0; i < 64; i++) {
+      const s1 = ((e >>> 6) | (e << 26)) ^ ((e >>> 11) | (e << 21)) ^ ((e >>> 25) | (e << 7));
+      const ch = (e & f) ^ (~e & g);
+      const temp1 = (h + s1 + ch + K[i] + w[i]) | 0;
+      const s0 = ((a >>> 2) | (a << 30)) ^ ((a >>> 13) | (a << 19)) ^ ((a >>> 22) | (a << 10));
+      const maj = (a & b) ^ (a & c0) ^ (b & c0);
+      const temp2 = (s0 + maj) | 0;
+      h = g; g = f; f = e; e = (d + temp1) | 0;
+      d = c0; c0 = b; b = a; a = (temp1 + temp2) | 0;
+    }
+    H[0] = (H[0] + a) | 0;
+    H[1] = (H[1] + b) | 0;
+    H[2] = (H[2] + c0) | 0;
+    H[3] = (H[3] + d) | 0;
+    H[4] = (H[4] + e) | 0;
+    H[5] = (H[5] + f) | 0;
+    H[6] = (H[6] + g) | 0;
+    H[7] = (H[7] + h) | 0;
+  }
+  const out = new Uint8Array(32);
+  for (let i = 0; i < 8; i++) {
+    out[i * 4] = (H[i] >>> 24) & 0xff;
+    out[i * 4 + 1] = (H[i] >>> 16) & 0xff;
+    out[i * 4 + 2] = (H[i] >>> 8) & 0xff;
+    out[i * 4 + 3] = H[i] & 0xff;
+  }
+  return out;
+}
+
+export function createHash(algorithm) {
+  if (algorithm.toLowerCase() !== "sha256") {
+    throw new Error(`Unsupported hash algorithm in browser: ${algorithm}`);
+  }
+  let chunks = [];
+  return {
+    update(data) {
+      if (typeof data === "string") {
+        chunks.push(new TextEncoder().encode(data));
+      } else if (data instanceof Uint8Array) {
+        chunks.push(data);
+      } else {
+        chunks.push(new TextEncoder().encode(String(data)));
+      }
+      return this;
+    },
+    digest(encoding) {
+      let totalLength = chunks.reduce((acc, c) => acc + c.length, 0);
+      let merged = new Uint8Array(totalLength);
+      let offset = 0;
+      for (const c of chunks) {
+        merged.set(c, offset);
+        offset += c.length;
+      }
+      const raw = sha256(merged);
+      const buf = Buffer.from(raw);
+      if (encoding) return buf.toString(encoding);
+      return buf;
+    }
+  };
+}
+
+export default { createHash };

package/browser/shims/fs.mjs

@@ -0,0 +1,159 @@
+import { Buffer } from "./buffer.mjs";
+import { vfsData } from "../vfs-data.mjs";
+
+const vfs = new Map();
+if (vfsData && typeof vfsData === "object") {
+  for (const [k, v] of Object.entries(vfsData)) {
+    vfs.set(k, v);
+  }
+}
+
+function cleanPath(p) {
+  let s = (p instanceof URL ? p.pathname : (p?.pathname || String(p))).replace(/\\/g, "/");
+  if (s.startsWith("file://")) s = s.replace(/^file:\/\//, "");
+  if (s.endsWith("runtime.wat")) return "backends/wasm/runtime.wat";
+  const exIdx = s.lastIndexOf("Examples/");
+  if (exIdx !== -1) return s.slice(exIdx);
+  const wasmIdx = s.lastIndexOf("backends/wasm/");
+  if (wasmIdx !== -1) return s.slice(wasmIdx);
+  const codecsIdx = s.lastIndexOf("codecs/");
+  if (codecsIdx !== -1) return s.slice(codecsIdx);
+  if (s.endsWith("/core.k") || s === "core.k") return "core.k";
+  if (s.startsWith("./")) s = s.slice(2);
+  while (s.startsWith("/")) s = s.slice(1);
+  return s;
+}
+
+export function setVfsFile(path, content) {
+  const cleaned = cleanPath(path);
+  vfs.set(cleaned, content);
+}
+
+export function getVfsFile(path) {
+  const cleaned = cleanPath(path);
+  if (vfs.has(cleaned)) return vfs.get(cleaned);
+  if (cleaned.startsWith("Examples/")) {
+    const stripped = cleaned.slice("Examples/".length);
+    if (vfs.has(stripped)) return vfs.get(stripped);
+  } else {
+    const withEx = `Examples/${cleaned}`;
+    if (vfs.has(withEx)) return vfs.get(withEx);
+  }
+  if (cleaned.startsWith("codecs/")) {
+    const stripped = cleaned.slice("codecs/".length);
+    if (vfs.has(stripped)) return vfs.get(stripped);
+  } else {
+    const withCodecs = `codecs/${cleaned}`;
+    if (vfs.has(withCodecs)) return vfs.get(withCodecs);
+  }
+  return undefined;
+}
+
+const CURATED_VFS_FILES = [
+  "core.k",
+  "arithmetics.k",
+  "ieee.k",
+  "json.mjs",
+  "utf8.mjs",
+  "int.mjs",
+  "unit.mjs",
+  "ieee.mjs"
+];
+
+export function getAllVfsFiles() {
+  const result = new Set();
+  for (const name of CURATED_VFS_FILES) {
+    if (getVfsFile(name) !== undefined) {
+      result.add(name);
+    }
+  }
+  for (const key of vfs.keys()) {
+    if (key.endsWith("runtime.wat") || key.startsWith("backends/")) continue;
+    if (key.startsWith("Examples/") || key.startsWith("codecs/")) continue;
+    result.add(key);
+  }
+  return Array.from(result);
+}
+
+export function readFileSync(filePath, options) {
+  const data = getVfsFile(filePath);
+  if (data === undefined) {
+    throw new Error(`ENOENT: no such file or directory, open '${filePath}'`);
+  }
+  const encoding = typeof options === "string" ? options : options?.encoding;
+  if (encoding === "utf8" || encoding === "utf-8") {
+    if (typeof data === "string") return data;
+    return new TextDecoder().decode(data);
+  }
+  if (typeof data === "string") {
+    return Buffer.from(data, "utf8");
+  }
+  return Buffer.from(data);
+}
+
+export function writeFileSync(filePath, data) {
+  const cleaned = cleanPath(filePath);
+  vfs.set(cleaned, data);
+}
+
+export function existsSync(filePath) {
+  return getVfsFile(filePath) !== undefined;
+}
+
+export function readdirSync(dirPath, options = {}) {
+  const cleanedDir = cleanPath(dirPath);
+  const prefix = (!cleanedDir || cleanedDir === ".") ? "" : (cleanedDir.endsWith("/") ? cleanedDir : cleanedDir + "/");
+  const results = new Set();
+  for (const key of vfs.keys()) {
+    if (prefix === "" || key.startsWith(prefix)) {
+      const rest = key.slice(prefix.length);
+      const name = rest.split("/")[0];
+      if (name) results.add(name);
+    }
+  }
+  const withFileTypes = options?.withFileTypes ?? false;
+  if (withFileTypes) {
+    return Array.from(results).map(name => {
+      const subPrefix = prefix + name + "/";
+      let isDir = false;
+      for (const k of vfs.keys()) {
+        if (k.startsWith(subPrefix)) {
+          isDir = true;
+          break;
+        }
+      }
+      return {
+        name,
+        isDirectory: () => isDir,
+        isFile: () => !isDir
+      };
+    });
+  }
+  return Array.from(results);
+}
+
+export function realpathSync(p) {
+  return cleanPath(p);
+}
+
+export function statSync(p) {
+  const data = readFileSync(p);
+  const size = typeof data === "string" ? new TextEncoder().encode(data).length : data.length;
+  return {
+    size,
+    isFile: () => true,
+    isDirectory: () => false
+  };
+}
+
+export default {
+  readFileSync,
+  writeFileSync,
+  existsSync,
+  readdirSync,
+  realpathSync,
+  statSync,
+  setVfsFile,
+  getVfsFile,
+  getAllVfsFiles
+};

package/browser/shims/os.mjs

@@ -0,0 +1,17 @@
+export function homedir() {
+  return "/home";
+}
+
+export function tmpdir() {
+  return "/tmp";
+}
+
+export function platform() {
+  return "browser";
+}
+
+export default {
+  homedir,
+  tmpdir,
+  platform
+};

package/browser/shims/path.mjs

@@ -0,0 +1,54 @@
+export function normalize(path) {
+  const parts = path.split("/").filter(Boolean);
+  const stack = [];
+  for (const part of parts) {
+    if (part === ".") continue;
+    if (part === "..") {
+      stack.pop();
+    } else {
+      stack.push(part);
+    }
+  }
+  const prefix = path.startsWith("/") ? "/" : "";
+  return prefix + stack.join("/");
+}
+
+export function join(...parts) {
+  return normalize(parts.filter(Boolean).join("/"));
+}
+
+export function dirname(path) {
+  const normalized = normalize(path);
+  const idx = normalized.lastIndexOf("/");
+  if (idx === -1) return ".";
+  if (idx === 0) return "/";
+  return normalized.slice(0, idx);
+}
+
+export function basename(path, ext) {
+  const normalized = normalize(path);
+  let base = normalized.slice(normalized.lastIndexOf("/") + 1);
+  if (ext && base.endsWith(ext)) {
+    base = base.slice(0, -ext.length);
+  }
+  return base;
+}
+
+export function extname(path) {
+  const base = basename(path);
+  const idx = base.lastIndexOf(".");
+  return idx === -1 ? "" : base.slice(idx);
+}
+
+export function resolve(...parts) {
+  return join(...parts);
+}
+
+export default {
+  normalize,
+  join,
+  dirname,
+  basename,
+  extname,
+  resolve
+};

package/browser/shims/process.mjs

@@ -0,0 +1,44 @@
+export const argv = ["browser"];
+export const env = {};
+
+export function exit(code = 0) {
+  console.warn(`process.exit(${code}) called in browser`);
+}
+
+export const stdin = {
+  on() {},
+  resume() {},
+  pause() {}
+};
+
+export const stdout = {
+  write(chunk) {
+    console.log(chunk);
+  }
+};
+
+export const hrtime = function() {
+  const now = performance.now();
+  const sec = Math.floor(now / 1000);
+  const nsec = Math.floor((now % 1000) * 1e6);
+  return [sec, nsec];
+};
+hrtime.bigint = function() {
+  return BigInt(Math.round(performance.now() * 1e6));
+};
+
+export const processShim = {
+  argv,
+  env,
+  exit,
+  stdin,
+  stdout,
+  hrtime,
+  versions: { wabt_browser: "1.0" }
+};
+
+if (typeof globalThis !== "undefined" && (!globalThis.process || !globalThis.process.hrtime)) {
+  globalThis.process = processShim;
+}
+
+export default processShim;

package/browser/shims/readline.mjs

@@ -0,0 +1,11 @@
+export function createInterface() {
+  return {
+    on() { return this; },
+    close() {},
+    prompt() {},
+    setPrompt() {},
+    write() {}
+  };
+}
+
+export default { createInterface };

package/browser/shims/url.mjs

@@ -0,0 +1,12 @@
+export function fileURLToPath(url) {
+  return String(url).replace(/^file:\/\//, "");
+}
+
+export function pathToFileURL(filepath) {
+  return new URL(`file://${filepath}`);
+}
+
+export default {
+  fileURLToPath,
+  pathToFileURL
+};