@xnoxs/flux-lang 3.2.1 → 3.3.0

package/src/mangler.js

@@ -1,280 +0,0 @@
-'use strict';
-
-// ── Safe names: never mangle these ────────────────────────────────────────────
-const SAFE = new Set([
-  // JS globals
-  'undefined','null','true','false','NaN','Infinity','arguments','this','super',
-  'console','document','window','navigator','location','history','screen',
-  'Math','JSON','Array','Object','String','Number','Boolean','Symbol','BigInt',
-  'Promise','Proxy','Reflect','WeakMap','WeakSet','WeakRef',
-  'Map','Set','Date','RegExp','Error','TypeError','RangeError','SyntaxError',
-  'URIError','EvalError','ReferenceError',
-  'parseInt','parseFloat','isNaN','isFinite',
-  'encodeURIComponent','decodeURIComponent','encodeURI','decodeURI',
-  'atob','btoa','structuredClone','queueMicrotask',
-  'setTimeout','setInterval','clearTimeout','clearInterval',
-  'requestAnimationFrame','cancelAnimationFrame',
-  'fetch','XMLHttpRequest','WebSocket','EventSource','FormData','Headers',
-  'Request','Response','URL','URLSearchParams','Blob','File','FileReader',
-  'alert','confirm','prompt',
-  'Event','CustomEvent','Node','Element','HTMLElement','DocumentFragment',
-  'MutationObserver','IntersectionObserver','ResizeObserver',
-  // Node.js
-  'process','Buffer','require','module','exports','__dirname','__filename',
-  'global','globalThis','setImmediate','clearImmediate','queueMicrotask',
-  'TextEncoder','TextDecoder','AbortController','AbortSignal','performance',
-  // Common imports used in Flux apps
-  'Http','Fs','Path','Url','Crypto','Os','Net','Stream','Events','Util',
-  'http','fs','path','url','crypto','os','net','stream','events','util',
-  // Flux runtime helpers (must never be mangled)
-  '_fluxH','_fluxCSS',
-  // Common variable names that map to globals
-  'print',
-]);
-
-// ── Name generator ─────────────────────────────────────────────────────────────
-function makeName(n) {
-  // Produces: _a, _b, ..., _z, _aa, _ab, ...
-  const chars = 'abcdefghijklmnopqrstuvwxyz';
-  let s = '';
-  n++;
-  while (n > 0) {
-    s = chars[(n - 1) % 26] + s;
-    n = Math.floor((n - 1) / 26);
-  }
-  return '_' + s;
-}
-
-// ── Mangler ────────────────────────────────────────────────────────────────────
-class Mangler {
-  constructor() {
-    this.map      = new Map(); // original name → mangled name
-    this.counter  = 0;
-    this.exported = new Set(); // names that are exported (keep readable)
-    this.imported = new Set(); // names brought in via import (keep as-is)
-  }
-
-  // ── Public API ───────────────────────────────────────────────
-  mangle(ast) {
-    this._collectExportedAndImported(ast);
-    this._collectDeclarations(ast);
-    return this._walkProgram(ast);
-  }
-
-  getMap() { return Object.fromEntries(this.map); }
-
-  // ── Step 1: collect exported + imported names ────────────────
-  _collectExportedAndImported(ast) {
-    for (const node of ast.body) {
-      if (node.type === 'ExportDecl') {
-        const d = node.decl;
-        if (d && d.name) this.exported.add(d.name);
-        if (d && d.type === 'DestructureDecl') {
-          (d.pattern || []).forEach(p => p && this.exported.add(p.alias || p.name || p.key));
-        }
-      }
-      if (node.type === 'ImportDecl') {
-        if (node.defaultName) this.imported.add(node.defaultName);
-        (node.names || []).forEach(n => this.imported.add(n));
-      }
-    }
-  }
-
-  // ── Step 2: collect all top-level user-defined names ─────────
-  _collectDeclarations(ast) {
-    this._walkStmts(ast.body, { toplevel: true, collect: true });
-  }
-
-  // ── Step 3: walk AST and rewrite names ───────────────────────
-  _walkProgram(ast) {
-    const body = this._walkStmts(ast.body, { toplevel: true });
-    return { ...ast, body };
-  }
-
-  _walkStmts(stmts, ctx = {}) {
-    return stmts.map(s => this._walkStmt(s, ctx));
-  }
-
-  _walkStmt(node, ctx = {}) {
-    if (!node) return node;
-    switch (node.type) {
-      case 'VarDecl':        return this._walkVarDecl(node, ctx);
-      case 'DestructureDecl':return this._walkDestructure(node, ctx);
-      case 'FnDecl':         return this._walkFnDecl(node, ctx);
-      case 'ClassDecl':      return this._walkClassDecl(node, ctx);
-      case 'IfStmt':         return { ...node,
-        cond:    this._walkExpr(node.cond),
-        then:    this._walkStmts(node.then),
-        elseifs: node.elseifs.map(e => ({ cond: this._walkExpr(e.cond), body: this._walkStmts(e.body) })),
-        else_:   node.else_ ? this._walkStmts(node.else_) : null };
-      case 'ForInStmt':      return { ...node,
-        var:  this._mangleLocal(node.var),
-        iter: this._walkExpr(node.iter),
-        body: this._walkStmts(node.body) };
-      case 'WhileStmt':      return { ...node, cond: this._walkExpr(node.cond), body: this._walkStmts(node.body) };
-      case 'DoWhileStmt':    return { ...node, cond: this._walkExpr(node.cond), body: this._walkStmts(node.body) };
-      case 'MatchStmt':      return { ...node,
-        subject: this._walkExpr(node.subject),
-        arms: node.arms.map(a => ({ ...a, body: this._walkStmts(a.body) })) };
-      case 'ReturnStmt':     return { ...node, value: this._walkExpr(node.value) };
-      case 'ThrowStmt':      return { ...node, value: this._walkExpr(node.value) };
-      case 'TryCatchStmt':   return { ...node,
-        tryBody:     this._walkStmts(node.tryBody),
-        catchParam:  node.catchParam ? this._mangleLocal(node.catchParam) : null,
-        catchBody:   node.catchBody  ? this._walkStmts(node.catchBody)   : null,
-        finallyBody: node.finallyBody ? this._walkStmts(node.finallyBody) : null };
-      case 'ExportDecl': {
-        const d = node.decl;
-        // Walk the inner decl but keep the name intact for the export statement
-        return { ...node, decl: this._walkStmt(d, ctx) };
-      }
-      case 'ImportDecl':     return node; // pass through unchanged
-      case 'TypeDecl':       return node; // ADT types — variant names must stay readable
-      case 'ExprStmt':       return { ...node, expr: this._walkExpr(node.expr) };
-      case 'BreakStmt':
-      case 'ContinueStmt':   return node;
-      default:               return node;
-    }
-  }
-
-  _walkVarDecl(node, ctx) {
-    // In collect mode, just register the name
-    if (ctx.collect) { this._registerName(node.name); return node; }
-    return {
-      ...node,
-      name: this._mangleName(node.name),
-      init: node.init ? this._walkExpr(node.init) : null,
-    };
-  }
-
-  _walkDestructure(node, ctx) {
-    if (ctx.collect) {
-      (node.pattern || []).forEach(p => {
-        if (p) this._registerName(p.alias || p.name || p.key);
-      });
-      return node;
-    }
-    if (node.patternType === 'array') {
-      // codegen uses p.name for array destructuring elements
-      const pattern = node.pattern.map(p => {
-        if (!p) return p;
-        if (p.rest) return { ...p, name: this._mangleName(p.name) };
-        return { ...p, name: this._mangleName(p.name), defaultVal: p.defaultVal ? this._walkExpr(p.defaultVal) : null };
-      });
-      return { ...node, pattern, init: this._walkExpr(node.init) };
-    } else {
-      // codegen uses p.alias (or p.key when alias === key) for object destructuring
-      const pattern = node.pattern.map(p => {
-        if (!p) return p;
-        if (p.rest) return { ...p, key: p.key, alias: this._mangleName(p.alias || p.key) };
-        return { ...p, alias: this._mangleName(p.alias || p.key), defaultVal: p.defaultVal ? this._walkExpr(p.defaultVal) : null };
-      });
-      return { ...node, pattern, init: this._walkExpr(node.init) };
-    }
-  }
-
-  _walkFnDecl(node, ctx) {
-    if (ctx.collect && node.name) { this._registerName(node.name); return node; }
-    const mangledName = node.name ? this._mangleName(node.name) : null;
-    const params = node.params.map(p => ({
-      ...p,
-      name: this._mangleParam(p.name),
-      defaultVal: p.defaultVal ? this._walkExpr(p.defaultVal) : null,
-    }));
-    const body = node.inline ? this._walkExpr(node.body) : this._walkStmts(node.body);
-    return { ...node, name: mangledName, params, body };
-  }
-
-  _walkClassDecl(node, ctx) {
-    if (ctx.collect && node.name) { this._registerName(node.name); return node; }
-    const mangledName = this._mangleName(node.name);
-    const methods = node.methods.map(m => {
-      // Method names that match well-known lifecycle / JS built-ins — keep them
-      const params = m.params.map(p => ({ ...p, name: this._mangleParam(p.name), defaultVal: p.defaultVal ? this._walkExpr(p.defaultVal) : null }));
-      const body   = m.inline ? this._walkExpr(m.body) : this._walkStmts(m.body);
-      return { ...m, params, body };
-    });
-    const superClass = node.superClass ? this._mangleName(node.superClass) : null;
-    return { ...node, name: mangledName, superClass, methods };
-  }
-
-  _walkExpr(node) {
-    if (!node) return node;
-    switch (node.type) {
-      case 'Identifier':    return { ...node, name: this._mangleName(node.name) };
-      case 'NumberLit':
-      case 'BoolLit':
-      case 'NullLit':
-      case 'StringLit':
-      case 'SelfExpr':      return node;
-      case 'TemplateLit':   return { ...node, parts: node.parts.map(p => {
-        if (p.type !== 'expr') return p;
-        // Replace every identifier in the raw expression string that has a mangled name.
-        // Uses word-boundary replacement so "name" inside "username" is not touched.
-        let expr = p.value;
-        for (const [orig, mangled] of this.map) {
-          expr = expr.replace(new RegExp(`(?<![\\w$])${orig}(?![\\w$])`, 'g'), mangled);
-        }
-        return { ...p, value: expr };
-      }) };
-      case 'BinaryExpr':    return { ...node, left: this._walkExpr(node.left), right: this._walkExpr(node.right) };
-      case 'UnaryExpr':     return { ...node, operand: this._walkExpr(node.operand) };
-      case 'UpdateExpr':    return { ...node, operand: this._walkExpr(node.operand) };
-      case 'AwaitExpr':     return { ...node, operand: this._walkExpr(node.operand) };
-      case 'TypeofExpr':    return { ...node, operand: this._walkExpr(node.operand) };
-      case 'TernaryExpr':   return { ...node, cond: this._walkExpr(node.cond), then: this._walkExpr(node.then), else_: this._walkExpr(node.else_) };
-      case 'AssignExpr':    return { ...node, target: this._walkExpr(node.target), value: this._walkExpr(node.value) };
-      case 'SpreadExpr':    return { ...node, expr: this._walkExpr(node.expr) };
-      case 'PipeExpr':      return { ...node, left: this._walkExpr(node.left), right: this._walkExpr(node.right) };
-      case 'MemberExpr':    return { ...node, obj: this._walkExpr(node.obj) /* prop is kept */ };
-      case 'OptMemberExpr': return { ...node, obj: this._walkExpr(node.obj) };
-      case 'IndexExpr':     return { ...node, obj: this._walkExpr(node.obj), idx: this._walkExpr(node.idx) };
-      case 'OptIndexExpr':  return { ...node, obj: this._walkExpr(node.obj), idx: this._walkExpr(node.idx) };
-      case 'CallExpr':      return { ...node, callee: this._walkExpr(node.callee), args: node.args.map(a => this._walkExpr(a)) };
-      case 'OptCallExpr':   return { ...node, callee: this._walkExpr(node.callee), args: node.args.map(a => this._walkExpr(a)) };
-      case 'NewExpr':       return { ...node, callee: this._mangleName(node.callee), args: node.args.map(a => this._walkExpr(a)) };
-      case 'LambdaExpr':    return { ...node,
-        params: node.params.map(p => ({ ...p, name: this._mangleParam(p.name) })),
-        body:   this._walkExpr(node.body) };
-      case 'FnDecl':        return this._walkFnDecl(node, {});
-      case 'ArrayExpr':     return { ...node, items: node.items.map(i => this._walkExpr(i)) };
-      case 'ObjectExpr':    return { ...node, pairs: node.pairs.map(p => ({
-        ...p, value: this._walkExpr(p.value)
-        // keys are kept — they are property names, not variable references
-      })) };
-      case 'RangeExpr':     return { ...node, start: this._walkExpr(node.start), end: this._walkExpr(node.end) };
-      default:              return node;
-    }
-  }
-
-  // ── Name helpers ─────────────────────────────────────────────
-  _registerName(name) {
-    if (!name || SAFE.has(name) || this.exported.has(name) || this.imported.has(name)) return;
-    if (!this.map.has(name)) this.map.set(name, makeName(this.counter++));
-  }
-
-  _mangleName(name) {
-    if (!name) return name;
-    if (SAFE.has(name) || this.exported.has(name) || this.imported.has(name)) return name;
-    // If we have a registered mangled name, use it
-    if (this.map.has(name)) return this.map.get(name);
-    // Not in map — likely a global or unregistered reference; return as-is
-    return name;
-  }
-
-  // For local params and loop variables — always mangle even if not pre-registered
-  _mangleLocal(name) {
-    if (!name || SAFE.has(name)) return name;
-    if (!this.map.has(name)) this.map.set(name, makeName(this.counter++));
-    return this.map.get(name);
-  }
-
-  // Same as _mangleLocal but for function params
-  _mangleParam(name) {
-    if (!name || SAFE.has(name)) return name;
-    if (!this.map.has(name)) this.map.set(name, makeName(this.counter++));
-    return this.map.get(name);
-  }
-}
-
-module.exports = { Mangler, SAFE, makeName };