@xnoxs/flux-lang 3.1.1

package/src/self/sourcemap.flux

@@ -0,0 +1,66 @@
+// ============================================================
+//  Flux Self-Hosted Source Map Generator
+//  src/self/sourcemap.flux — written in Flux, compiled by stage-0
+//
+//  Source Map v3 — maps generated JS line/col back to original
+//  Flux source line/col.
+// ============================================================
+
+val BASE64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
+
+export fn encodeVLQ(value):
+  var vlq = value < 0 ? ((-value) << 1) | 1 : (value << 1)
+  var result = ''
+  var running = true
+  while running:
+    var digit = vlq & 0x1F
+    vlq = vlq >> 5
+    if vlq > 0: digit = digit | 0x20
+    result = result + BASE64[digit]
+    if vlq <= 0: running = false
+  return result
+
+export class SourceMapBuilder:
+  sourceFile:    string
+  sourceContent: string
+  mappings:      any[]
+
+  fn addMapping(genLine, genCol, srcLine, srcCol):
+    while self.mappings.length <= genLine: self.mappings.push([])
+    self.mappings[genLine].push({ genCol, srcLine, srcCol })
+
+  fn encodeMappings():
+    var prevSrcLine = 0
+    var prevSrcCol  = 0
+    val lines2 = []
+    for lineSegs in self.mappings:
+      var prevGenCol = 0
+      val segs = []
+      for seg in lineSegs:
+        val encoded = [
+          encodeVLQ(seg.genCol  - prevGenCol),
+          encodeVLQ(0),
+          encodeVLQ(seg.srcLine - prevSrcLine),
+          encodeVLQ(seg.srcCol  - prevSrcCol),
+        ].join('')
+        prevGenCol  = seg.genCol
+        prevSrcLine = seg.srcLine
+        prevSrcCol  = seg.srcCol
+        segs.push(encoded)
+      lines2.push(segs.join(','))
+    return lines2.join(';')
+
+  fn toJSON(outputFile):
+    val file = outputFile ?? ''
+    return {
+      version:        3,
+      file:           file,
+      sourceRoot:     '',
+      sources:        [self.sourceFile],
+      sourcesContent: [self.sourceContent],
+      names:          [],
+      mappings:       self.encodeMappings(),
+    }
+
+  fn toString(outputFile):
+    return JSON.stringify(self.toJSON(outputFile))

package/src/self/sourcemap.js

@@ -0,0 +1,72 @@
+// ── Flux stdlib ──
+
+function join(arr, sep) { return arr.join(sep != null ? sep : ','); }
+// ── end stdlib ──
+
+// Generated by Flux Transpiler v3.1.0
+"use strict";
+
+const BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function encodeVLQ(value) {
+  let vlq = ((value < 0) ? ((-value << 1) | 1) : (value << 1));
+  let result = "";
+  let running = true;
+  while (running) {
+    let digit = (vlq & 31);
+    vlq = (vlq >> 5);
+    if ((vlq > 0)) {
+      digit = (digit | 32);
+    }
+    result = (result + BASE64[digit]);
+    if ((vlq <= 0)) {
+      running = false;
+    }
+  }
+  return result;
+}
+module.exports.encodeVLQ = encodeVLQ;
+class SourceMapBuilder {
+  constructor(sourceFile, sourceContent, mappings) {
+    this.sourceFile = sourceFile;
+    this.sourceContent = sourceContent;
+    this.mappings = mappings;
+  }
+
+  addMapping(genLine, genCol, srcLine, srcCol) {
+    while ((this.mappings.length <= genLine)) {
+      this.mappings.push([]);
+    }
+    this.mappings[genLine].push({ genCol, srcLine, srcCol });
+  }
+
+  encodeMappings() {
+    let prevSrcLine = 0;
+    let prevSrcCol = 0;
+    const lines2 = [];
+    for (const lineSegs of this.mappings) {
+      let prevGenCol = 0;
+      const segs = [];
+      for (const seg of lineSegs) {
+        const encoded = [encodeVLQ((seg.genCol - prevGenCol)), encodeVLQ(0), encodeVLQ((seg.srcLine - prevSrcLine)), encodeVLQ((seg.srcCol - prevSrcCol))].join("");
+        prevGenCol = seg.genCol;
+        prevSrcLine = seg.srcLine;
+        prevSrcCol = seg.srcCol;
+        segs.push(encoded);
+      }
+      lines2.push(segs.join(","));
+    }
+    return lines2.join(";");
+  }
+
+  toJSON(outputFile) {
+    const file = (outputFile ?? "");
+    return { version: 3, file, sourceRoot: "", sources: [this.sourceFile], sourcesContent: [this.sourceContent], names: [], mappings: this.encodeMappings() };
+  }
+
+  toString(outputFile) {
+    return JSON.stringify(this.toJSON(outputFile));
+  }
+
+}
+
+module.exports.SourceMapBuilder = SourceMapBuilder;

package/src/self/stdlib.flux

@@ -0,0 +1,356 @@
+// ============================================================
+//  Flux Self-Hosted Standard Library
+//  src/self/stdlib.flux — written in Flux, compiled by stage-0
+//
+//  Runtime helpers injected into compiled Flux programs.
+// ============================================================
+
+export val 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',
+]
+
+fn makeSymbolRe(sym):
+  return new RegExp("\\b" + sym + "\\s*\\(", 'g')
+
+export fn detectUsedSymbols(jsCode):
+  return STDLIB_SYMBOLS.filter(sym -> makeSymbolRe(sym).test(jsCode))
+
+export fn buildStdlib(symbols):
+  var needed = new Set(STDLIB_SYMBOLS)
+  if symbols: needed = new Set(symbols.filter(s -> STDLIB_SYMBOLS.includes(s)))
+
+  if needed.size == 0: return ''
+
+  val 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) {
+  if (arguments.length === 1) { end = start; start = 0; }
+  step = step || (end >= start ? 1 : -1);
+  const out = [];
+  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;
+  });
+}`)
+
+  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('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--) {
+    var j = Math.floor(Math.random() * (i + 1));
+    var tmp = a[i]; a[i] = a[j]; a[j] = tmp;
+  }
+  return a;
+}`)
+
+  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('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));
+}`)
+
+  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;
+  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));
+    }
+  }
+}`)
+
+  if needed.has('memoize'):
+    parts.push(`
+function memoize(fn) {
+  var cache = new Map();
+  return function() {
+    var key = JSON.stringify(arguments);
+    if (cache.has(key)) return cache.get(key);
+    var result = fn.apply(this, arguments);
+    cache.set(key, result);
+    return result;
+  };
+}`)
+
+  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))); };
+  };
+}`)
+
+  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);
+}`)
+
+  parts.push('// ── end stdlib ──\n')
+  return parts.join('\n')