@xnoxs/flux-lang 4.0.7 → 4.0.9

package/src/stdlib.js

@@ -1,137 +1,33 @@
+/* compiled from src/self/stdlib.flux by Flux Lang */
 'use strict';
+// ── Flux stdlib ──
 
-// ── 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 map(arr, fn) { return arr.map(fn); }
 
-  if (needed.size === 0) return '';
+function filter(arr, fn) { return arr.filter(fn); }
 
-  const parts = ['// ── Flux stdlib ──'];
+function reduce(arr, fn, init) { return arguments.length >= 3 ? arr.reduce(fn, init) : arr.reduce(fn); }
 
-  // ── Array pipe helpers ─────────────────────────────────────────────────────
+function forEach(arr, fn) { arr.forEach(fn); return arr; }
 
-  if (needed.has('map')) {
-    parts.push(`
-function map(arr, fn) { return arr.map(fn); }`);
-  }
+function find(arr, fn) { return arr.find(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 findIndex(arr, fn) { return arr.findIndex(fn); }
 
-  if (needed.has('forEach')) {
-    parts.push(`
-function forEach(arr, fn) { arr.forEach(fn); return arr; }`);
-  }
+function some(arr, fn) { return arr.some(fn); }
 
-  if (needed.has('find')) {
-    parts.push(`
-function find(arr, fn) { return arr.find(fn); }`);
-  }
+function every(arr, fn) { return arr.every(fn); }
 
-  if (needed.has('findIndex')) {
-    parts.push(`
-function findIndex(arr, fn) { return arr.findIndex(fn); }`);
-  }
+function join(arr, sep) { return arr.join(sep != null ? sep : ','); }
 
-  if (needed.has('some')) {
-    parts.push(`
-function some(arr, fn) { return arr.some(fn); }`);
-  }
+function sort(arr, fn) { return arr.slice().sort(fn); }
 
-  if (needed.has('every')) {
-    parts.push(`
-function every(arr, fn) { return arr.every(fn); }`);
-  }
+function flat(arr, depth) { return arr.flat(depth != null ? depth : 1); }
 
-  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 flatMap(arr, fn) { return arr.flatMap(fn); }
 
-  // ── Sequences ──────────────────────────────────────────────────────────────
+function includes(arr, val) { return arr.includes(val); }
 
-  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);
@@ -139,350 +35,83 @@ 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); }`);
-  }
-
-  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);
-}`);
-  }
+function floor(n) { return Math.floor(n); }
 
-  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--) {
@@ -490,155 +119,71 @@ 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);
-}`);
-  }
-
-  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;
-}`);
-  }
+function keys(obj) { return Object.keys(obj); }
 
-  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);
@@ -646,123 +191,14 @@ 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);
-}`);
-  }
-
-  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 ──────────────────────────────────────────────────────────────────
+function repeat(s, n) { return String(s).repeat(n); }
 
-  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;
@@ -772,54 +208,8 @@ 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() {
@@ -829,98 +219,195 @@ 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 ──
 
-  if (needed.has('identity')) {
-    parts.push(`
-function identity(v) { return v; }`);
-  }
+// Generated by Flux Transpiler v3.2.0
+"use strict";
 
-  if (needed.has('noop')) {
-    parts.push(`
-function noop() {}`);
+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.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.size == 0)) {
+    return "";
   }
-
-  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)));
-  };
-}`);
+  const parts = ["// ── Flux stdlib ──"];
+  if (needed.has("map")) {
+    parts.push("function map(arr, fn) { return arr.map(fn); }");
   }
-
-  if (needed.has('complement')) {
-    parts.push(`
-function complement(fn) {
-  return function() { return !fn.apply(this, arguments); };
-}`);
+  if (needed.has("filter")) {
+    parts.push("function filter(arr, fn) { return arr.filter(fn); }");
   }
-
-  parts.push('// ── end stdlib ──\n');
-  return parts.join('\n');
-}
-
-/**
- * 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);
-  });
+  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("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("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("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("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}");
+  }
+  parts.push("// ── end stdlib ──\n");
+  return parts.join("\n");
 }
-
-module.exports = { buildStdlib, detectUsedSymbols, STDLIB_SYMBOLS };
+module.exports.buildStdlib = buildStdlib;