@xnoxs/flux-lang 3.1.1 → 3.2.0

package/dist/flux.esm.js

@@ -1,5 +1,5 @@
 /*!
- * flux-lang v3.1.1
+ * flux-lang v3.2.0
  * Flux — A modern language that transpiles to JavaScript. Python-clean syntax, TypeScript-level safety, Rust-inspired pattern matching.
  * (c) 2026 Flux Lang Contributors
  * Released under the MIT License
@@ -984,18 +984,48 @@ var require_parser = __commonJS({
         }
         return stmts;
       }
+      // ── Decorator parsing: @name or @name(args) ───────────────────
+      parseDecorators() {
+        const decorators = [];
+        while (this.check(T.AT)) {
+          const loc = this.skip();
+          const name = this.eat(T.IDENT).value;
+          let args = [];
+          if (this.check(T.LPAREN)) {
+            this.pos++;
+            while (!this.check(T.RPAREN) && !this.check(T.EOF)) {
+              args.push(this.parseExpr());
+              if (!this.maybe(T.COMMA)) break;
+            }
+            this.eat(T.RPAREN);
+          }
+          decorators.push({ name, args, loc });
+          this.skipNewlines();
+        }
+        return decorators;
+      }
       parseOneStmt() {
+        const decorators = this.check(T.AT) ? this.parseDecorators() : [];
         const tok = this.peek();
         switch (tok.type) {
           case T.VAR:
           case T.VAL:
             return this.parseVarDecl();
-          case T.FN:
-            return this.parseFnDecl();
-          case T.ASYNC:
-            return this.parseAsyncFn();
-          case T.CLASS:
-            return this.parseClassDecl();
+          case T.FN: {
+            const n = this.parseFnDecl();
+            if (decorators.length) n.decorators = decorators;
+            return n;
+          }
+          case T.ASYNC: {
+            const n = this.parseAsyncFn();
+            if (decorators.length) n.decorators = decorators;
+            return n;
+          }
+          case T.CLASS: {
+            const n = this.parseClassDecl();
+            if (decorators.length) n.decorators = decorators;
+            return n;
+          }
           case T.IF:
             return this.parseIf();
           case T.FOR:
@@ -1576,6 +1606,26 @@ var require_parser = __commonJS({
             m.modifiers = mods;
             m.modifiers.add("static");
             methods.push(m);
+          } else if (this.check(T.VAR) || this.check(T.VAL)) {
+            const fieldKind = this.skip().type === T.VAR ? "var" : "val";
+            const fname = this.eat(T.IDENT).value;
+            let optional = false;
+            let ftype = null;
+            if (this.check(T.QUESTION)) {
+              this.pos++;
+              optional = true;
+            }
+            if (this.check(T.COLON)) {
+              this.pos++;
+              ftype = this.parseTypeAnn();
+            }
+            let init = null;
+            if (this.check(T.EQ)) {
+              this.pos++;
+              init = this.parseExpr();
+            }
+            this.skipNewlines();
+            fields.push({ name: fname, typeAnn: ftype, optional, modifiers: mods, init, fieldKind });
           } else if (this.check(T.IDENT)) {
             const fname = this.eat(T.IDENT).value;
             let optional = false;
@@ -1586,7 +1636,7 @@ var require_parser = __commonJS({
             this.eat(T.COLON);
             const ftype = this.parseTypeAnn();
             this.skipNewlines();
-            fields.push({ name: fname, typeAnn: ftype, optional, modifiers: mods });
+            fields.push({ name: fname, typeAnn: ftype, optional, modifiers: mods, init: null });
           } else {
             this.skip();
           }
@@ -2500,7 +2550,7 @@ function _fmt(v, s) {
         this.lines = [];
         this.level = 0;
         this._needsFmt = false;
-        this.emit("// Generated by Flux Transpiler v3.1.0");
+        this.emit("// Generated by Flux Transpiler v3.2.0");
         this.emit('"use strict";');
         this.blank();
         for (const node of ast.body) this.genStmt(node);
@@ -2604,23 +2654,44 @@ function _fmt(v, s) {
           this.out();
           this.emit("}");
         }
+        if (node.name && node.decorators && node.decorators.length > 0) {
+          for (let i = node.decorators.length - 1; i >= 0; i--) {
+            const dec = node.decorators[i];
+            const decArgs = dec.args.length > 0 ? `(${dec.args.map((a) => this.genExpr(a)).join(", ")})(${node.name})` : `(${node.name})`;
+            this.emit(`${node.name} = ${dec.name}${decArgs};`);
+          }
+        }
       }
       // ── class ──────────────────────────────────────────────────────
       genClass(node) {
         const ext = node.superClass ? ` extends ${node.superClass}` : "";
         this.emit(`class ${node.name}${ext} {`);
         this.in();
+        const isPrivate = (f) => f.modifiers && f.modifiers.has("private");
+        const fieldName = (f) => isPrivate(f) ? `#${f.name}` : f.name;
+        const fieldRef = (f) => isPrivate(f) ? `this.#${f.name}` : `this.${f.name}`;
+        const privateFields = node.fields.filter(isPrivate);
+        for (const f of privateFields) this.emit(`#${f.name};`);
+        if (privateFields.length > 0) this.blank();
         const allFields = getAllFields(node.name, this.clsReg);
-        if (allFields.length > 0) {
-          const params = allFields.map((f) => f.name).join(", ");
+        const paramFields = allFields.filter((f) => f.init == null && !isPrivate(f));
+        const initFields = allFields.filter((f) => f.init != null);
+        const ownInitFields = node.fields.filter((f) => f.init != null);
+        const needsCtor = paramFields.length > 0 || initFields.length > 0 || privateFields.length > 0;
+        if (needsCtor) {
+          const params = paramFields.map((f) => f.name).join(", ");
           this.emit(`constructor(${params}) {`);
           this.in();
           if (node.superClass && this.clsReg[node.superClass]) {
             const parentFields = getAllFields(node.superClass, this.clsReg);
-            if (parentFields.length > 0)
-              this.emit(`super(${parentFields.map((f) => f.name).join(", ")});`);
-          }
-          for (const f of node.fields) this.emit(`this.${f.name} = ${f.name};`);
+            const parentParams = parentFields.filter((f) => f.init == null);
+            if (parentParams.length > 0)
+              this.emit(`super(${parentParams.map((f) => f.name).join(", ")});`);
+          }
+          for (const f of node.fields.filter((f2) => f2.init == null && !isPrivate(f2)))
+            this.emit(`${fieldRef(f)} = ${f.name};`);
+          for (const f of ownInitFields)
+            this.emit(`${fieldRef(f)} = ${this.genExpr(f.init)};`);
           this.out();
           this.emit("}");
           this.blank();
@@ -2645,6 +2716,13 @@ function _fmt(v, s) {
         }
         this.out();
         this.emit("}");
+        if (node.decorators && node.decorators.length > 0) {
+          for (let i = node.decorators.length - 1; i >= 0; i--) {
+            const dec = node.decorators[i];
+            const decArgs = dec.args.length > 0 ? `(${dec.args.map((a) => this.genExpr(a)).join(", ")})(${node.name})` : `(${node.name})`;
+            this.emit(`${node.name} = ${dec.name}${decArgs};`);
+          }
+        }
         this.blank();
       }
       // ── if / else if / else ─────────────────────────────────────────
@@ -5874,41 +5952,16 @@ var require_stdlib = __commonJS({
   "src/stdlib.js"(exports, module) {
     "use strict";
     var STDLIB_SYMBOLS = [
+      // Sequences
       "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",
-      // Array pipe helpers — standalone wrappers around Array.prototype methods
+      // Array pipe helpers
       "map",
       "filter",
       "reduce",
@@ -5921,7 +5974,106 @@ var require_stdlib = __commonJS({
       "sort",
       "flat",
       "flatMap",
-      "includes"
+      "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"
     ];
     function buildStdlib(symbols) {
       const needed = symbols ? new Set(symbols.filter((s) => STDLIB_SYMBOLS.includes(s))) : new Set(STDLIB_SYMBOLS);
@@ -6045,6 +6197,148 @@ function sortBy(arr, fn) {
     var kb = typeof fn === 'function' ? fn(b) : b[fn];
     return ka < kb ? -1 : ka > kb ? 1 : 0;
   });
+}`);
+      }
+      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;
 }`);
       }
       if (needed.has("clamp")) {
@@ -6064,6 +6358,69 @@ function sum(arr) {
 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);
+}`);
+      }
+      if (needed.has("lerp")) {
+        parts.push(`
+function lerp(a, b, t) { return a + (b - a) * t; }`);
       }
       if (needed.has("randInt")) {
         parts.push(`
@@ -6125,6 +6482,43 @@ function filterValues(obj, fn) {
         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;
 }`);
       }
       if (needed.has("deepEqual")) {
@@ -6138,6 +6532,133 @@ function deepEqual(a, b) {
 function deepClone(v) {
   return JSON.parse(JSON.stringify(v));
 }`);
+      }
+      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(); });
+}`);
+      }
+      if (needed.has("snakeCase")) {
+        parts.push(`
+function snakeCase(s) {
+  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(/^-/, '');
+}`);
+      }
+      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);
+  var total = len - s.length;
+  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(''); }`);
+      }
+      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'; }`);
       }
       if (needed.has("sleep")) {
         parts.push(`
@@ -6153,9 +6674,48 @@ async function retry(fn, attempts, delay) {
   for (var i = 0; i < attempts; i++) {
     try { return await fn(); } catch(e) {
       if (i === attempts - 1) throw e;
-      await sleep(delay * Math.pow(2, i));
+      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")) {
@@ -6202,50 +6762,37 @@ function curry(fn) {
   };
 }`);
       }
-      if (needed.has("capitalize")) {
+      if (needed.has("identity")) {
         parts.push(`
-function capitalize(s) {
-  return s ? s[0].toUpperCase() + s.slice(1) : s;
-}`);
+function identity(v) { return v; }`);
       }
-      if (needed.has("camelCase")) {
+      if (needed.has("noop")) {
         parts.push(`
-function camelCase(s) {
-  return s.replace(/[-_\\s]+(.)/g, function(_, c) { return c.toUpperCase(); }).replace(/^./, function(c) { return c.toLowerCase(); });
-}`);
+function noop() {}`);
       }
-      if (needed.has("snakeCase")) {
-        parts.push(`
-function snakeCase(s) {
-  return s.replace(/([A-Z])/g, function(c) { return '_' + c.toLowerCase(); }).replace(/[-\\s]+/g, '_').replace(/^_/, '');
-}`);
-      }
-      if (needed.has("kebabCase")) {
+      if (needed.has("once")) {
         parts.push(`
-function kebabCase(s) {
-  return s.replace(/([A-Z])/g, function(c) { return '-' + c.toLowerCase(); }).replace(/[_\\s]+/g, '-').replace(/^-/, '');
+function once(fn) {
+  var called = false, result;
+  return function() {
+    if (!called) { called = true; result = fn.apply(this, arguments); }
+    return result;
+  };
 }`);
       }
-      if (needed.has("truncate")) {
+      if (needed.has("flip")) {
         parts.push(`
-function truncate(s, len, suffix) {
-  suffix = suffix != null ? suffix : '...';
-  if (s.length <= len) return s;
-  // FIX: guard against suffix longer than len to avoid negative slice index
-  var cut = len - suffix.length;
-  if (cut <= 0) return suffix.slice(0, len);
-  return s.slice(0, cut) + suffix;
+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")) {
+      if (needed.has("complement")) {
         parts.push(`
-function pad(s, len, char) {
-  char = char || ' ';
-  s = String(s);
-  var total = len - s.length;
-  if (total <= 0) return s;
-  var half = Math.floor(total / 2);
-  return char.repeat(half) + s + char.repeat(total - half);
+function complement(fn) {
+  return function() { return !fn.apply(this, arguments); };
 }`);
       }
       parts.push("// \u2500\u2500 end stdlib \u2500\u2500\n");