@xnoxs/flux-lang 4.0.9 → 4.1.1

package/src/stdlib.js

@@ -1,33 +1,137 @@
-/* compiled from src/self/stdlib.flux by Flux Lang */
 'use strict';
-// ── Flux stdlib ──
 
-function map(arr, fn) { return arr.map(fn); }
+// ── Flux Standard Library ─────────────────────────────────────────────────────
+// Runtime helpers injected into compiled Flux programs.
+// Each function is self-contained so tree-shaking can work later.
+
+// ── Detection: which stdlib symbols appear in compiled JS? ───────────────────
+const STDLIB_SYMBOLS = [
+  // Sequences
+  'range', 'zip', 'enumerate', 'flatten', 'chunk', 'unique', 'groupBy', 'sortBy',
+
+  // Array pipe helpers
+  'map', 'filter', 'reduce', 'forEach', 'find', 'findIndex',
+  'some', 'every', 'join', 'sort', 'flat', 'flatMap', 'includes',
+
+  // Array extras
+  'first', 'last', 'take', 'drop', 'takeWhile', 'dropWhile',
+  'compact', 'intersection', 'difference', 'arrayUnion', 'unzip',
+  'countBy', 'minBy', 'maxBy', 'toPairs', 'partition',
+  'count', 'head', 'tail', 'nth', 'rotate', 'sliding',
+
+  // Math
+  'clamp', 'sum', 'product',
+  'min', 'max', 'abs', 'floor', 'ceil', 'round',
+  'mean', 'median', 'stdDev', 'lerp',
+  'randInt', 'sample', 'shuffle',
+
+  // Objects
+  'pick', 'omit', 'deepEqual', 'deepClone',
+  'mapValues', 'filterValues', 'fromEntries',
+  'keys', 'values', 'entries', 'merge', 'invert', 'defaults',
+
+  // Strings
+  'capitalize', 'camelCase', 'snakeCase', 'kebabCase', 'truncate', 'pad',
+  'padStart', 'padEnd', 'trim', 'trimStart', 'trimEnd',
+  'words', 'lines', 'startsWith', 'endsWith', 'repeat', 'replaceAll', 'reverseStr',
+
+  // Type checks
+  'isNil', 'isString', 'isNumber', 'isArray', 'isObject', 'isFunction', 'isBool',
+
+  // Async
+  'sleep', 'retry', 'memoize', 'timeout', 'debounce', 'throttle', 'allSettled',
+
+  // Functional
+  'pipe', 'compose', 'partial', 'curry',
+  'identity', 'noop', 'once', 'flip', 'complement',
+];
+
+/**
+ * Build the stdlib preamble JavaScript string.
+ * If `symbols` is provided, only include helpers that are used.
+ * @param {string[]} [symbols]  - list of stdlib names actually used in the output
+ * @returns {string}
+ */
+function buildStdlib(symbols) {
+  const needed = symbols
+    ? new Set(symbols.filter(s => STDLIB_SYMBOLS.includes(s)))
+    : new Set(STDLIB_SYMBOLS);
 
-function filter(arr, fn) { return arr.filter(fn); }
+  if (needed.size === 0) return '';
 
-function reduce(arr, fn, init) { return arguments.length >= 3 ? arr.reduce(fn, init) : arr.reduce(fn); }
+  const parts = ['// ── Flux stdlib ──'];
 
-function forEach(arr, fn) { arr.forEach(fn); return arr; }
+  // ── Array pipe helpers ─────────────────────────────────────────────────────
 
-function find(arr, fn) { return arr.find(fn); }
+  if (needed.has('map')) {
+    parts.push(`
+function map(arr, fn) { return arr.map(fn); }`);
+  }
 
-function findIndex(arr, fn) { return arr.findIndex(fn); }
+  if (needed.has('filter')) {
+    parts.push(`
+function filter(arr, fn) { return arr.filter(fn); }`);
+  }
+
+  if (needed.has('reduce')) {
+    parts.push(`
+function reduce(arr, fn, init) { return arguments.length >= 3 ? arr.reduce(fn, init) : arr.reduce(fn); }`);
+  }
 
-function some(arr, fn) { return arr.some(fn); }
+  if (needed.has('forEach')) {
+    parts.push(`
+function forEach(arr, fn) { arr.forEach(fn); return arr; }`);
+  }
 
-function every(arr, fn) { return arr.every(fn); }
+  if (needed.has('find')) {
+    parts.push(`
+function find(arr, fn) { return arr.find(fn); }`);
+  }
 
-function join(arr, sep) { return arr.join(sep != null ? sep : ','); }
+  if (needed.has('findIndex')) {
+    parts.push(`
+function findIndex(arr, fn) { return arr.findIndex(fn); }`);
+  }
 
-function sort(arr, fn) { return arr.slice().sort(fn); }
+  if (needed.has('some')) {
+    parts.push(`
+function some(arr, fn) { return arr.some(fn); }`);
+  }
 
-function flat(arr, depth) { return arr.flat(depth != null ? depth : 1); }
+  if (needed.has('every')) {
+    parts.push(`
+function every(arr, fn) { return arr.every(fn); }`);
+  }
 
-function flatMap(arr, fn) { return arr.flatMap(fn); }
+  if (needed.has('join')) {
+    parts.push(`
+function join(arr, sep) { return arr.join(sep != null ? sep : ','); }`);
+  }
+
+  if (needed.has('sort')) {
+    parts.push(`
+function sort(arr, fn) { return arr.slice().sort(fn); }`);
+  }
+
+  if (needed.has('flat')) {
+    parts.push(`
+function flat(arr, depth) { return arr.flat(depth != null ? depth : 1); }`);
+  }
+
+  if (needed.has('flatMap')) {
+    parts.push(`
+function flatMap(arr, fn) { return arr.flatMap(fn); }`);
+  }
+
+  if (needed.has('includes')) {
+    parts.push(`
+function includes(arr, val) { return arr.includes(val); }`);
+  }
 
-function includes(arr, val) { return arr.includes(val); }
+  // ── Sequences ──────────────────────────────────────────────────────────────
 
+  if (needed.has('range')) {
+    parts.push(`
 function range(start, end, step) {
   if (arguments.length === 1) { end = start; start = 0; }
   step = step || (end >= start ? 1 : -1);
@@ -35,83 +139,350 @@ function range(start, end, step) {
   if (step > 0) { for (let i = start; i < end; i += step) out.push(i); }
   else          { for (let i = start; i > end; i += step) out.push(i); }
   return out;
-}
+}`);
+  }
 
+  if (needed.has('zip')) {
+    parts.push(`
 function zip() {
   const arrays = Array.from(arguments);
   const len = Math.min.apply(null, arrays.map(function(a) { return a.length; }));
   const out = [];
   for (let i = 0; i < len; i++) out.push(arrays.map(function(a) { return a[i]; }));
   return out;
-}
+}`);
+  }
 
+  if (needed.has('enumerate')) {
+    parts.push(`
 function enumerate(arr, start) {
   start = start || 0;
   return arr.map(function(v, i) { return [i + start, v]; });
-}
+}`);
+  }
 
+  if (needed.has('flatten')) {
+    parts.push(`
 function flatten(arr, depth) {
   return depth == null ? arr.flat(Infinity) : arr.flat(depth);
-}
+}`);
+  }
 
+  if (needed.has('chunk')) {
+    parts.push(`
 function chunk(arr, size) {
   const out = [];
   for (let i = 0; i < arr.length; i += size) out.push(arr.slice(i, i + size));
   return out;
-}
+}`);
+  }
 
+  if (needed.has('unique')) {
+    parts.push(`
 function unique(arr) {
   return Array.from(new Set(arr));
-}
+}`);
+  }
 
+  if (needed.has('groupBy')) {
+    parts.push(`
 function groupBy(arr, fn) {
   return arr.reduce(function(acc, v) {
     var k = typeof fn === 'function' ? fn(v) : v[fn];
     (acc[k] = acc[k] || []).push(v);
     return acc;
   }, {});
-}
+}`);
+  }
 
+  if (needed.has('sortBy')) {
+    parts.push(`
 function sortBy(arr, fn) {
   return arr.slice().sort(function(a, b) {
     var ka = typeof fn === 'function' ? fn(a) : a[fn];
     var kb = typeof fn === 'function' ? fn(b) : b[fn];
     return ka < kb ? -1 : ka > kb ? 1 : 0;
   });
-}
+}`);
+  }
+
+  // ── Array extras ───────────────────────────────────────────────────────────
+
+  if (needed.has('first') || needed.has('head')) {
+    parts.push(`
+function first(arr) { return arr[0]; }
+function head(arr) { return arr[0]; }`);
+  }
+
+  if (needed.has('last')) {
+    parts.push(`
+function last(arr) { return arr[arr.length - 1]; }`);
+  }
+
+  if (needed.has('tail')) {
+    parts.push(`
+function tail(arr) { return arr.slice(1); }`);
+  }
+
+  if (needed.has('nth')) {
+    parts.push(`
+function nth(arr, n) { return n < 0 ? arr[arr.length + n] : arr[n]; }`);
+  }
+
+  if (needed.has('take')) {
+    parts.push(`
+function take(arr, n) { return arr.slice(0, n); }`);
+  }
+
+  if (needed.has('drop')) {
+    parts.push(`
+function drop(arr, n) { return arr.slice(n); }`);
+  }
+
+  if (needed.has('takeWhile')) {
+    parts.push(`
+function takeWhile(arr, fn) {
+  var i = 0;
+  while (i < arr.length && fn(arr[i])) i++;
+  return arr.slice(0, i);
+}`);
+  }
+
+  if (needed.has('dropWhile')) {
+    parts.push(`
+function dropWhile(arr, fn) {
+  var i = 0;
+  while (i < arr.length && fn(arr[i])) i++;
+  return arr.slice(i);
+}`);
+  }
+
+  if (needed.has('compact')) {
+    parts.push(`
+function compact(arr) {
+  return arr.filter(function(v) { return v != null && v !== false && v !== 0 && v !== ''; });
+}`);
+  }
+
+  if (needed.has('intersection')) {
+    parts.push(`
+function intersection(a, b) {
+  var s = new Set(b);
+  return a.filter(function(v) { return s.has(v); });
+}`);
+  }
+
+  if (needed.has('difference')) {
+    parts.push(`
+function difference(a, b) {
+  var s = new Set(b);
+  return a.filter(function(v) { return !s.has(v); });
+}`);
+  }
+
+  if (needed.has('arrayUnion')) {
+    parts.push(`
+function arrayUnion(a, b) {
+  return Array.from(new Set(a.concat(b)));
+}`);
+  }
+
+  if (needed.has('unzip')) {
+    parts.push(`
+function unzip(pairs) {
+  var a = [], b = [];
+  for (var i = 0; i < pairs.length; i++) { a.push(pairs[i][0]); b.push(pairs[i][1]); }
+  return [a, b];
+}`);
+  }
+
+  if (needed.has('countBy')) {
+    parts.push(`
+function countBy(arr, fn) {
+  return arr.reduce(function(acc, v) {
+    var k = typeof fn === 'function' ? fn(v) : v[fn];
+    acc[k] = (acc[k] || 0) + 1;
+    return acc;
+  }, {});
+}`);
+  }
+
+  if (needed.has('minBy')) {
+    parts.push(`
+function minBy(arr, fn) {
+  if (!arr.length) return undefined;
+  return arr.reduce(function(best, v) {
+    return (typeof fn === 'function' ? fn(v) : v[fn]) < (typeof fn === 'function' ? fn(best) : best[fn]) ? v : best;
+  });
+}`);
+  }
+
+  if (needed.has('maxBy')) {
+    parts.push(`
+function maxBy(arr, fn) {
+  if (!arr.length) return undefined;
+  return arr.reduce(function(best, v) {
+    return (typeof fn === 'function' ? fn(v) : v[fn]) > (typeof fn === 'function' ? fn(best) : best[fn]) ? v : best;
+  });
+}`);
+  }
+
+  if (needed.has('toPairs')) {
+    parts.push(`
+function toPairs(obj) {
+  return Object.keys(obj).map(function(k) { return [k, obj[k]]; });
+}`);
+  }
+
+  if (needed.has('partition')) {
+    parts.push(`
+function partition(arr, fn) {
+  var yes = [], no = [];
+  arr.forEach(function(v) { (fn(v) ? yes : no).push(v); });
+  return [yes, no];
+}`);
+  }
 
+  if (needed.has('count')) {
+    parts.push(`
+function count(arr, fn) {
+  if (typeof fn !== 'function') return arr.length;
+  return arr.reduce(function(n, v) { return fn(v) ? n + 1 : n; }, 0);
+}`);
+  }
+
+  if (needed.has('rotate')) {
+    parts.push(`
+function rotate(arr, n) {
+  var len = arr.length;
+  if (!len) return [];
+  var k = ((n % len) + len) % len;
+  return arr.slice(k).concat(arr.slice(0, k));
+}`);
+  }
+
+  if (needed.has('sliding')) {
+    parts.push(`
+function sliding(arr, size, step) {
+  step = step || 1;
+  var out = [];
+  for (var i = 0; i + size <= arr.length; i += step) out.push(arr.slice(i, i + size));
+  return out;
+}`);
+  }
+
+  // ── Math ───────────────────────────────────────────────────────────────────
+
+  if (needed.has('clamp')) {
+    parts.push(`
 function clamp(val, min, max) {
   return Math.min(Math.max(val, min), max);
-}
+}`);
+  }
 
+  if (needed.has('sum')) {
+    parts.push(`
 function sum(arr) {
   return arr.reduce(function(a, b) { return a + b; }, 0);
-}
+}`);
+  }
 
+  if (needed.has('product')) {
+    parts.push(`
 function product(arr) {
   return arr.reduce(function(a, b) { return a * b; }, 1);
-}
+}`);
+  }
 
+  if (needed.has('min')) {
+    parts.push(`
 function min(arr) {
   if (arguments.length > 1) return Math.min.apply(null, arguments);
   return Math.min.apply(null, arr);
-}
+}`);
+  }
 
+  if (needed.has('max')) {
+    parts.push(`
 function max(arr) {
   if (arguments.length > 1) return Math.max.apply(null, arguments);
   return Math.max.apply(null, arr);
-}
+}`);
+  }
+
+  if (needed.has('abs')) {
+    parts.push(`
+function abs(n) { return Math.abs(n); }`);
+  }
+
+  if (needed.has('floor')) {
+    parts.push(`
+function floor(n) { return Math.floor(n); }`);
+  }
+
+  if (needed.has('ceil')) {
+    parts.push(`
+function ceil(n) { return Math.ceil(n); }`);
+  }
 
-function floor(n) { return Math.floor(n); }
+  if (needed.has('round')) {
+    parts.push(`
+function round(n, decimals) {
+  if (decimals == null) return Math.round(n);
+  var f = Math.pow(10, decimals);
+  return Math.round(n * f) / f;
+}`);
+  }
 
+  if (needed.has('mean')) {
+    parts.push(`
+function mean(arr) {
+  if (!arr.length) return 0;
+  return arr.reduce(function(a, b) { return a + b; }, 0) / arr.length;
+}`);
+  }
+
+  if (needed.has('median')) {
+    parts.push(`
+function median(arr) {
+  if (!arr.length) return 0;
+  var s = arr.slice().sort(function(a, b) { return a - b; });
+  var m = Math.floor(s.length / 2);
+  return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2;
+}`);
+  }
+
+  if (needed.has('stdDev')) {
+    parts.push(`
+function stdDev(arr) {
+  if (!arr.length) return 0;
+  var m = arr.reduce(function(a, b) { return a + b; }, 0) / arr.length;
+  var variance = arr.reduce(function(acc, v) { return acc + (v - m) * (v - m); }, 0) / arr.length;
+  return Math.sqrt(variance);
+}`);
+  }
+
+  if (needed.has('lerp')) {
+    parts.push(`
+function lerp(a, b, t) { return a + (b - a) * t; }`);
+  }
+
+  if (needed.has('randInt')) {
+    parts.push(`
 function randInt(min, max) {
   return Math.floor(Math.random() * (max - min + 1)) + min;
-}
+}`);
+  }
 
+  if (needed.has('sample')) {
+    parts.push(`
 function sample(arr) {
   return arr[Math.floor(Math.random() * arr.length)];
-}
+}`);
+  }
 
+  if (needed.has('shuffle')) {
+    parts.push(`
 function shuffle(arr) {
   var a = arr.slice();
   for (var i = a.length - 1; i > 0; i--) {
@@ -119,71 +490,155 @@ function shuffle(arr) {
     var tmp = a[i]; a[i] = a[j]; a[j] = tmp;
   }
   return a;
-}
+}`);
+  }
 
+  // ── Objects ────────────────────────────────────────────────────────────────
+
+  if (needed.has('pick')) {
+    parts.push(`
 function pick(obj, keys) {
   var out = {};
   keys.forEach(function(k) { if (Object.prototype.hasOwnProperty.call(obj, k)) out[k] = obj[k]; });
   return out;
-}
+}`);
+  }
 
+  if (needed.has('omit')) {
+    parts.push(`
 function omit(obj, keys) {
   var ks = new Set(keys);
   var out = {};
   Object.keys(obj).forEach(function(k) { if (!ks.has(k)) out[k] = obj[k]; });
   return out;
-}
+}`);
+  }
 
+  if (needed.has('mapValues')) {
+    parts.push(`
 function mapValues(obj, fn) {
   var out = {};
   Object.keys(obj).forEach(function(k) { out[k] = fn(obj[k], k); });
   return out;
-}
+}`);
+  }
 
+  if (needed.has('filterValues')) {
+    parts.push(`
 function filterValues(obj, fn) {
   var out = {};
   Object.keys(obj).forEach(function(k) { if (fn(obj[k], k)) out[k] = obj[k]; });
   return out;
-}
+}`);
+  }
 
+  if (needed.has('fromEntries')) {
+    parts.push(`
 function fromEntries(entries) {
   return Object.fromEntries(entries);
-}
+}`);
+  }
 
-function keys(obj) { return Object.keys(obj); }
+  if (needed.has('keys')) {
+    parts.push(`
+function keys(obj) { return Object.keys(obj); }`);
+  }
+
+  if (needed.has('values')) {
+    parts.push(`
+function values(obj) { return Object.values(obj); }`);
+  }
+
+  if (needed.has('entries')) {
+    parts.push(`
+function entries(obj) { return Object.entries(obj); }`);
+  }
+
+  if (needed.has('merge')) {
+    parts.push(`
+function merge() {
+  return Object.assign.apply(Object, [{}].concat(Array.from(arguments)));
+}`);
+  }
+
+  if (needed.has('invert')) {
+    parts.push(`
+function invert(obj) {
+  var out = {};
+  Object.keys(obj).forEach(function(k) { out[obj[k]] = k; });
+  return out;
+}`);
+  }
 
+  if (needed.has('defaults')) {
+    parts.push(`
+function defaults(obj) {
+  var sources = Array.from(arguments).slice(1);
+  var out = Object.assign({}, obj);
+  sources.forEach(function(s) {
+    Object.keys(s).forEach(function(k) { if (out[k] == null) out[k] = s[k]; });
+  });
+  return out;
+}`);
+  }
+
+  if (needed.has('deepEqual')) {
+    parts.push(`
 function deepEqual(a, b) {
   return JSON.stringify(a) === JSON.stringify(b);
-}
+}`);
+  }
 
+  if (needed.has('deepClone')) {
+    parts.push(`
 function deepClone(v) {
   return JSON.parse(JSON.stringify(v));
-}
+}`);
+  }
+
+  // ── Strings ────────────────────────────────────────────────────────────────
 
+  if (needed.has('capitalize')) {
+    parts.push(`
 function capitalize(s) {
   return s ? s[0].toUpperCase() + s.slice(1) : s;
-}
+}`);
+  }
 
+  if (needed.has('camelCase')) {
+    parts.push(`
 function camelCase(s) {
-  return s.replace(/[-_\s]+(.)/g, function(_, c) { return c.toUpperCase(); }).replace(/^./, function(c) { return c.toLowerCase(); });
-}
+  return s.replace(/[-_\\s]+(.)/g, function(_, c) { return c.toUpperCase(); }).replace(/^./, function(c) { return c.toLowerCase(); });
+}`);
+  }
 
+  if (needed.has('snakeCase')) {
+    parts.push(`
 function snakeCase(s) {
-  return s.replace(/([A-Z])/g, function(c) { return '_' + c.toLowerCase(); }).replace(/[-\s]+/g, '_').replace(/^_/, '');
-}
+  return s.replace(/([A-Z])/g, function(c) { return '_' + c.toLowerCase(); }).replace(/[-\\s]+/g, '_').replace(/^_/, '');
+}`);
+  }
 
+  if (needed.has('kebabCase')) {
+    parts.push(`
 function kebabCase(s) {
-  return s.replace(/([A-Z])/g, function(c) { return '-' + c.toLowerCase(); }).replace(/[_\s]+/g, '-').replace(/^-/, '');
-}
+  return s.replace(/([A-Z])/g, function(c) { return '-' + c.toLowerCase(); }).replace(/[_\\s]+/g, '-').replace(/^-/, '');
+}`);
+  }
 
+  if (needed.has('truncate')) {
+    parts.push(`
 function truncate(s, len, suffix) {
   suffix = suffix != null ? suffix : '...';
   if (s.length <= len) return s;
   var cut = len - suffix.length;
   if (cut <= 0) return suffix.slice(0, len);
   return s.slice(0, cut) + suffix;
-}
+}`);
+  }
 
+  if (needed.has('pad')) {
+    parts.push(`
 function pad(s, len, char) {
   char = char || ' ';
   s = String(s);
@@ -191,14 +646,123 @@ function pad(s, len, char) {
   if (total <= 0) return s;
   var half = Math.floor(total / 2);
   return char.repeat(half) + s + char.repeat(total - half);
-}
+}`);
+  }
 
-function repeat(s, n) { return String(s).repeat(n); }
+  if (needed.has('padStart')) {
+    parts.push(`
+function padStart(s, len, char) {
+  return String(s).padStart(len, char || ' ');
+}`);
+  }
+
+  if (needed.has('padEnd')) {
+    parts.push(`
+function padEnd(s, len, char) {
+  return String(s).padEnd(len, char || ' ');
+}`);
+  }
+
+  if (needed.has('trim')) {
+    parts.push(`
+function trim(s) { return String(s).trim(); }`);
+  }
+
+  if (needed.has('trimStart')) {
+    parts.push(`
+function trimStart(s) { return String(s).trimStart(); }`);
+  }
+
+  if (needed.has('trimEnd')) {
+    parts.push(`
+function trimEnd(s) { return String(s).trimEnd(); }`);
+  }
+
+  if (needed.has('words')) {
+    parts.push(`
+function words(s) { return String(s).trim().split(/\\s+/); }`);
+  }
+
+  if (needed.has('lines')) {
+    parts.push(`
+function lines(s) { return String(s).split(/\\r?\\n/); }`);
+  }
+
+  if (needed.has('startsWith')) {
+    parts.push(`
+function startsWith(s, prefix) { return String(s).startsWith(prefix); }`);
+  }
+
+  if (needed.has('endsWith')) {
+    parts.push(`
+function endsWith(s, suffix) { return String(s).endsWith(suffix); }`);
+  }
+
+  if (needed.has('repeat')) {
+    parts.push(`
+function repeat(s, n) { return String(s).repeat(n); }`);
+  }
+
+  if (needed.has('replaceAll')) {
+    parts.push(`
+function replaceAll(s, search, replacement) {
+  return String(s).split(search).join(replacement);
+}`);
+  }
+
+  if (needed.has('reverseStr')) {
+    parts.push(`
+function reverseStr(s) { return String(s).split('').reverse().join(''); }`);
+  }
 
+  // ── Type checks ────────────────────────────────────────────────────────────
+
+  if (needed.has('isNil')) {
+    parts.push(`
+function isNil(v) { return v == null; }`);
+  }
+
+  if (needed.has('isString')) {
+    parts.push(`
+function isString(v) { return typeof v === 'string'; }`);
+  }
+
+  if (needed.has('isNumber')) {
+    parts.push(`
+function isNumber(v) { return typeof v === 'number' && !isNaN(v); }`);
+  }
+
+  if (needed.has('isArray')) {
+    parts.push(`
+function isArray(v) { return Array.isArray(v); }`);
+  }
+
+  if (needed.has('isObject')) {
+    parts.push(`
+function isObject(v) { return v !== null && typeof v === 'object' && !Array.isArray(v); }`);
+  }
+
+  if (needed.has('isFunction')) {
+    parts.push(`
+function isFunction(v) { return typeof v === 'function'; }`);
+  }
+
+  if (needed.has('isBool')) {
+    parts.push(`
+function isBool(v) { return typeof v === 'boolean'; }`);
+  }
+
+  // ── Async ──────────────────────────────────────────────────────────────────
+
+  if (needed.has('sleep')) {
+    parts.push(`
 function sleep(ms) {
   return new Promise(function(resolve) { setTimeout(resolve, ms); });
-}
+}`);
+  }
 
+  if (needed.has('retry')) {
+    parts.push(`
 async function retry(fn, attempts, delay) {
   attempts = attempts || 3;
   delay    = delay    || 300;
@@ -208,8 +772,54 @@ async function retry(fn, attempts, delay) {
       await new Promise(function(r) { setTimeout(r, delay * Math.pow(2, i)); });
     }
   }
-}
+}`);
+  }
+
+  if (needed.has('timeout')) {
+    parts.push(`
+function timeout(fn, ms) {
+  return Promise.race([
+    typeof fn === 'function' ? fn() : fn,
+    new Promise(function(_, reject) {
+      setTimeout(function() { reject(new Error('Timeout after ' + ms + 'ms')); }, ms);
+    })
+  ]);
+}`);
+  }
+
+  if (needed.has('allSettled')) {
+    parts.push(`
+function allSettled(promises) {
+  return Promise.allSettled(promises);
+}`);
+  }
+
+  if (needed.has('debounce')) {
+    parts.push(`
+function debounce(fn, ms) {
+  var timer;
+  return function() {
+    clearTimeout(timer);
+    var args = arguments;
+    var ctx  = this;
+    timer = setTimeout(function() { fn.apply(ctx, args); }, ms);
+  };
+}`);
+  }
+
+  if (needed.has('throttle')) {
+    parts.push(`
+function throttle(fn, ms) {
+  var last = 0;
+  return function() {
+    var now = Date.now();
+    if (now - last >= ms) { last = now; return fn.apply(this, arguments); }
+  };
+}`);
+  }
 
+  if (needed.has('memoize')) {
+    parts.push(`
 function memoize(fn) {
   var cache = new Map();
   return function() {
@@ -219,195 +829,98 @@ function memoize(fn) {
     cache.set(key, result);
     return result;
   };
-}
+}`);
+  }
 
+  // ── Functional ─────────────────────────────────────────────────────────────
+
+  if (needed.has('pipe')) {
+    parts.push(`
 function pipe() {
   var fns = Array.from(arguments);
   return function(x) { return fns.reduce(function(v, f) { return f(v); }, x); };
-}
+}`);
+  }
 
+  if (needed.has('compose')) {
+    parts.push(`
 function compose() {
   var fns = Array.from(arguments);
   return function(x) { return fns.reduceRight(function(v, f) { return f(v); }, x); };
-}
+}`);
+  }
 
+  if (needed.has('partial')) {
+    parts.push(`
 function partial(fn) {
   var args = Array.from(arguments).slice(1);
   return function() { return fn.apply(this, args.concat(Array.from(arguments))); };
-}
+}`);
+  }
 
+  if (needed.has('curry')) {
+    parts.push(`
 function curry(fn) {
   return function curried() {
     var args = Array.from(arguments);
     if (args.length >= fn.length) return fn.apply(this, args);
     return function() { return curried.apply(this, args.concat(Array.from(arguments))); };
   };
-}
-// ── end stdlib ──
-
-// Generated by Flux Transpiler v3.2.0
-"use strict";
-
-const STDLIB_SYMBOLS = ["range", "zip", "enumerate", "clamp", "sum", "product", "flatten", "chunk", "unique", "groupBy", "sortBy", "pick", "omit", "deepEqual", "deepClone", "sleep", "retry", "memoize", "pipe", "compose", "partial", "curry", "capitalize", "camelCase", "snakeCase", "kebabCase", "truncate", "pad", "randInt", "sample", "shuffle", "mapValues", "filterValues", "fromEntries", "map", "filter", "reduce", "forEach", "find", "findIndex", "some", "every", "join", "sort", "flat", "flatMap", "includes"];
-module.exports.STDLIB_SYMBOLS = STDLIB_SYMBOLS;
-function makeSymbolRe(sym) {
-  return new RegExp((("\\b" + sym) + "\\s*\\("), "g");
-}
-function detectUsedSymbols(jsCode) {
-  return STDLIB_SYMBOLS.filter((sym) => makeSymbolRe(sym).test(jsCode));
-}
-module.exports.detectUsedSymbols = detectUsedSymbols;
-function buildStdlib(symbols) {
-  let needed = new Set(STDLIB_SYMBOLS);
-  if (symbols) {
-    needed = new Set(symbols.filter((s) => STDLIB_SYMBOLS.includes(s)));
-  }
-  if ((needed.size == 0)) {
-    return "";
-  }
-  const parts = ["// ── Flux stdlib ──"];
-  if (needed.has("map")) {
-    parts.push("function map(arr, fn) { return arr.map(fn); }");
-  }
-  if (needed.has("filter")) {
-    parts.push("function filter(arr, fn) { return arr.filter(fn); }");
-  }
-  if (needed.has("reduce")) {
-    parts.push("function reduce(arr, fn, init) { return arguments.length >= 3 ? arr.reduce(fn, init) : arr.reduce(fn); }");
-  }
-  if (needed.has("forEach")) {
-    parts.push("function forEach(arr, fn) { arr.forEach(fn); return arr; }");
-  }
-  if (needed.has("find")) {
-    parts.push("function find(arr, fn) { return arr.find(fn); }");
-  }
-  if (needed.has("findIndex")) {
-    parts.push("function findIndex(arr, fn) { return arr.findIndex(fn); }");
-  }
-  if (needed.has("some")) {
-    parts.push("function some(arr, fn) { return arr.some(fn); }");
-  }
-  if (needed.has("every")) {
-    parts.push("function every(arr, fn) { return arr.every(fn); }");
-  }
-  if (needed.has("join")) {
-    parts.push("function join(arr, sep) { return arr.join(sep != null ? sep : ','); }");
-  }
-  if (needed.has("sort")) {
-    parts.push("function sort(arr, fn) { return arr.slice().sort(fn); }");
-  }
-  if (needed.has("flat")) {
-    parts.push("function flat(arr, depth) { return arr.flat(depth != null ? depth : 1); }");
-  }
-  if (needed.has("flatMap")) {
-    parts.push("function flatMap(arr, fn) { return arr.flatMap(fn); }");
-  }
-  if (needed.has("includes")) {
-    parts.push("function includes(arr, val) { return arr.includes(val); }");
-  }
-  if (needed.has("range")) {
-    parts.push("function range(start, end, step) {\n  if (arguments.length === 1) { end = start; start = 0; }\n  step = step || (end >= start ? 1 : -1);\n  const out = [];\n  if (step > 0) { for (let i = start; i < end; i += step) out.push(i); }\n  else          { for (let i = start; i > end; i += step) out.push(i); }\n  return out;\n}");
-  }
-  if (needed.has("zip")) {
-    parts.push("function zip() {\n  const arrays = Array.from(arguments);\n  const len = Math.min.apply(null, arrays.map(function(a) { return a.length; }));\n  const out = [];\n  for (let i = 0; i < len; i++) out.push(arrays.map(function(a) { return a[i]; }));\n  return out;\n}");
-  }
-  if (needed.has("enumerate")) {
-    parts.push("function enumerate(arr, start) {\n  start = start || 0;\n  return arr.map(function(v, i) { return [i + start, v]; });\n}");
-  }
-  if (needed.has("flatten")) {
-    parts.push("function flatten(arr, depth) {\n  return depth == null ? arr.flat(Infinity) : arr.flat(depth);\n}");
-  }
-  if (needed.has("chunk")) {
-    parts.push("function chunk(arr, size) {\n  const out = [];\n  for (let i = 0; i < arr.length; i += size) out.push(arr.slice(i, i + size));\n  return out;\n}");
-  }
-  if (needed.has("unique")) {
-    parts.push("function unique(arr) {\n  return Array.from(new Set(arr));\n}");
-  }
-  if (needed.has("groupBy")) {
-    parts.push("function groupBy(arr, fn) {\n  return arr.reduce(function(acc, v) {\n    var k = typeof fn === 'function' ? fn(v) : v[fn];\n    (acc[k] = acc[k] || []).push(v);\n    return acc;\n  }, {});\n}");
-  }
-  if (needed.has("sortBy")) {
-    parts.push("function sortBy(arr, fn) {\n  return arr.slice().sort(function(a, b) {\n    var ka = typeof fn === 'function' ? fn(a) : a[fn];\n    var kb = typeof fn === 'function' ? fn(b) : b[fn];\n    return ka < kb ? -1 : ka > kb ? 1 : 0;\n  });\n}");
-  }
-  if (needed.has("clamp")) {
-    parts.push("function clamp(val, min, max) {\n  return Math.min(Math.max(val, min), max);\n}");
-  }
-  if (needed.has("sum")) {
-    parts.push("function sum(arr) {\n  return arr.reduce(function(a, b) { return a + b; }, 0);\n}");
+}`);
   }
-  if (needed.has("product")) {
-    parts.push("function product(arr) {\n  return arr.reduce(function(a, b) { return a * b; }, 1);\n}");
-  }
-  if (needed.has("randInt")) {
-    parts.push("function randInt(min, max) {\n  return Math.floor(Math.random() * (max - min + 1)) + min;\n}");
-  }
-  if (needed.has("sample")) {
-    parts.push("function sample(arr) {\n  return arr[Math.floor(Math.random() * arr.length)];\n}");
-  }
-  if (needed.has("shuffle")) {
-    parts.push("function shuffle(arr) {\n  var a = arr.slice();\n  for (var i = a.length - 1; i > 0; i--) {\n    var j = Math.floor(Math.random() * (i + 1));\n    var tmp = a[i]; a[i] = a[j]; a[j] = tmp;\n  }\n  return a;\n}");
-  }
-  if (needed.has("pick")) {
-    parts.push("function pick(obj, keys) {\n  var out = {};\n  keys.forEach(function(k) { if (Object.prototype.hasOwnProperty.call(obj, k)) out[k] = obj[k]; });\n  return out;\n}");
-  }
-  if (needed.has("omit")) {
-    parts.push("function omit(obj, keys) {\n  var ks = new Set(keys);\n  var out = {};\n  Object.keys(obj).forEach(function(k) { if (!ks.has(k)) out[k] = obj[k]; });\n  return out;\n}");
-  }
-  if (needed.has("mapValues")) {
-    parts.push("function mapValues(obj, fn) {\n  var out = {};\n  Object.keys(obj).forEach(function(k) { out[k] = fn(obj[k], k); });\n  return out;\n}");
-  }
-  if (needed.has("filterValues")) {
-    parts.push("function filterValues(obj, fn) {\n  var out = {};\n  Object.keys(obj).forEach(function(k) { if (fn(obj[k], k)) out[k] = obj[k]; });\n  return out;\n}");
-  }
-  if (needed.has("fromEntries")) {
-    parts.push("function fromEntries(entries) {\n  return Object.fromEntries(entries);\n}");
-  }
-  if (needed.has("deepEqual")) {
-    parts.push("function deepEqual(a, b) {\n  return JSON.stringify(a) === JSON.stringify(b);\n}");
-  }
-  if (needed.has("deepClone")) {
-    parts.push("function deepClone(v) {\n  return JSON.parse(JSON.stringify(v));\n}");
-  }
-  if (needed.has("sleep")) {
-    parts.push("function sleep(ms) {\n  return new Promise(function(resolve) { setTimeout(resolve, ms); });\n}");
-  }
-  if (needed.has("retry")) {
-    parts.push("async function retry(fn, attempts, delay) {\n  attempts = attempts || 3;\n  delay    = delay    || 300;\n  for (var i = 0; i < attempts; i++) {\n    try { return await fn(); } catch(e) {\n      if (i === attempts - 1) throw e;\n      await sleep(delay * Math.pow(2, i));\n    }\n  }\n}");
-  }
-  if (needed.has("memoize")) {
-    parts.push("function memoize(fn) {\n  var cache = new Map();\n  return function() {\n    var key = JSON.stringify(arguments);\n    if (cache.has(key)) return cache.get(key);\n    var result = fn.apply(this, arguments);\n    cache.set(key, result);\n    return result;\n  };\n}");
-  }
-  if (needed.has("pipe")) {
-    parts.push("function pipe() {\n  var fns = Array.from(arguments);\n  return function(x) { return fns.reduce(function(v, f) { return f(v); }, x); };\n}");
-  }
-  if (needed.has("compose")) {
-    parts.push("function compose() {\n  var fns = Array.from(arguments);\n  return function(x) { return fns.reduceRight(function(v, f) { return f(v); }, x); };\n}");
-  }
-  if (needed.has("partial")) {
-    parts.push("function partial(fn) {\n  var args = Array.from(arguments).slice(1);\n  return function() { return fn.apply(this, args.concat(Array.from(arguments))); };\n}");
-  }
-  if (needed.has("curry")) {
-    parts.push("function curry(fn) {\n  return function curried() {\n    var args = Array.from(arguments);\n    if (args.length >= fn.length) return fn.apply(this, args);\n    return function() { return curried.apply(this, args.concat(Array.from(arguments))); };\n  };\n}");
-  }
-  if (needed.has("capitalize")) {
-    parts.push("function capitalize(s) {\n  return s ? s[0].toUpperCase() + s.slice(1) : s;\n}");
-  }
-  if (needed.has("camelCase")) {
-    parts.push("function camelCase(s) {\n  return s.replace(/[-_\\s]+(.)/g, function(_, c) { return c.toUpperCase(); }).replace(/^./, function(c) { return c.toLowerCase(); });\n}");
+
+  if (needed.has('identity')) {
+    parts.push(`
+function identity(v) { return v; }`);
   }
-  if (needed.has("snakeCase")) {
-    parts.push("function snakeCase(s) {\n  return s.replace(/([A-Z])/g, function(c) { return '_' + c.toLowerCase(); }).replace(/[-\\s]+/g, '_').replace(/^_/, '');\n}");
+
+  if (needed.has('noop')) {
+    parts.push(`
+function noop() {}`);
   }
-  if (needed.has("kebabCase")) {
-    parts.push("function kebabCase(s) {\n  return s.replace(/([A-Z])/g, function(c) { return '-' + c.toLowerCase(); }).replace(/[_\\s]+/g, '-').replace(/^-/, '');\n}");
+
+  if (needed.has('once')) {
+    parts.push(`
+function once(fn) {
+  var called = false, result;
+  return function() {
+    if (!called) { called = true; result = fn.apply(this, arguments); }
+    return result;
+  };
+}`);
   }
-  if (needed.has("truncate")) {
-    parts.push("function truncate(s, len, suffix) {\n  suffix = suffix != null ? suffix : '...';\n  if (s.length <= len) return s;\n  var cut = len - suffix.length;\n  if (cut <= 0) return suffix.slice(0, len);\n  return s.slice(0, cut) + suffix;\n}");
+
+  if (needed.has('flip')) {
+    parts.push(`
+function flip(fn) {
+  return function() {
+    var args = Array.from(arguments);
+    return fn.apply(this, [args[1], args[0]].concat(args.slice(2)));
+  };
+}`);
   }
-  if (needed.has("pad")) {
-    parts.push("function pad(s, len, char) {\n  char = char || ' ';\n  s = String(s);\n  var total = len - s.length;\n  if (total <= 0) return s;\n  var half = Math.floor(total / 2);\n  return char.repeat(half) + s + char.repeat(total - half);\n}");
+
+  if (needed.has('complement')) {
+    parts.push(`
+function complement(fn) {
+  return function() { return !fn.apply(this, arguments); };
+}`);
   }
-  parts.push("// ── end stdlib ──\n");
-  return parts.join("\n");
+
+  parts.push('// ── end stdlib ──\n');
+  return parts.join('\n');
 }
-module.exports.buildStdlib = buildStdlib;
+
+/**
+ * Detect which stdlib symbols are referenced in a JS string.
+ * @param {string} jsCode
+ * @returns {string[]}
+ */
+function detectUsedSymbols(jsCode) {
+  return STDLIB_SYMBOLS.filter(sym => {
+    const re = new RegExp(`\\b${sym}\\s*\\(`, 'g');
+    return re.test(jsCode);
+  });
+}
+
+module.exports = { buildStdlib, detectUsedSymbols, STDLIB_SYMBOLS };