purus 0.8.0 → 0.9.0

package/stdlib/p-math.js

@@ -0,0 +1,29 @@
+// Purus stdlib: math — Math alias with lowercase constants
+//
+// math = JS Math + lowercase aliases for uppercase constants (PI → pi, etc.)
+// All Math.* methods (abs, sin, floor, ...) are available as-is.
+
+exports.spread = "Math";
+
+exports.mod = {
+  ...Math,
+  pi: Math.PI,
+  e: Math.E,
+  ln2: Math.LN2,
+  ln10: Math.LN10,
+  log2e: Math.LOG2E,
+  log10e: Math.LOG10E,
+  sqrt2: Math.SQRT2,
+  sqrt1_2: Math.SQRT1_2,
+};
+
+exports.constants = {
+  pi: "PI",
+  e: "E",
+  ln2: "LN2",
+  ln10: "LN10",
+  log2e: "LOG2E",
+  log10e: "LOG10E",
+  sqrt2: "SQRT2",
+  sqrt1_2: "SQRT1_2",
+};

package/stdlib/p-number.js

@@ -0,0 +1,51 @@
+// Purus stdlib: p-number — Number utility functions
+//
+// test: node -e "const n = require('./stdlib/p-number'); console.log(n.mod.isfinite(42))"
+
+exports.mod = {
+  isfinite(val) {
+    return Number.isFinite(val);
+  },
+  isinteger(val) {
+    return Number.isInteger(val);
+  },
+  isnan(val) {
+    return Number.isNaN(val);
+  },
+  issafe(val) {
+    return Number.isSafeInteger(val);
+  },
+  parsefloat(str) {
+    return Number.parseFloat(str);
+  },
+  parseint(str, radix) {
+    return Number.parseInt(str, radix || 10);
+  },
+  tofixed(num, digits) {
+    return Number(num).toFixed(digits || 0);
+  },
+  toprecision(num, digits) {
+    return Number(num).toPrecision(digits);
+  },
+  toexponential(num, digits) {
+    return Number(num).toExponential(digits);
+  },
+  tostring(num, radix) {
+    return Number(num).toString(radix || 10);
+  },
+  clamp(num, min, max) {
+    return Math.min(Math.max(num, min), max);
+  },
+};
+
+exports.spread = "Number";
+
+exports.constants = {
+  maxsafe: "MAX_SAFE_INTEGER",
+  minsafe: "MIN_SAFE_INTEGER",
+  epsilon: "EPSILON",
+  maxvalue: "MAX_VALUE",
+  minvalue: "MIN_VALUE",
+  posinf: "POSITIVE_INFINITY",
+  neginf: "NEGATIVE_INFINITY",
+};

package/stdlib/p-object.js

@@ -0,0 +1,69 @@
+// Purus stdlib: p-object — Object utility functions
+//
+// test: node -e "const o = require('./stdlib/p-object'); console.log(o.mod.keys({a:1,b:2}))"
+
+exports.mod = {
+  keys(obj) {
+    return Object.keys(obj);
+  },
+  values(obj) {
+    return Object.values(obj);
+  },
+  entries(obj) {
+    return Object.entries(obj);
+  },
+  fromentries(arr) {
+    return Object.fromEntries(arr);
+  },
+  assign(target, ...sources) {
+    return Object.assign(target, ...sources);
+  },
+  freeze(obj) {
+    return Object.freeze(obj);
+  },
+  seal(obj) {
+    return Object.seal(obj);
+  },
+  isfrozen(obj) {
+    return Object.isFrozen(obj);
+  },
+  issealed(obj) {
+    return Object.isSealed(obj);
+  },
+  hasown(obj, key) {
+    return Object.hasOwn(obj, key);
+  },
+  create(proto, props) {
+    return Object.create(proto, props);
+  },
+  is(a, b) {
+    return Object.is(a, b);
+  },
+  len(obj) {
+    return Object.keys(obj).length;
+  },
+  merge(...objs) {
+    return Object.assign({}, ...objs);
+  },
+  clone(obj) {
+    return structuredClone(obj);
+  },
+  pick(obj, keys) {
+    const result = {};
+    for (const k of keys) {
+      if (k in obj) result[k] = obj[k];
+    }
+    return result;
+  },
+  omit(obj, keys) {
+    const set = new Set(keys);
+    const result = {};
+    for (const k of Object.keys(obj)) {
+      if (!set.has(k)) result[k] = obj[k];
+    }
+    return result;
+  },
+};
+
+exports.spread = null;
+exports.constants = {};

package/stdlib/p-promise.js

@@ -0,0 +1,45 @@
+// Purus stdlib: p-promise — Promise utility functions
+//
+// test: node -e "const p = require('./stdlib/p-promise'); p.mod.resolve(42).then(v => console.log(v))"
+
+exports.mod = {
+  resolve(value) {
+    return Promise.resolve(value);
+  },
+  reject(reason) {
+    return Promise.reject(reason);
+  },
+  all(promises) {
+    return Promise.all(promises);
+  },
+  allsettled(promises) {
+    return Promise.allSettled(promises);
+  },
+  race(promises) {
+    return Promise.race(promises);
+  },
+  any(promises) {
+    return Promise.any(promises);
+  },
+  create(executor) {
+    return new Promise(executor);
+  },
+  delay(ms) {
+    return new Promise(function (resolve) {
+      setTimeout(resolve, ms);
+    });
+  },
+  timeout(promise, ms) {
+    return Promise.race([
+      promise,
+      new Promise(function (_, reject) {
+        setTimeout(function () {
+          reject(new Error("Promise timed out"));
+        }, ms);
+      }),
+    ]);
+  },
+};
+
+exports.spread = null;
+exports.constants = {};

package/stdlib/p-random.js

@@ -0,0 +1,218 @@
+// Purus stdlib: random
+//
+// test: node -e "const r = require('./stdlib/random'); console.log(r.mod.randint(1, 10))"
+
+exports.mod = {
+  // --- core ---
+  random() {
+    return Math.random();
+  },
+  randint(a, b) {
+    return Math.floor(Math.random() * (b - a + 1)) + a;
+  },
+  randrange(...args) {
+    let start = 0,
+      stop,
+      step = 1;
+    if (args.length === 1) {
+      stop = args[0];
+    } else if (args.length === 2) {
+      start = args[0];
+      stop = args[1];
+    } else {
+      start = args[0];
+      stop = args[1];
+      step = args[2];
+    }
+    const n = Math.ceil((stop - start) / step);
+    return start + step * Math.floor(Math.random() * n);
+  },
+  randbool(p) {
+    if (p === undefined) p = 0.5;
+    return Math.random() < p;
+  },
+  getrandbits(k) {
+    if (k <= 0) return 0;
+    if (k <= 32) return (Math.random() * (1 << k)) >>> 0;
+    let result = 0;
+    let remaining = k;
+    while (remaining > 0) {
+      const bits = Math.min(remaining, 32);
+      result = result * (1 << bits) + ((Math.random() * (1 << bits)) >>> 0);
+      remaining -= bits;
+    }
+    return result;
+  },
+  randbytes(n) {
+    const bytes = new Uint8Array(n);
+    for (let i = 0; i < n; i++) {
+      bytes[i] = (Math.random() * 256) >>> 0;
+    }
+    return Array.from(bytes);
+  },
+  normalvariate(mu, sigma) {
+    return this.gauss(mu, sigma);
+  },
+
+  // --- real-valued distributions ---
+  uniform(a, b) {
+    return a + (b - a) * Math.random();
+  },
+  triangular(lo, hi, mode) {
+    if (lo === undefined) lo = 0;
+    if (hi === undefined) hi = 1;
+    if (mode === undefined) mode = (lo + hi) / 2;
+    const u = Math.random(),
+      c = (mode - lo) / (hi - lo);
+    return u < c
+      ? lo + Math.sqrt(u * (hi - lo) * (mode - lo))
+      : hi - Math.sqrt((1 - u) * (hi - lo) * (hi - mode));
+  },
+  gauss(mu, sigma) {
+    if (mu === undefined) mu = 0;
+    if (sigma === undefined) sigma = 1;
+    let u, v, s;
+    do {
+      u = Math.random() * 2 - 1;
+      v = Math.random() * 2 - 1;
+      s = u * u + v * v;
+    } while (s >= 1 || s === 0);
+    return mu + sigma * u * Math.sqrt((-2 * Math.log(s)) / s);
+  },
+  expovariate(lambd) {
+    return -Math.log(1 - Math.random()) / lambd;
+  },
+  gammavariate(alpha, beta) {
+    if (alpha > 1) {
+      const d = alpha - 1 / 3,
+        c = 1 / Math.sqrt(9 * d);
+      let x, v;
+      do {
+        do {
+          x = this.gauss(0, 1);
+          v = 1 + c * x;
+        } while (v <= 0);
+        v = v * v * v;
+      } while (
+        Math.log(Math.random()) >=
+        0.5 * x * x + d - d * v + d * Math.log(v)
+      );
+      return d * v * beta;
+    }
+    if (alpha === 1) return -Math.log(1 - Math.random()) * beta;
+    return (
+      this.gammavariate(alpha + 1, beta) * Math.pow(Math.random(), 1 / alpha)
+    );
+  },
+  betavariate(alpha, beta) {
+    const y = this.gammavariate(alpha, 1);
+    return y === 0 ? 0 : y / (y + this.gammavariate(beta, 1));
+  },
+  lognormvariate(mu, sigma) {
+    return Math.exp(this.gauss(mu, sigma));
+  },
+  vonmisesvariate(mu, kappa) {
+    if (kappa <= 1e-6) return 2 * Math.PI * Math.random();
+    const a = 1 + Math.sqrt(1 + 4 * kappa * kappa),
+      b = (a - Math.sqrt(2 * a)) / (2 * kappa),
+      r = (1 + b * b) / (2 * b);
+    let f;
+    do {
+      const u1 = Math.random(),
+        z = Math.cos(Math.PI * u1),
+        d = z / (r + z),
+        u2 = Math.random();
+      if (u2 < 1 - d * d || u2 <= (1 - d) * Math.exp(d)) {
+        f = (1 / r + z) / (1 + r * z);
+        break;
+      }
+    } while (true);
+    return (
+      (((Math.random() > 0.5 ? mu + Math.acos(f) : mu - Math.acos(f)) %
+        (2 * Math.PI)) +
+        2 * Math.PI) %
+      (2 * Math.PI)
+    );
+  },
+  paretovariate(alpha) {
+    return Math.pow(1 - Math.random(), -1 / alpha);
+  },
+  weibullvariate(alpha, beta) {
+    return alpha * Math.pow(-Math.log(1 - Math.random()), 1 / beta);
+  },
+
+  // --- sequence ---
+  choice(arr) {
+    return arr[Math.floor(Math.random() * arr.length)];
+  },
+  choices(arr, k) {
+    return Array.from(
+      { length: k },
+      () => arr[Math.floor(Math.random() * arr.length)],
+    );
+  },
+  wchoices(arr, weights, k) {
+    const cum = [];
+    let s = 0;
+    for (const w of weights) {
+      s += w;
+      cum.push(s);
+    }
+    return Array.from({ length: k }, () => {
+      const r = Math.random() * s;
+      let lo = 0,
+        hi = cum.length - 1;
+      while (lo < hi) {
+        const mid = (lo + hi) >> 1;
+        cum[mid] < r ? (lo = mid + 1) : (hi = mid);
+      }
+      return arr[lo];
+    });
+  },
+  shuffle(arr) {
+    const a = [...arr];
+    for (let i = a.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [a[i], a[j]] = [a[j], a[i]];
+    }
+    return a;
+  },
+  sample(arr, k) {
+    const a = [...arr];
+    for (let i = a.length - 1; i > 0; i--) {
+      const j = Math.floor(Math.random() * (i + 1));
+      [a[i], a[j]] = [a[j], a[i]];
+    }
+    return a.slice(0, k);
+  },
+
+  // --- discrete ---
+  binomial(n, p) {
+    let x = 0;
+    for (let i = 0; i < n; i++) {
+      if (Math.random() < p) x++;
+    }
+    return x;
+  },
+  poisson(lambda) {
+    const L = Math.exp(-lambda);
+    let k = 0,
+      p = 1;
+    do {
+      k++;
+      p *= Math.random();
+    } while (p > L);
+    return k - 1;
+  },
+  geometric(p) {
+    return Math.floor(Math.log(1 - Math.random()) / Math.log(1 - p)) + 1;
+  },
+
+  // --- utility ---
+  clamp(val, lo, hi) {
+    return Math.min(Math.max(val, lo), hi);
+  },
+  lerp(a, b, t) {
+    return a + (b - a) * t;
+  },
+};

package/stdlib/p-regexp.js

@@ -0,0 +1,50 @@
+// Purus stdlib: p-regexp — Regular expression utilities
+//
+// test: node -e "const r = require('./stdlib/p-regexp'); console.log(r.mod.test(/\d+/, '42'))"
+
+exports.mod = {
+  create(pattern, flags) {
+    return new RegExp(pattern, flags || "");
+  },
+  test(re, str) {
+    return re instanceof RegExp ? re.test(str) : new RegExp(re).test(str);
+  },
+  match(re, str) {
+    return str.match(re);
+  },
+  matchall(re, str) {
+    const r = re instanceof RegExp ? re : new RegExp(re, "g");
+    if (!r.flags.includes("g")) {
+      return [...str.matchAll(new RegExp(r.source, r.flags + "g"))];
+    }
+    return [...str.matchAll(r)];
+  },
+  exec(re, str) {
+    return re.exec(str);
+  },
+  replace(re, str, replacement) {
+    return str.replace(re, replacement);
+  },
+  replaceall(re, str, replacement) {
+    const r = re instanceof RegExp ? re : new RegExp(re, "g");
+    if (!r.flags.includes("g")) {
+      return str.replaceAll(new RegExp(r.source, r.flags + "g"), replacement);
+    }
+    return str.replaceAll(r, replacement);
+  },
+  split(re, str) {
+    return str.split(re);
+  },
+  source(re) {
+    return re.source;
+  },
+  flags(re) {
+    return re.flags;
+  },
+  escape(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  },
+};
+
+exports.spread = null;
+exports.constants = {};

package/stdlib/p-set.js

@@ -0,0 +1,61 @@
+// Purus stdlib: p-set — Set creation and operations
+//
+// test: node -e "const s = require('./stdlib/p-set'); console.log(s.mod.from([1,2,3,2,1]))"
+
+exports.mod = {
+  create(...items) {
+    return new Set(items);
+  },
+  from(iterable) {
+    return new Set(iterable);
+  },
+  add(set, value) {
+    return new Set(set).add(value);
+  },
+  delete(set, value) {
+    const s = new Set(set);
+    s.delete(value);
+    return s;
+  },
+  has(set, value) {
+    return set.has(value);
+  },
+  size(set) {
+    return set.size;
+  },
+  values(set) {
+    return [...set];
+  },
+  union(a, b) {
+    return a.union(b);
+  },
+  intersection(a, b) {
+    return a.intersection(b);
+  },
+  difference(a, b) {
+    return a.difference(b);
+  },
+  symmetricdifference(a, b) {
+    return a.symmetricDifference(b);
+  },
+  issubset(a, b) {
+    return a.isSubsetOf(b);
+  },
+  issuperset(a, b) {
+    return a.isSupersetOf(b);
+  },
+  isdisjoint(a, b) {
+    return a.isDisjointFrom(b);
+  },
+  clear(set) {
+    const s = new Set(set);
+    s.clear();
+    return s;
+  },
+  toarray(set) {
+    return [...set];
+  },
+};
+
+exports.spread = null;
+exports.constants = {};

package/stdlib/p-string.js

@@ -0,0 +1,103 @@
+// Purus stdlib: string — string utility functions
+//
+// test: node -e "const s = require('./stdlib/string'); console.log(s.mod.reverse('hello'))"
+
+exports.mod = {
+  // --- query ---
+  len(str) {
+    return str.length;
+  },
+  contains(str, sub) {
+    return str.includes(sub);
+  },
+  startswith(str, prefix) {
+    return str.startsWith(prefix);
+  },
+  endswith(str, suffix) {
+    return str.endsWith(suffix);
+  },
+  indexof(str, sub) {
+    return str.indexOf(sub);
+  },
+  count(str, sub) {
+    let c = 0,
+      i = 0;
+    while ((i = str.indexOf(sub, i)) !== -1) {
+      c++;
+      i += sub.length;
+    }
+    return c;
+  },
+
+  // --- transform ---
+  upper(str) {
+    return str.toUpperCase();
+  },
+  lower(str) {
+    return str.toLowerCase();
+  },
+  capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  },
+  title(str) {
+    return str.replace(/\b\w/g, (c) => c.toUpperCase());
+  },
+  trim(str) {
+    return str.trim();
+  },
+  trimstart(str) {
+    return str.trimStart();
+  },
+  trimend(str) {
+    return str.trimEnd();
+  },
+  reverse(str) {
+    return [...str].reverse().join("");
+  },
+  repeat(str, n) {
+    return str.repeat(n);
+  },
+  replace(str, old, rep) {
+    return str.replaceAll(old, rep);
+  },
+  replacefirst(str, old, rep) {
+    return str.replace(old, rep);
+  },
+  padstart(str, len, fill) {
+    return str.padStart(len, fill || " ");
+  },
+  padend(str, len, fill) {
+    return str.padEnd(len, fill || " ");
+  },
+
+  // --- split / join ---
+  split(str, sep) {
+    return str.split(sep);
+  },
+  lines(str) {
+    return str.split(/\r?\n/);
+  },
+  words(str) {
+    return str.split(/\s+/).filter((w) => w.length > 0);
+  },
+  join(arr, sep) {
+    return arr.join(sep);
+  },
+  chars(str) {
+    return [...str];
+  },
+
+  // --- slice ---
+  slice(str, start, end) {
+    return str.slice(start, end);
+  },
+  charat(str, i) {
+    return str.charAt(i);
+  },
+  codeat(str, i) {
+    return str.codePointAt(i);
+  },
+  fromcode(code) {
+    return String.fromCodePoint(code);
+  },
+};