yglob main?

libs/d3_.js

 
   return zoom;
 }
+function evl(txt){
+
+  var ret = {}
+  clog("d3_ evl")
+  ret.eret = eval(txt)
+  clog("d3_ evl.")
+  return ret
+}
+exports.evl = evl;
 
 exports.Adder = Adder;
 exports.Delaunay = Delaunay;

mob/u2/glob_defs.js

+
+glob_dev_hooks = window.glob_dev_hooks || {}
+glob_dev_fns = window.glob_dev_fns || {}
+glob_dbg = window.glob_dbg || {}

xf/sfl/mod_e.js

 // https://observablehq.com/@jinnace/sticky-force-layout@137
 export default function define(runtime, observer) {
   const main = runtime.module();
+  yglob.m = main
   main.variable(observer()).define(["md"], function(md){return(
 md`# Sticky Force Layout
 
 
 // svg.append("g").attr("id","tx").classed("tnodex", true).text("Q")
  // /*
+
+
+
 const node = svg
       .selectAll(".node")
       .data(graph.nodes)
       .join("g")
       .attr("r", 12)
       .classed("node", true)
-      .classed("fixed", d => d.fx !== undefined);
+      .classed("fixed", d => d.fx !== undefined)
+
 
 svg.append("text").attr("id","tx").classed("tnodex", true).text("Q")
   // */
       .attr("fill", "#0ff")
       .classed("node", true)
       .classed("node_l", true)
-      .classed("fixed", (d) => {clog("zx~",d);return d.fx  !== undefined});
+      .classed("fixed", (d) => {clog("zx~",d);return d.fx  !== undefined})
+      .classed("fx", glob_dev_fns.cls_picker || nop)
 // const node = node_l
 // 
 node_l.append("circle")
 
       console.log("NODE",svg,node,[z],z.style,[svg.node])
 
+
+      /*
+      let transform;
+  const zoom = d3.zoom().on("zoom", e => {
+    node.attr("transform", (transform = e.transform));
+    node.style("stroke-width", 3 / Math.sqrt(transform.k));
+    // points.attr("r", 3 / Math.sqrt(transform.k));
+  });
+
+      svg.call(zoom)
+    .call(zoom.transform, d3.zoomIdentity)
+      */
+
+
+
   yield svg.node();
 /*
   clog("z?",graph)
         clog("z~",vx)
       }
 */
+// dev_dec_gen(glob_dev_fns.forceManyBody,"forceManyBody_",[])
+// dev_dec_gen(glob_dev_fns.forceCenter,"forceCenter_",[width / 2, height / 2])
+// dev_dec_gen(glob_dev_fns.forceLink,"forceLink_",[graph.links])
+
+// glob_dev_fns.forceManyBody_
+// glob_dev_fns.forceCenter_
+// glob_dev_fns.forceLink_
+  // clog()
+
+
+
+  clog("d3_",d3,d3.evl,d3.evl(glob_dev_fns.forceManyBody + ""))
+  Object.assign(window.yglob,{d3})
+
   const simulation = d3
     .forceSimulation()
     .nodes(graph.nodes)
+
+    .force("charge",dev_dec_gen(glob_dev_fns.forceManyBody,"forceManyBody_",[]))
+    .force("center",dev_dec_gen(glob_dev_fns.forceCenter,"forceCenter_",[width / 2, height / 2]))
+    .force("link",  dev_dec_gen(glob_dev_fns.forceLink,"forceLink_",[graph.links]))
+
+    // .force("charge", d3.forceManyBody())
+    // .force("center", d3.forceCenter(width / 2, height / 2))
+    // .force("link", d3.forceLink(graph.links))
+
+    .on("tick", tick);
+
+
+/*
+
+
+    .force("charge", d3.evl(`clog("d3_~");ret= `+glob_dev_fns.forceManyBody)())
+    .force("center", d3.evl(`clog("d3_~");ret= `+glob_dev_fns.forceCenter)(width / 2, height / 2))
+    .force("link", d3.evl(`clog("d3_~");ret= `+glob_dev_fns.forceLink)(graph.links))
+
+
+    .force("charge", glob_dev_fns.forceManyBody())
+    .force("center", glob_dev_fns.forceCenter(width / 2, height / 2))
+    .force("link", glob_dev_fns.forceLink(graph.links))
+
     .force("charge", d3.forceManyBody())
     .force("center", d3.forceCenter(width / 2, height / 2))
     .force("link", d3.forceLink(graph.links))
-    .on("tick", tick);
+
+
+
+
+    .force("charge", d3.evl(`
+      clog("d3_C")
+      ret.fn=` +glob_dev_fns.forceManyBody + "").fn())
+    .force("center", d3.evl(`
+clog("d3_C")
+      ret.fn=` +glob_dev_fns.forceCenter + "").fn(width / 2, height / 2))
+    .force("link", d3.evl(`
+
+clog("d3_C")
+      ret.fn=` +glob_dev_fns.forceLink + "").fn(graph.links))
+
+
+
+
+
+
+*/
+
+
+
+
+
+
 
   const drag = d3
     .drag()
   node_l.call(drag).on("click", click);
 
   function tick() {
+    return glob_dev_fns["tick"].apply(this,arguments)
+  }
+  function click(event, d) {
+    return glob_dev_fns["click"].apply(this,arguments)
+  }
+  function dragstart() {
+    return glob_dev_fns["dragstart"].apply(this,arguments)
+  }
+  function dragged(event, d) {
+    return glob_dev_fns["dragged"].apply(this,arguments)
+  }
+  // function tick() {}
+
+  function tick_() {
     link
       .attr("x1", d => d.source.x)
       .attr("y1", d => d.source.y)
     // node.text(d => {      // clog("Ntxt")      return`${d.index} z?`})
     z.text(d => {      
      // clog("Ntxt")      
+      return`${d.index} ${d.i2 != undefined ? d.i2  : "_"}`
+      return`${d.index} ${d.i2  || "_"}`
       return`${d.index} ${d.x.toFixed(2)},${d.y.toFixed(2)}`
     })
     if (!yglob.n1){
     */
   }
 
-  function click(event, d) {
+  function click_(event, d) {
     delete d.fx;
     delete d.fy;
     clog("click")
     simulation.alpha(1).restart();
   }
 
-  function dragstart() {
+  function dragstart_() {
     clog("cli drag")
     d3.select(this).classed("fixed", true);
   }
 
-  function dragged(event, d) {
+  function dragged_(event, d) {
     d.fx = clamp(event.x, 0, width);
     d.fy = clamp(event.y, 0, height);
     // clog("DRAGGED2")
     // simulation.alpha(0).restart();
     simulation.alpha(1).restart();
   }
+  glob_dev_fns["tick"] = tick_
+  glob_dev_fns["click"] = click_
+  glob_dev_fns["dragstart"] = dragstart_
+  glob_dev_fns["dragged"] = dragged_
+
+  glob_dev_fns["tick_"] = tick_
+  glob_dev_fns["click_"] = click_
+  glob_dev_fns["dragstart_"] = dragstart_
+  glob_dev_fns["dragged_"] = dragged_
+
   clog(":vbox")
   window.yglob = window.yglob || {}
   Object.assign(window.yglob,{simulation,d3})
 )});
 */
   main.variable(observer("graph")).define("graph", function(){
+    clog("d3_mg")
 
 
     // return(

xf/sfl/sfl.html

 <!DOCTYPE html>
 <meta charset="utf-8">
 <title>Sticky Force Layout</title>
-<link rel="stylesheet" type="text/css" href="./inspector.css">
-<link rel="stylesheet" type="text/css" href="./m.css">
+<link class="rld" rel="stylesheet" type="text/css" href="./inspector.css">
+<link class="rld" rel="stylesheet" type="text/css" href="./m.css">
 	<script src="/ign/libs/jquery-3.5.1.min.js"></script> 
 	<script class="rld" src="/ign/mob/u2/unj.js?c=023"></script>
+	<script class="rld" src="/ign/mob/u2/glob_defs.js?c=023"></script>
 	<script class="rld" src="/ign/rf/u/proto_ext.js?c=023"></script>
 	<script class="rld" src="/ign/rf/u/universals.js?c=023"></script>
 	<script class="rld" src="/ign/xf/sfl/sfl_r/n1.js?c=023"></script>
 <script>
 	window.dev_flag = 1
 </script>
-	<link rel="stylesheet" type="text/css" href="/ign/xf/sfl/sfl_r/n1.css?c=023">
+	<link  class="rld" rel="stylesheet" type="text/css" href="/ign/xf/sfl/sfl_r/n1.css?c=023">
 
 
 

xf/sfl/sfl_r/n1.css

  
+.n2 *{
+	/*fill: blue !important;*/
+	fill: blue;
+	/*pointer-events:none; */
+	/*fill: blue !important;*/
+}

xf/sfl/sfl_r/n1.js

 clog("A.")
 
 
+function add_link(link_) {
+	var link = jc(link_)
+	// body...
+}
+
+
+
+function evl_test(txt){
+		var ret = {}
+		  ret.eret = eval(txt)// clog("d3_r evl.")
+		  return ret
+
+}
+
+function scope_test(){
+	var lvar = "z"
+	Function.call(fnt)
+	// new Function("return " +fnt)()()
+
+}
+
+
+function fn_attrs(fn){
+	var i,k,v 
+	i=0
+	// for ([k,v] of entries(fn)) {
+	for ([k,v] in entries(fn)) {
+		i++
+		clog(".",{i,k,v})
+	}
+
+	// dev_dec_gen2(glob_dev_fns.forceManyBody,"forceManyBody_")
+}
+
+
+function fnt(){
+	clog("FNT1",lvar)
+}
+
+// fn_gen.forceManyBody_.fn
+
+// n.toString(10.2)
+glob_dev_fns.cls_picker = function(){
+	clog("d3_~ CLS!",{that:this,args:[...arguments]})
+}
+
+
+function i2hp(int,s="",size=2){
+	return s + Number(int).toString(16).padStart(size,"0")
+	// "".padStart(2,"0")
+
+}
+
+function* sequenceGenerator(minVal, maxVal) {
+    let currVal = minVal;
+    let cnt
+
+    while(currVal < maxVal){
+    	clog("CV",currVal)
+    // let cv = currVal++
+    cnt += 1
+    if (cnt > 30){
+    	clog("CNT!")
+    	break
+    }
+    	yield currVal.toString(3)
+    // .padStart(3,"0")
+        // yield currVal++;
+		currVal++;
+    	
+    	clog("CV.",currVal)
+    }
+}
+function* sequenceGenerator2(minVal, maxVal) {
+    let currVal = minVal;
+    let cnt
+
+    while(currVal < maxVal){
+    	clog("CV",currVal)
+    // let cv = currVal++
+    cnt += 1
+    if (cnt > 30){
+    	clog("CNT!")
+    	break
+    }
+
+    	yield i2hp(currVal++)
+    // .padStart(3,"0")
+        // yield currVal++;
+		// currVal++;
+    	
+    	// clog("CV.",currVal)
+    }
+}
+// sequenceGenerator
+// a=[...sequenceGenerator(0,27)]
+
+// [
+// 111
+// 110
+// 101
+// 011
+
+// 001
+// 010
+// 100
+// 000
+
+
+// 8 01
+// 7 02
+// 6 12
+
+
+// 012
+// 021
+// 102
+// 120
+// 210
+// 201
+// ]
+
+function gen_colors(){
+
+}
+
+
+
+
+
+function save_index(){
+	yglob.main.nodes.forEach(function(n,i,arr){
+
+		clog("d3_E",{that:this,args:[...arguments]})
+		Object.assign(n,{i2:n.index})
+	})
+}
+
+function save_index2(){
+	yglob.main.nodes.forEach(function(){
+		clog("d3_E",{that:this,args:[...arguments]})
+	})
+}
+function splice_out(arr,elm){
+	let i = arr.indexOf(elm)
+	// var r = "" 
+	if (i != -1){
+		return arr.splice(i,1)
+	}
+	// return
+
+}
+
+function rem_node_by_index(index){
+	var n = get_node(index)
+	return splice_out(yglob.main.nodes,n)
+}
+
+function get_node(index){
+	var i,k,v
+	for (v of yglob.main.nodes){
+		if (v.index == index){
+			return v
+		}
+	}
+
+}
+// a = [1,2,3,4,5,6,7,8,9,0]
+// 

xf/sfl/sfl_r/n2.js

  
+{
+// forceManyBody
+// forceCenter
+// forceLink
+
+window.glob_dev_fns.forceLink = function link(links) {
+  var id = index$1,
+      strength = defaultStrength,
+      strengths,
+      distance = constant$7(30),
+      distances,
+      nodes,
+      count,
+      bias,
+      random,
+      iterations = 1;
+
+  if (links == null) links = [];
+
+  function defaultStrength(link) {
+    return 1 / Math.min(count[link.source.index], count[link.target.index]);
+  }
+
+  function force(alpha) {
+    for (var k = 0, n = links.length; k < iterations; ++k) {
+      for (var i = 0, link, source, target, x, y, l, b; i < n; ++i) {
+        link = links[i], source = link.source, target = link.target;
+        x = target.x + target.vx - source.x - source.vx || jiggle(random);
+        y = target.y + target.vy - source.y - source.vy || jiggle(random);
+        l = Math.sqrt(x * x + y * y);
+        l = (l - distances[i]) / l * alpha * strengths[i];
+        x *= l, y *= l;
+        target.vx -= x * (b = bias[i]);
+        target.vy -= y * b;
+        source.vx += x * (b = 1 - b);
+        source.vy += y * b;
+      }
+    }
+  }
+  	function reinit(txt){
+		var ret = {};ret.eret = eval(txt);return ret
+	}
+	force.reinit = reinit
+
+  function initialize() {
+    if (!nodes) return;
+
+    var i,
+        n = nodes.length,
+        m = links.length,
+        nodeById = new Map(nodes.map((d, i) => [id(d, i, nodes), d])),
+        link;
+
+    for (i = 0, count = new Array(n); i < m; ++i) {
+      link = links[i], link.index = i;
+      if (typeof link.source !== "object") link.source = find$1(nodeById, link.source);
+      if (typeof link.target !== "object") link.target = find$1(nodeById, link.target);
+      count[link.source.index] = (count[link.source.index] || 0) + 1;
+      count[link.target.index] = (count[link.target.index] || 0) + 1;
+    }
+
+    for (i = 0, bias = new Array(m); i < m; ++i) {
+      link = links[i], bias[i] = count[link.source.index] / (count[link.source.index] + count[link.target.index]);
+    }
+
+    strengths = new Array(m), initializeStrength();
+    distances = new Array(m), initializeDistance();
+  }
+
+  function initializeStrength() {
+    if (!nodes) return;
+
+    for (var i = 0, n = links.length; i < n; ++i) {
+      strengths[i] = +strength(links[i], i, links);
+    }
+  }
+
+  function initializeDistance() {
+    if (!nodes) return;
+
+    for (var i = 0, n = links.length; i < n; ++i) {
+      distances[i] = +distance(links[i], i, links);
+    }
+  }
+
+  force.initialize = function(_nodes, _random) {
+    nodes = _nodes;
+    random = _random;
+    initialize();
+  };
+
+  force.links = function(_) {
+    return arguments.length ? (links = _, initialize(), force) : links;
+  };
+
+  force.id = function(_) {
+    return arguments.length ? (id = _, force) : id;
+  };
+
+  force.iterations = function(_) {
+    return arguments.length ? (iterations = +_, force) : iterations;
+  };
+
+  force.strength = function(_) {
+    return arguments.length ? (strength = typeof _ === "function" ? _ : constant$7(+_), initializeStrength(), force) : strength;
+  };
+
+  force.distance = function(_) {
+    return arguments.length ? (distance = typeof _ === "function" ? _ : constant$7(+_), initializeDistance(), force) : distance;
+  };
+
+  return force;
+}
+
+
+
+
+
+
+
+
+window.glob_dev_fns.forceCenter = function center$1(x, y) {
+  var nodes, strength = 1;
+
+  if (x == null) x = 0;
+  if (y == null) y = 0;
+
+  function force() {
+    var i,
+        n = nodes.length,
+        node,
+        sx = 0,
+        sy = 0;
+
+    for (i = 0; i < n; ++i) {
+      node = nodes[i], sx += node.x, sy += node.y;
+    }
+
+    for (sx = (sx / n - x) * strength, sy = (sy / n - y) * strength, i = 0; i < n; ++i) {
+      node = nodes[i], node.x -= sx, node.y -= sy;
+    }
+  }
+	function reinit(txt){
+		var ret = {};ret.eret = eval(txt);return ret
+	}
+	force.reinit = reinit
+
+  force.initialize = function(_) {
+    nodes = _;
+  };
+
+  force.x = function(_) {
+    return arguments.length ? (x = +_, force) : x;
+  };
+
+  force.y = function(_) {
+    return arguments.length ? (y = +_, force) : y;
+  };
+
+  force.strength = function(_) {
+    return arguments.length ? (strength = +_, force) : strength;
+  };
+
+  return force;
+}
+
+
+
+
+window.glob_dev_fns.forceManyBody = function manyBody() {
+	clog("d3 dc3")
+
+  var nodes,
+      node,
+      random,
+      alpha,
+      strength = constant$7(-30),
+      strengths,
+      distanceMin2 = 1,
+      distanceMax2 = Infinity,
+      theta2 = 0.81;
+
+  function force(_) {
+
+  	function xfn(){
+  		clog("XFN")
+  	}
+
+	if (glob_dbg.rfn_c > 0){
+		glob_dbg.rfn_c -= 1
+		clog("d3_r",glob_dbg.rfn_c,this)
+		// clog("d3_r",glob_dbg.rfn_c,this,fn_gen[this.name])
+	}
+
+  	this.xfn_ = xfn
+
+    var i, n = nodes.length, tree = quadtree(nodes, x$1, y$1).visitAfter(accumulate);
+    for (alpha = _, i = 0; i < n; ++i) node = nodes[i], tree.visit(apply);
+  }
+
+	function reinit(txt){
+		var ret = {};ret.eret = eval(txt);return ret
+	}
+	force.reinit = reinit
+
+  function initialize() {
+    if (!nodes) return;
+    var i, n = nodes.length, node;
+    strengths = new Array(n);
+    for (i = 0; i < n; ++i) node = nodes[i], strengths[node.index] = +strength(node, i, nodes);
+  }
+
+  function accumulate(quad) {
+    var strength = 0, q, c, weight = 0, x, y, i;
+
+    // For internal nodes, accumulate forces from child quadrants.
+    if (quad.length) {
+      for (x = y = i = 0; i < 4; ++i) {
+        if ((q = quad[i]) && (c = Math.abs(q.value))) {
+          strength += q.value, weight += c, x += c * q.x, y += c * q.y;
+        }
+      }
+      quad.x = x / weight;
+      quad.y = y / weight;
+    }
+
+    // For leaf nodes, accumulate forces from coincident quadrants.
+    else {
+      q = quad;
+      q.x = q.data.x;
+      q.y = q.data.y;
+      do strength += strengths[q.data.index];
+      while (q = q.next);
+    }
+
+    quad.value = strength;
+  }
+
+  function apply(quad, x1, _, x2) {
+    if (!quad.value) return true;
+
+    var x = quad.x - node.x,
+        y = quad.y - node.y,
+        w = x2 - x1,
+        l = x * x + y * y;
+
+    // Apply the Barnes-Hut approximation if possible.
+    // Limit forces for very close nodes; randomize direction if coincident.
+    if (w * w / theta2 < l) {
+      if (l < distanceMax2) {
+        if (x === 0) x = jiggle(random), l += x * x;
+        if (y === 0) y = jiggle(random), l += y * y;
+        if (l < distanceMin2) l = Math.sqrt(distanceMin2 * l);
+        node.vx += x * quad.value * alpha / l;
+        node.vy += y * quad.value * alpha / l;
+      }
+      return true;
+    }
+
+    // Otherwise, process points directly.
+    else if (quad.length || l >= distanceMax2) return;
+
+    // Limit forces for very close nodes; randomize direction if coincident.
+    if (quad.data !== node || quad.next) {
+      if (x === 0) x = jiggle(random), l += x * x;
+      if (y === 0) y = jiggle(random), l += y * y;
+      if (l < distanceMin2) l = Math.sqrt(distanceMin2 * l);
+    }
+
+    do if (quad.data !== node) {
+      w = strengths[quad.data.index] * alpha / l;
+      node.vx += x * w;
+      node.vy += y * w;
+    } while (quad = quad.next);
+  }
+
+  force.initialize = function(_nodes, _random) {
+    nodes = _nodes;
+    random = _random;
+    initialize();
+  };
+
+  force.strength = function(_) {
+	if (glob_dbg.rfn_c > 0){
+		glob_dbg.rfn_c -= 1
+		clog("d3_r strength",glob_dbg.rfn_c,this)
+		// clog("d3_r",glob_dbg.rfn_c,this,fn_gen[this.name])
+	}
+
+
+    return arguments.length ? (strength = typeof _ === "function" ? _ : constant$7(+_), initialize(), force) : strength;
+  };
+
+  force.distanceMin = function(_) {
+    return arguments.length ? (distanceMin2 = _ * _, force) : Math.sqrt(distanceMin2);
+  };
+
+  force.distanceMax = function(_) {
+    return arguments.length ? (distanceMax2 = _ * _, force) : Math.sqrt(distanceMax2);
+  };
+
+  force.theta = function(_) {
+    return arguments.length ? (theta2 = _ * _, force) : Math.sqrt(theta2);
+  };
+
+  return force;
+}
+
+
+}
+
+
+
+glob_dev_fns.forceManyBody_ = glob_dev_fns.forceManyBody
+glob_dev_fns.forceCenter_ = glob_dev_fns.forceCenter
+glob_dev_fns.forceLink_ = glob_dev_fns.forceLink
+
+
+
+
+clog("n2")
+function trc(){
+	console.trace("zq")
+}
+
+function eval_helper(txt){
+	return yglob.d3.evl(txt).fn
+}
+function eval_helper2(txt,fscope){
+	return fscope.reinit(txt).fn
+}
+window.glob_dev_fns["test"]  = function test(){
+	clog("TEXT")
+}
+
+
+
+
+if (window.yglob){
+
+// glob_dev_fns.forceManyBody_
+// glob_dev_fns.forceCenter_
+// glob_dev_fns.forceLink_
+
+// dev_dec_gen2(glob_dev_fns.forceManyBody,"forceManyBody_")
+dev_dec_gen2(glob_dev_fns.forceManyBody,"forceManyBody_")
+dev_dec_gen2(glob_dev_fns.forceCenter,"forceCenter_")
+dev_dec_gen2(glob_dev_fns.forceLink,"forceLink_")
+
+}
+
+
+
+
+
+
+
+
+
+
+
+function ret_fn(){
+	// clog("?")
+	if (glob_dbg.rfn_c > 0){
+		glob_dbg.rfn_c -= 1
+		clog("d3_r",glob_dbg.rfn_c,this,fn_gen[this.name])
+	}
+	// window.yglob
+	return fn_gen[this.name].fn
+}
+
+function txt_dec_fn(fn){
+	return "ret.fn = "+ fn + ""
+}
+
+function reinit_helper(nforce,oforce,m){
+	var rforce = eval_helper2(txt_dec_fn(nforce),oforce)
+	clog("d3_re rf",m)
+	var i,k,v
+	var varr = []
+	for ([k,v] of entries(oforce)){
+		varr.push(k)
+		if (k=="reinit"){
+			// continue
+		}
+		if (v + "" == rforce[k] + ""){
+			rforce[k]=v
+			continue
+
+		} else if (!rforce[k]) {
+			rforce[k]=v
+			continue
+
+		} else {
+			clog("d3_re rfk",m,k)
+			rforce[k] = eval_helper2(txt_dec_fn(rforce[k]),oforce)
+		}
+
+	}
+	for ([k,v] of entries(rforce)){
+		if (varr.includes(k)){
+			continue
+		} 
+			clog("d3_re rfk_",m,k)
+		rforce[k] = eval_helper2(txt_dec_fn(rforce[k]),oforce)
+	}
+	return rforce
+
+
+}
+
+function dev_dec_gen2(fn_txt,name,args,that){
+	let txt = txt_dec_fn(fn_txt)
+	let fscope = fn_gen[name]
+	let evl_fn = eval_helper(txt,fscope.fn)
+	var nforce = evl_fn(...fn_gen[name].args)
+	// force.reinit
+	let evl_fn2 = reinit_helper(nforce,fscope.fn,{name})
+			/*
+	let evl_fn2 = eval_helper2(txt_dec_fn(nforce),fscope.fn)
+
+
+	// fn_gen.forceManyBody_.fn
+	Object.assign(evl_fn2,fn_gen[name].fn)
+	// evl_fn2
+	evl_fn2.reinit = fn_gen[name].fn.reinit
+	//		*/
+	// fn_gen[name].fn = evl_fn(...fn_gen[name].args)
+		fn_gen[name].fn = evl_fn2
+}
+
+function dev_dec_gen2_(fn_txt,name,args,that){
+	let txt = txt_dec_fn(fn_txt)
+	let evl_fn = eval_helper(txt)
+	fn_gen[name].fn = evl_fn(...fn_gen[name].args)
+}
+
+function dev_dec_gen(fn_txt,name,args,that){
+	let txt = txt_dec_fn(fn_txt)
+	let evl_fn = eval_helper(txt)
+	if (!fn_gen[name]){
+		fn_gen[name] = {args:[]}
+	}
+	if (args){
+	fn_gen[name].args = args
+
+	}
+	fn_gen[name].fn = evl_fn(...fn_gen[name].args)
+	// glob_dev_fns[name] = evl_fn(...args)
+	glob_dev_fns[name] = new Proxy(fn_gen[name].fn,{name,...fn_gen.fn_prx})
+	// glob_dev_fns[name] = ret_fn.bind({name})
+	return glob_dev_fns[name]
+}
+
+fn_gen = window.fn_gen || {}
+fn_gen.fn_prx = {
+	apply:function(target,that,args){
+		return fn_gen[this.name].fn(...args)
+	},
+	// new Proxy(target, handler)
+
+}
+
+
+
+
+glob_dbg.rfn_b = 0
+glob_dbg.rfn_c = 3
+
+
+
+clog("d3_+",window.yglob,glob_dbg,jc(glob_dbg))
+
+
+
+// yglob.d3.evl(`clog("d3_~");ret= `+glob_dev_fns.forceManyBody)()
+
+
+
+
+// glob_dev_fns.forceLink
+
+/*
+var z = "tx_4"
+// var Z = "tx_3"
+// window.glob_dev_fns["tx_2"]  = function(){
+window["glob_dev_fns"][`Z_${1}`]  = function(){
+	clog("z3")
+	// console.trace("zq")
+	trc()
+}
+window["glob_dev_fns"][z]  = function(){
+	clog("z4")
+	// console.trace("zq")
+	trc()
+}
+*/
+
+// glob_dev_fns["tx_2"]()
+// glob_dev_fns["tx_3"]()
+// glob_dev_fns["tx_4"]()

xf/vc/vc_iconf.js

 		// arr_rmv(interfaceConfig.TOOLBAR_BUTTONS,"fullscreen")
 		arr_rmv(interfaceConfig.TOOLBAR_BUTTONS,"shortcuts")
 		// arr_rmv(interfaceConfig.TOOLBAR_BUTTONS,"tileview")
-		arr_rmv(interfaceConfig.TOOLBAR_BUTTONS,"livestreaming")
+		// arr_rmv(interfaceConfig.TOOLBAR_BUTTONS,"livestreaming")
 		arr_rmv(interfaceConfig.TOOLBAR_BUTTONS,"recording")
 		// arr_rmv(interfaceConfig.TOOLBAR_BUTTONS,"filmstrip")
 		clog("MODx",isMod,interfaceConfig.TOOLBAR_BUTTONS)