@xnoxs/flux-lang 3.1.1

package/src/self/mangler.flux

@@ -0,0 +1,253 @@
+// ============================================================
+//  Flux Self-Hosted Mangler
+//  src/self/mangler.flux — written in Flux, compiled by stage-0
+//
+//  Renames local identifiers to short names (_a, _b, ...) to
+//  reduce output size. Exported/imported names are preserved.
+// ============================================================
+
+export val SAFE = new Set([
+  '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',
+  'process','Buffer','require','module','exports','__dirname','__filename',
+  'global','globalThis','setImmediate','clearImmediate',
+  'TextEncoder','TextDecoder','AbortController','AbortSignal','performance',
+  'Http','Fs','Path','Url','Crypto','Os','Net','Stream','Events','Util',
+  'http','fs','path','url','crypto','os','net','stream','events','util',
+  '_fluxH','_fluxCSS',
+  'print',
+])
+
+export fn makeName(n):
+  val chars = 'abcdefghijklmnopqrstuvwxyz'
+  var s = ''
+  var num = n + 1
+  while num > 0:
+    s = chars[(num - 1) % 26] + s
+    num = Math.floor((num - 1) / 26)
+  return '_' + s
+
+export class Mangler:
+  map:      any
+  counter:  int
+  exported: any
+  imported: any
+
+  fn mangle(ast):
+    self.collectExportedAndImported(ast)
+    self.collectDeclarations(ast)
+    return self.walkProgram(ast)
+
+  fn getMap():
+    return Object.fromEntries(self.map)
+
+  fn collectExportedAndImported(ast):
+    for node in ast.body:
+      if node.type == 'ExportDecl':
+        val d = node.decl
+        if d and d.name: self.exported.add(d.name)
+        if d and d.type == 'DestructureDecl':
+          for pat in (d.pattern ?? []):
+            if pat: self.exported.add(pat.alias ?? pat.name ?? pat.key)
+      if node.type == 'ImportDecl':
+        if node.defaultName: self.imported.add(node.defaultName)
+        (node.names ?? []).forEach(n -> self.imported.add(n))
+
+  fn collectDeclarations(ast):
+    self.walkStmts(ast.body, { toplevel: true, collect: true })
+
+  fn walkProgram(ast):
+    val body = self.walkStmts(ast.body, { toplevel: true })
+    return { ...ast, body }
+
+  fn walkStmts(stmts, ctx):
+    return stmts.map(s -> self.walkStmt(s, ctx ?? {}))
+
+  fn walkStmt(node, ctx):
+    if not node: return node
+    val c = ctx ?? {}
+    if node.type == 'VarDecl':        return self.walkVarDecl(node, c)
+    if node.type == 'DestructureDecl': return self.walkDestructure(node, c)
+    if node.type == 'FnDecl':         return self.walkFnDecl(node, c)
+    if node.type == 'ClassDecl':      return self.walkClassDecl(node, c)
+    if node.type == 'IfStmt':
+      return { ...node,
+        cond:    self.walkExpr(node.cond),
+        then:    self.walkStmts(node.then),
+        elseifs: node.elseifs.map(e -> ({ cond: self.walkExpr(e.cond), body: self.walkStmts(e.body) })),
+        else_:   node.else_ ? self.walkStmts(node.else_) : null }
+    if node.type == 'ForInStmt':
+      return { ...node,
+        var:  self.mangleLocal(node.var),
+        iter: self.walkExpr(node.iter),
+        body: self.walkStmts(node.body) }
+    if node.type == 'WhileStmt':
+      return { ...node, cond: self.walkExpr(node.cond), body: self.walkStmts(node.body) }
+    if node.type == 'DoWhileStmt':
+      return { ...node, cond: self.walkExpr(node.cond), body: self.walkStmts(node.body) }
+    if node.type == 'MatchStmt':
+      return { ...node,
+        subject: self.walkExpr(node.subject),
+        arms: node.arms.map(a -> ({ ...a, body: self.walkStmts(a.body) })) }
+    if node.type == 'ReturnStmt':
+      return { ...node, value: self.walkExpr(node.value) }
+    if node.type == 'ThrowStmt':
+      return { ...node, value: self.walkExpr(node.value) }
+    if node.type == 'TryCatchStmt':
+      return { ...node,
+        tryBody:     self.walkStmts(node.tryBody),
+        catchParam:  node.catchParam ? self.mangleLocal(node.catchParam) : null,
+        catchBody:   node.catchBody  ? self.walkStmts(node.catchBody)   : null,
+        finallyBody: node.finallyBody ? self.walkStmts(node.finallyBody) : null }
+    if node.type == 'ExportDecl':
+      return { ...node, decl: self.walkStmt(node.decl, c) }
+    if node.type == 'ImportDecl': return node
+    if node.type == 'TypeDecl':   return node
+    if node.type == 'ExprStmt':
+      return { ...node, expr: self.walkExpr(node.expr) }
+    return node
+
+  fn walkVarDecl(node, ctx):
+    if ctx.collect: self.registerName(node.name); return node
+    return { ...node,
+      name: self.mangleName(node.name),
+      init: node.init ? self.walkExpr(node.init) : null }
+
+  fn mangleArrPatItem(p):
+    if not p: return p
+    if p.rest: return { ...p, name: self.mangleName(p.name) }
+    return { ...p, name: self.mangleName(p.name), defaultVal: p.defaultVal ? self.walkExpr(p.defaultVal) : null }
+
+  fn mangleObjPatItem(p):
+    if not p: return p
+    if p.rest: return { ...p, key: p.key, alias: self.mangleName(p.alias ?? p.key) }
+    return { ...p, alias: self.mangleName(p.alias ?? p.key), defaultVal: p.defaultVal ? self.walkExpr(p.defaultVal) : null }
+
+  fn walkDestructure(node, ctx):
+    if ctx.collect:
+      for dp in (node.pattern ?? []):
+        if dp: self.registerName(dp.alias ?? dp.name ?? dp.key)
+      return node
+    if node.patternType == 'array':
+      val pattern = node.pattern.map(p -> self.mangleArrPatItem(p))
+      return { ...node, pattern, init: self.walkExpr(node.init) }
+    else:
+      val pattern2 = node.pattern.map(p -> self.mangleObjPatItem(p))
+      return { ...node, pattern: pattern2, init: self.walkExpr(node.init) }
+
+  fn walkFnDecl(node, ctx):
+    if ctx.collect and node.name: self.registerName(node.name); return node
+    val mangledName = node.name ? self.mangleName(node.name) : null
+    val params = node.params.map(p -> ({
+      ...p,
+      name: self.mangleParam(p.name),
+      defaultVal: p.defaultVal ? self.walkExpr(p.defaultVal) : null,
+    }))
+    val body = node.inline ? self.walkExpr(node.body) : self.walkStmts(node.body)
+    return { ...node, name: mangledName, params, body }
+
+  fn mangleClassMethod(m):
+    val params = m.params.map(p -> ({
+      ...p,
+      name: self.mangleParam(p.name),
+      defaultVal: p.defaultVal ? self.walkExpr(p.defaultVal) : null,
+    }))
+    val body = m.inline ? self.walkExpr(m.body) : self.walkStmts(m.body)
+    return { ...m, params, body }
+
+  fn walkClassDecl(node, ctx):
+    if ctx.collect and node.name: self.registerName(node.name); return node
+    val mangledName = self.mangleName(node.name)
+    val methods = node.methods.map(m -> self.mangleClassMethod(m))
+    val superClass = node.superClass ? self.mangleName(node.superClass) : null
+    return { ...node, name: mangledName, superClass, methods }
+
+  fn mangleTemplatePart(p):
+    if p.type != 'expr': return p
+    var expr = p.value
+    for entry in self.map:
+      val orig    = entry[0]
+      val mangled = entry[1]
+      expr = expr.replace(new RegExp('(?<![\\w$])' + orig + '(?![\\w$])', 'g'), mangled)
+    return { ...p, value: expr }
+
+  fn walkExpr(node):
+    if not node: return node
+    if node.type == 'Identifier':
+      return { ...node, name: self.mangleName(node.name) }
+    if (node.type == 'NumberLit' or node.type == 'BoolLit' or node.type == 'NullLit' or
+        node.type == 'StringLit' or node.type == 'SelfExpr'):
+      return node
+    if node.type == 'TemplateLit':
+      return { ...node, parts: node.parts.map(p -> self.mangleTemplatePart(p)) }
+    if node.type == 'BinaryExpr':
+      return { ...node, left: self.walkExpr(node.left), right: self.walkExpr(node.right) }
+    if (node.type == 'UnaryExpr' or node.type == 'UpdateExpr' or
+        node.type == 'AwaitExpr' or node.type == 'TypeofExpr'):
+      return { ...node, operand: self.walkExpr(node.operand) }
+    if node.type == 'TernaryExpr':
+      return { ...node, cond: self.walkExpr(node.cond), then: self.walkExpr(node.then), else_: self.walkExpr(node.else_) }
+    if node.type == 'AssignExpr':
+      return { ...node, target: self.walkExpr(node.target), value: self.walkExpr(node.value) }
+    if node.type == 'SpreadExpr':
+      return { ...node, expr: self.walkExpr(node.expr) }
+    if node.type == 'PipeExpr':
+      return { ...node, left: self.walkExpr(node.left), right: self.walkExpr(node.right) }
+    if node.type == 'MemberExpr' or node.type == 'OptMemberExpr':
+      return { ...node, obj: self.walkExpr(node.obj) }
+    if node.type == 'IndexExpr' or node.type == 'OptIndexExpr':
+      return { ...node, obj: self.walkExpr(node.obj), idx: self.walkExpr(node.idx) }
+    if node.type == 'CallExpr' or node.type == 'OptCallExpr':
+      return { ...node, callee: self.walkExpr(node.callee), args: node.args.map(a -> self.walkExpr(a)) }
+    if node.type == 'NewExpr':
+      return { ...node, callee: self.mangleName(node.callee), args: node.args.map(a -> self.walkExpr(a)) }
+    if node.type == 'LambdaExpr':
+      return { ...node,
+        params: node.params.map(p -> ({ ...p, name: self.mangleParam(p.name) })),
+        body:   self.walkExpr(node.body) }
+    if node.type == 'FnDecl':
+      return self.walkFnDecl(node, {})
+    if node.type == 'ArrayExpr':
+      return { ...node, items: node.items.map(i -> self.walkExpr(i)) }
+    if node.type == 'ObjectExpr':
+      return { ...node, pairs: node.pairs.map(p -> ({ ...p, value: self.walkExpr(p.value) })) }
+    if node.type == 'RangeExpr':
+      return { ...node, start: self.walkExpr(node.start), end: self.walkExpr(node.end) }
+    return node
+
+  fn registerName(name):
+    if not name or SAFE.has(name) or self.exported.has(name) or self.imported.has(name): return
+    if not self.map.has(name): self.map.set(name, makeName(self.counter)); self.counter = self.counter + 1
+
+  fn mangleName(name):
+    if not name: return name
+    if SAFE.has(name) or self.exported.has(name) or self.imported.has(name): return name
+    if self.map.has(name): return self.map.get(name)
+    return name
+
+  fn mangleLocal(name):
+    if not name or SAFE.has(name): return name
+    if not self.map.has(name): self.map.set(name, makeName(self.counter)); self.counter = self.counter + 1
+    return self.map.get(name)
+
+  fn mangleParam(name):
+    if not name or SAFE.has(name): return name
+    if not self.map.has(name): self.map.set(name, makeName(self.counter)); self.counter = self.counter + 1
+    return self.map.get(name)
+
+export fn makeMangler():
+  return new Mangler(new Map(), 0, new Set(), new Set())

package/src/self/mangler.js

@@ -0,0 +1,348 @@
+// Flux JSX Runtime
+"use strict";
+
+function _fluxH(tag,props,...children){
+  if(tag===""){const f=document.createDocumentFragment();children.flat(Infinity).forEach(c=>{if(c==null)return;f.appendChild(c instanceof Node?c:document.createTextNode(String(c)));});return f;}
+  const el=document.createElement(tag);
+  if(props){for(const[k,v]of Object.entries(props)){if(k==="class"||k==="className"){el.className=v;}else if(k==="style"&&typeof v==="object"){Object.assign(el.style,v);}else if(k.startsWith("on")&&typeof v==="function"){el.addEventListener(k.slice(2).toLowerCase(),v);}else if(typeof v==="boolean"){if(v)el.setAttribute(k,"");}else{el.setAttribute(k,String(v));}}}
+  children.flat(Infinity).forEach(c=>{if(c==null)return;el.appendChild(c instanceof Node?c:document.createTextNode(String(c)));});
+  return el;
+}
+function _fluxCSS(css){const s=document.createElement("style");s.textContent=css;document.head.appendChild(s);return css;}
+// ── Flux stdlib ──
+
+function map(arr, fn) { return arr.map(fn); }
+
+function forEach(arr, fn) { arr.forEach(fn); return arr; }
+
+function fromEntries(entries) {
+  return Object.fromEntries(entries);
+}
+// ── end stdlib ──
+
+
+const SAFE = new Set(["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", "process", "Buffer", "require", "module", "exports", "__dirname", "__filename", "global", "globalThis", "setImmediate", "clearImmediate", "TextEncoder", "TextDecoder", "AbortController", "AbortSignal", "performance", "Http", "Fs", "Path", "Url", "Crypto", "Os", "Net", "Stream", "Events", "Util", "http", "fs", "path", "url", "crypto", "os", "net", "stream", "events", "util", "_fluxH", "_fluxCSS", "print"]);
+module.exports.SAFE = SAFE;
+function makeName(n) {
+  const chars = "abcdefghijklmnopqrstuvwxyz";
+  let s = "";
+  let num = (n + 1);
+  while ((num > 0)) {
+    s = (chars[((num - 1) % 26)] + s);
+    num = Math.floor(((num - 1) / 26));
+  }
+  return ("_" + s);
+}
+module.exports.makeName = makeName;
+class Mangler {
+  constructor(map, counter, exported, imported) {
+    this.map = map;
+    this.counter = counter;
+    this.exported = exported;
+    this.imported = imported;
+  }
+
+  mangle(ast) {
+    this.collectExportedAndImported(ast);
+    this.collectDeclarations(ast);
+    return this.walkProgram(ast);
+  }
+
+  getMap() {
+    return Object.fromEntries(this.map);
+  }
+
+  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"))) {
+          for (const pat of (d.pattern ?? [])) {
+            if (pat) {
+              this.exported.add(((pat.alias ?? pat.name) ?? pat.key));
+            }
+          }
+        }
+      }
+      if ((node.type == "ImportDecl")) {
+        if (node.defaultName) {
+          this.imported.add(node.defaultName);
+        }
+        (node.names ?? []).forEach((n) => this.imported.add(n));
+      }
+    }
+  }
+
+  collectDeclarations(ast) {
+    this.walkStmts(ast.body, { toplevel: true, collect: true });
+  }
+
+  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;
+    }
+    const c = (ctx ?? {  });
+    if ((node.type == "VarDecl")) {
+      return this.walkVarDecl(node, c);
+    }
+    if ((node.type == "DestructureDecl")) {
+      return this.walkDestructure(node, c);
+    }
+    if ((node.type == "FnDecl")) {
+      return this.walkFnDecl(node, c);
+    }
+    if ((node.type == "ClassDecl")) {
+      return this.walkClassDecl(node, c);
+    }
+    if ((node.type == "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) };
+    }
+    if ((node.type == "ForInStmt")) {
+      return { ...node, var: this.mangleLocal(node.var), iter: this.walkExpr(node.iter), body: this.walkStmts(node.body) };
+    }
+    if ((node.type == "WhileStmt")) {
+      return { ...node, cond: this.walkExpr(node.cond), body: this.walkStmts(node.body) };
+    }
+    if ((node.type == "DoWhileStmt")) {
+      return { ...node, cond: this.walkExpr(node.cond), body: this.walkStmts(node.body) };
+    }
+    if ((node.type == "MatchStmt")) {
+      return { ...node, subject: this.walkExpr(node.subject), arms: node.arms.map((a) => { ...a, body: this.walkStmts(a.body) }) };
+    }
+    if ((node.type == "ReturnStmt")) {
+      return { ...node, value: this.walkExpr(node.value) };
+    }
+    if ((node.type == "ThrowStmt")) {
+      return { ...node, value: this.walkExpr(node.value) };
+    }
+    if ((node.type == "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) };
+    }
+    if ((node.type == "ExportDecl")) {
+      return { ...node, decl: this.walkStmt(node.decl, c) };
+    }
+    if ((node.type == "ImportDecl")) {
+      return node;
+    }
+    if ((node.type == "TypeDecl")) {
+      return node;
+    }
+    if ((node.type == "ExprStmt")) {
+      return { ...node, expr: this.walkExpr(node.expr) };
+    }
+    return node;
+  }
+
+  walkVarDecl(node, ctx) {
+    if (ctx.collect) {
+      this.registerName(node.name);
+    }
+    return node;
+    return { ...node, name: this.mangleName(node.name), init: (node.init ? this.walkExpr(node.init) : null) };
+  }
+
+  mangleArrPatItem(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) };
+  }
+
+  mangleObjPatItem(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) };
+  }
+
+  walkDestructure(node, ctx) {
+    if (ctx.collect) {
+      for (const dp of (node.pattern ?? [])) {
+        if (dp) {
+          this.registerName(((dp.alias ?? dp.name) ?? dp.key));
+        }
+      }
+      return node;
+    }
+    if ((node.patternType == "array")) {
+      const pattern = node.pattern.map((p) => this.mangleArrPatItem(p));
+      return { ...node, pattern, init: this.walkExpr(node.init) };
+    }
+    else {
+      const pattern2 = node.pattern.map((p) => this.mangleObjPatItem(p));
+      return { ...node, pattern: pattern2, 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 };
+  }
+
+  mangleClassMethod(m) {
+    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 };
+  }
+
+  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) => this.mangleClassMethod(m));
+    const superClass = (node.superClass ? this.mangleName(node.superClass) : null);
+    return { ...node, name: mangledName, superClass, methods };
+  }
+
+  mangleTemplatePart(p) {
+    if ((p.type != "expr")) {
+      return p;
+    }
+    let expr = p.value;
+    for (const entry of this.map) {
+      const orig = entry[0];
+      const mangled = entry[1];
+      expr = expr.replace(new RegExp((("(?<![\\w$])" + orig) + "(?![\\w$])"), "g"), mangled);
+    }
+    return { ...p, value: expr };
+  }
+
+  walkExpr(node) {
+    if (!node) {
+      return node;
+    }
+    if ((node.type == "Identifier")) {
+      return { ...node, name: this.mangleName(node.name) };
+    }
+    if ((((((node.type == "NumberLit") || (node.type == "BoolLit")) || (node.type == "NullLit")) || (node.type == "StringLit")) || (node.type == "SelfExpr"))) {
+      return node;
+    }
+    if ((node.type == "TemplateLit")) {
+      return { ...node, parts: node.parts.map((p) => this.mangleTemplatePart(p)) };
+    }
+    if ((node.type == "BinaryExpr")) {
+      return { ...node, left: this.walkExpr(node.left), right: this.walkExpr(node.right) };
+    }
+    if (((((node.type == "UnaryExpr") || (node.type == "UpdateExpr")) || (node.type == "AwaitExpr")) || (node.type == "TypeofExpr"))) {
+      return { ...node, operand: this.walkExpr(node.operand) };
+    }
+    if ((node.type == "TernaryExpr")) {
+      return { ...node, cond: this.walkExpr(node.cond), then: this.walkExpr(node.then), else_: this.walkExpr(node.else_) };
+    }
+    if ((node.type == "AssignExpr")) {
+      return { ...node, target: this.walkExpr(node.target), value: this.walkExpr(node.value) };
+    }
+    if ((node.type == "SpreadExpr")) {
+      return { ...node, expr: this.walkExpr(node.expr) };
+    }
+    if ((node.type == "PipeExpr")) {
+      return { ...node, left: this.walkExpr(node.left), right: this.walkExpr(node.right) };
+    }
+    if (((node.type == "MemberExpr") || (node.type == "OptMemberExpr"))) {
+      return { ...node, obj: this.walkExpr(node.obj) };
+    }
+    if (((node.type == "IndexExpr") || (node.type == "OptIndexExpr"))) {
+      return { ...node, obj: this.walkExpr(node.obj), idx: this.walkExpr(node.idx) };
+    }
+    if (((node.type == "CallExpr") || (node.type == "OptCallExpr"))) {
+      return { ...node, callee: this.walkExpr(node.callee), args: node.args.map((a) => this.walkExpr(a)) };
+    }
+    if ((node.type == "NewExpr")) {
+      return { ...node, callee: this.mangleName(node.callee), args: node.args.map((a) => this.walkExpr(a)) };
+    }
+    if ((node.type == "LambdaExpr")) {
+      return { ...node, params: node.params.map((p) => { ...p, name: this.mangleParam(p.name) }), body: this.walkExpr(node.body) };
+    }
+    if ((node.type == "FnDecl")) {
+      return this.walkFnDecl(node, {  });
+    }
+    if ((node.type == "ArrayExpr")) {
+      return { ...node, items: node.items.map((i) => this.walkExpr(i)) };
+    }
+    if ((node.type == "ObjectExpr")) {
+      return { ...node, pairs: node.pairs.map((p) => { ...p, value: this.walkExpr(p.value) }) };
+    }
+    if ((node.type == "RangeExpr")) {
+      return { ...node, start: this.walkExpr(node.start), end: this.walkExpr(node.end) };
+    }
+    return node;
+  }
+
+  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));
+    }
+    this.counter = (this.counter + 1);
+  }
+
+  mangleName(name) {
+    if (!name) {
+      return name;
+    }
+    if (((SAFE.has(name) || this.exported.has(name)) || this.imported.has(name))) {
+      return name;
+    }
+    if (this.map.has(name)) {
+      return this.map.get(name);
+    }
+    return name;
+  }
+
+  mangleLocal(name) {
+    if ((!name || SAFE.has(name))) {
+      return name;
+    }
+    if (!this.map.has(name)) {
+      this.map.set(name, makeName(this.counter));
+    }
+    this.counter = (this.counter + 1);
+    return this.map.get(name);
+  }
+
+  mangleParam(name) {
+    if ((!name || SAFE.has(name))) {
+      return name;
+    }
+    if (!this.map.has(name)) {
+      this.map.set(name, makeName(this.counter));
+    }
+    this.counter = (this.counter + 1);
+    return this.map.get(name);
+  }
+
+}
+
+module.exports.Mangler = Mangler;
+function makeMangler() {
+  return new Mangler(new Map(), 0, new Set(), new Set());
+}
+module.exports.makeMangler = makeMangler;