Bar graph added.

node_modules/vega-force/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2015-2018, University of Washington Interactive Data Lab
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+  may be used to endorse or promote products derived from this software
+  without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

node_modules/vega-force/README.md

@@ -0,0 +1,7 @@
+# vega-force
+
+Force simulation transform for Vega dataflows.
+
+This package provides the following Vega data transform:
+
+- [**Force**](https://vega.github.io/vega/docs/transforms/force/) [<>](https://github.com/vega/vega/blob/master/packages/vega-force/src/Force.js "Source")

node_modules/vega-force/build/vega-force.js

@@ -0,0 +1,250 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('vega-dataflow'), require('vega-util'), require('d3-force')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'vega-dataflow', 'vega-util', 'd3-force'], factory) :
+  (global = global || self, factory((global.vega = global.vega || {}, global.vega.transforms = {}), global.vega, global.vega, global.d3));
+}(this, (function (exports, vegaDataflow, vegaUtil, d3Force) { 'use strict';
+
+  var ForceMap = {
+    center: d3Force.forceCenter,
+    collide: d3Force.forceCollide,
+    nbody: d3Force.forceManyBody,
+    link: d3Force.forceLink,
+    x: d3Force.forceX,
+    y: d3Force.forceY
+  };
+
+  var Forces = 'forces',
+      ForceParams = [
+        'alpha', 'alphaMin', 'alphaTarget',
+        'velocityDecay', 'forces'
+      ],
+      ForceConfig = ['static', 'iterations'],
+      ForceOutput = ['x', 'y', 'vx', 'vy'];
+
+  /**
+   * Force simulation layout.
+   * @constructor
+   * @param {object} params - The parameters for this operator.
+   * @param {Array<object>} params.forces - The forces to apply.
+   */
+  function Force(params) {
+    vegaDataflow.Transform.call(this, null, params);
+  }
+
+  Force.Definition = {
+    'type': 'Force',
+    'metadata': {'modifies': true},
+    'params': [
+      { 'name': 'static', 'type': 'boolean', 'default': false },
+      { 'name': 'restart', 'type': 'boolean', 'default': false },
+      { 'name': 'iterations', 'type': 'number', 'default': 300 },
+      { 'name': 'alpha', 'type': 'number', 'default': 1 },
+      { 'name': 'alphaMin', 'type': 'number', 'default': 0.001 },
+      { 'name': 'alphaTarget', 'type': 'number', 'default': 0 },
+      { 'name': 'velocityDecay', 'type': 'number', 'default': 0.4 },
+      { 'name': 'forces', 'type': 'param', 'array': true,
+        'params': [
+          {
+            'key': {'force': 'center'},
+            'params': [
+              { 'name': 'x', 'type': 'number', 'default': 0 },
+              { 'name': 'y', 'type': 'number', 'default': 0 }
+            ]
+          },
+          {
+            'key': {'force': 'collide'},
+            'params': [
+              { 'name': 'radius', 'type': 'number', 'expr': true },
+              { 'name': 'strength', 'type': 'number', 'default': 0.7 },
+              { 'name': 'iterations', 'type': 'number', 'default': 1 }
+            ]
+          },
+          {
+            'key': {'force': 'nbody'},
+            'params': [
+              { 'name': 'strength', 'type': 'number', 'default': -30 },
+              { 'name': 'theta', 'type': 'number', 'default': 0.9 },
+              { 'name': 'distanceMin', 'type': 'number', 'default': 1 },
+              { 'name': 'distanceMax', 'type': 'number' }
+            ]
+          },
+          {
+            'key': {'force': 'link'},
+            'params': [
+              { 'name': 'links', 'type': 'data' },
+              { 'name': 'id', 'type': 'field' },
+              { 'name': 'distance', 'type': 'number', 'default': 30, 'expr': true },
+              { 'name': 'strength', 'type': 'number', 'expr': true },
+              { 'name': 'iterations', 'type': 'number', 'default': 1 }
+            ]
+          },
+          {
+            'key': {'force': 'x'},
+            'params': [
+              { 'name': 'strength', 'type': 'number', 'default': 0.1 },
+              { 'name': 'x', 'type': 'field' }
+            ]
+          },
+          {
+            'key': {'force': 'y'},
+            'params': [
+              { 'name': 'strength', 'type': 'number', 'default': 0.1 },
+              { 'name': 'y', 'type': 'field' }
+            ]
+          }
+        ] },
+      {
+        'name': 'as', 'type': 'string', 'array': true, 'modify': false,
+        'default': ForceOutput
+      }
+    ]
+  };
+
+  var prototype = vegaUtil.inherits(Force, vegaDataflow.Transform);
+
+  prototype.transform = function(_, pulse) {
+    var sim = this.value,
+        change = pulse.changed(pulse.ADD_REM),
+        params = _.modified(ForceParams),
+        iters = _.iterations || 300;
+
+    // configure simulation
+    if (!sim) {
+      this.value = sim = simulation(pulse.source, _);
+      sim.on('tick', rerun(pulse.dataflow, this));
+      if (!_.static) {
+        change = true;
+        sim.tick(); // ensure we run on init
+      }
+      pulse.modifies('index');
+    } else {
+      if (change) {
+        pulse.modifies('index');
+        sim.nodes(pulse.source);
+      }
+      if (params || pulse.changed(pulse.MOD)) {
+        setup(sim, _, 0, pulse);
+      }
+    }
+
+    // run simulation
+    if (params || change || _.modified(ForceConfig)
+        || (pulse.changed() && _.restart))
+    {
+      sim.alpha(Math.max(sim.alpha(), _.alpha || 1))
+         .alphaDecay(1 - Math.pow(sim.alphaMin(), 1 / iters));
+
+      if (_.static) {
+        for (sim.stop(); --iters >= 0;) sim.tick();
+      } else {
+        if (sim.stopped()) sim.restart();
+        if (!change) return pulse.StopPropagation; // defer to sim ticks
+      }
+    }
+
+    return this.finish(_, pulse);
+  };
+
+  prototype.finish = function(_, pulse) {
+    var dataflow = pulse.dataflow;
+
+    // inspect dependencies, touch link source data
+    for (var args=this._argops, j=0, m=args.length, arg; j<m; ++j) {
+      arg = args[j];
+      if (arg.name !== Forces || arg.op._argval.force !== 'link') {
+        continue;
+      }
+      for (var ops=arg.op._argops, i=0, n=ops.length, op; i<n; ++i) {
+        if (ops[i].name === 'links' && (op = ops[i].op.source)) {
+          dataflow.pulse(op, dataflow.changeset().reflow());
+          break;
+        }
+      }
+    }
+
+    // reflow all nodes
+    return pulse.reflow(_.modified()).modifies(ForceOutput);
+  };
+
+  function rerun(df, op) {
+    return function() { df.touch(op).run(); };
+  }
+
+  function simulation(nodes, _) {
+    var sim = d3Force.forceSimulation(nodes),
+        stopped = false,
+        stop = sim.stop,
+        restart = sim.restart;
+
+    sim.stopped = function() {
+      return stopped;
+    };
+    sim.restart = function() {
+      stopped = false;
+      return restart();
+    };
+    sim.stop = function() {
+      stopped = true;
+      return stop();
+    };
+
+    return setup(sim, _, true).on('end', function() { stopped = true; });
+  }
+
+  function setup(sim, _, init, pulse) {
+    var f = vegaUtil.array(_.forces), i, n, p, name;
+
+    for (i=0, n=ForceParams.length; i<n; ++i) {
+      p = ForceParams[i];
+      if (p !== Forces && _.modified(p)) sim[p](_[p]);
+    }
+
+    for (i=0, n=f.length; i<n; ++i) {
+      name = Forces + i;
+      p = init || _.modified(Forces, i) ? getForce(f[i])
+        : pulse && modified(f[i], pulse) ? sim.force(name)
+        : null;
+      if (p) sim.force(name, p);
+    }
+
+    for (n=(sim.numForces || 0); i<n; ++i) {
+      sim.force(Forces + i, null); // remove
+    }
+
+    sim.numForces = f.length;
+    return sim;
+  }
+
+  function modified(f, pulse) {
+    var k, v;
+    for (k in f) {
+      if (vegaUtil.isFunction(v = f[k]) && pulse.modified(vegaUtil.accessorFields(v)))
+        return 1;
+    }
+    return 0;
+  }
+
+  function getForce(_) {
+    var f, p;
+
+    if (!vegaUtil.hasOwnProperty(ForceMap, _.force)) {
+      vegaUtil.error('Unrecognized force: ' + _.force);
+    }
+    f = ForceMap[_.force]();
+
+    for (p in _) {
+      if (vegaUtil.isFunction(f[p])) setForceParam(f[p], _[p], _);
+    }
+
+    return f;
+  }
+
+  function setForceParam(f, v, _) {
+    f(vegaUtil.isFunction(v) ? function(d) { return v(d, _); } : v);
+  }
+
+  exports.force = Force;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+})));

node_modules/vega-force/build/vega-force.min.js

@@ -0,0 +1 @@
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports,require("vega-dataflow"),require("vega-util"),require("d3-force")):"function"==typeof define&&define.amd?define(["exports","vega-dataflow","vega-util","d3-force"],t):t(((e=e||self).vega=e.vega||{},e.vega.transforms={}),e.vega,e.vega,e.d3)}(this,(function(e,t,a,r){"use strict";var n={center:r.forceCenter,collide:r.forceCollide,nbody:r.forceManyBody,link:r.forceLink,x:r.forceX,y:r.forceY},o=["alpha","alphaMin","alphaTarget","velocityDecay","forces"],i=["static","iterations"],f=["x","y","vx","vy"];function u(e){t.Transform.call(this,null,e)}u.Definition={type:"Force",metadata:{modifies:!0},params:[{name:"static",type:"boolean",default:!1},{name:"restart",type:"boolean",default:!1},{name:"iterations",type:"number",default:300},{name:"alpha",type:"number",default:1},{name:"alphaMin",type:"number",default:.001},{name:"alphaTarget",type:"number",default:0},{name:"velocityDecay",type:"number",default:.4},{name:"forces",type:"param",array:!0,params:[{key:{force:"center"},params:[{name:"x",type:"number",default:0},{name:"y",type:"number",default:0}]},{key:{force:"collide"},params:[{name:"radius",type:"number",expr:!0},{name:"strength",type:"number",default:.7},{name:"iterations",type:"number",default:1}]},{key:{force:"nbody"},params:[{name:"strength",type:"number",default:-30},{name:"theta",type:"number",default:.9},{name:"distanceMin",type:"number",default:1},{name:"distanceMax",type:"number"}]},{key:{force:"link"},params:[{name:"links",type:"data"},{name:"id",type:"field"},{name:"distance",type:"number",default:30,expr:!0},{name:"strength",type:"number",expr:!0},{name:"iterations",type:"number",default:1}]},{key:{force:"x"},params:[{name:"strength",type:"number",default:.1},{name:"x",type:"field"}]},{key:{force:"y"},params:[{name:"strength",type:"number",default:.1},{name:"y",type:"field"}]}]},{name:"as",type:"string",array:!0,modify:!1,default:f}]};var s=a.inherits(u,t.Transform);function c(e,t,r,n){var i,f,u,s,c=a.array(t.forces);for(i=0,f=o.length;i<f;++i)"forces"!==(u=o[i])&&t.modified(u)&&e[u](t[u]);for(i=0,f=c.length;i<f;++i)s="forces"+i,(u=r||t.modified("forces",i)?d(c[i]):n&&l(c[i],n)?e.force(s):null)&&e.force(s,u);for(f=e.numForces||0;i<f;++i)e.force("forces"+i,null);return e.numForces=c.length,e}function l(e,t){var r,n;for(r in e)if(a.isFunction(n=e[r])&&t.modified(a.accessorFields(n)))return 1;return 0}function d(e){var t,r;for(r in a.hasOwnProperty(n,e.force)||a.error("Unrecognized force: "+e.force),t=n[e.force](),e)a.isFunction(t[r])&&m(t[r],e[r],e);return t}function m(e,t,r){e(a.isFunction(t)?function(e){return t(e,r)}:t)}s.transform=function(e,t){var a,n,f=this.value,u=t.changed(t.ADD_REM),s=e.modified(o),l=e.iterations||300;if(f?(u&&(t.modifies("index"),f.nodes(t.source)),(s||t.changed(t.MOD))&&c(f,e,0,t)):(this.value=f=function(e,t){var a=r.forceSimulation(e),n=!1,o=a.stop,i=a.restart;return a.stopped=function(){return n},a.restart=function(){return n=!1,i()},a.stop=function(){return n=!0,o()},c(a,t,!0).on("end",(function(){n=!0}))}(t.source,e),f.on("tick",(a=t.dataflow,n=this,function(){a.touch(n).run()})),e.static||(u=!0,f.tick()),t.modifies("index")),s||u||e.modified(i)||t.changed()&&e.restart)if(f.alpha(Math.max(f.alpha(),e.alpha||1)).alphaDecay(1-Math.pow(f.alphaMin(),1/l)),e.static)for(f.stop();--l>=0;)f.tick();else if(f.stopped()&&f.restart(),!u)return t.StopPropagation;return this.finish(e,t)},s.finish=function(e,t){for(var a,r=t.dataflow,n=this._argops,o=0,i=n.length;o<i;++o)if("forces"===(a=n[o]).name&&"link"===a.op._argval.force)for(var u,s=a.op._argops,c=0,l=s.length;c<l;++c)if("links"===s[c].name&&(u=s[c].op.source)){r.pulse(u,r.changeset().reflow());break}return t.reflow(e.modified()).modifies(f)},e.force=u,Object.defineProperty(e,"__esModule",{value:!0})}));

node_modules/vega-force/index.js

@@ -0,0 +1 @@
+export {default as force} from './src/Force';

node_modules/vega-force/package.json

@@ -0,0 +1,68 @@
+{
+  "_from": "vega-force@~4.0.4",
+  "_id": "vega-force@4.0.4",
+  "_inBundle": false,
+  "_integrity": "sha512-ETTezb3lpQIbrk8pdmv4WpoNlChWdIK1Hv5CHL8Q/oOT/lIop/NHnI+JZO4yuzaYv+o3UqNWPcjiY0U5/i51dw==",
+  "_location": "/vega-force",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "vega-force@~4.0.4",
+    "name": "vega-force",
+    "escapedName": "vega-force",
+    "rawSpec": "~4.0.4",
+    "saveSpec": null,
+    "fetchSpec": "~4.0.4"
+  },
+  "_requiredBy": [
+    "/vega"
+  ],
+  "_resolved": "https://registry.npmjs.org/vega-force/-/vega-force-4.0.4.tgz",
+  "_shasum": "b73cba2e169cc248c994c9d981c374eb06aff764",
+  "_spec": "vega-force@~4.0.4",
+  "_where": "/home/prabhatdev/Documents/opensource/gitHubStats/waka-readme-stats/node_modules/vega",
+  "author": {
+    "name": "Jeffrey Heer",
+    "url": "http://idl.cs.washington.edu"
+  },
+  "bugs": {
+    "url": "https://github.com/vega/vega/issues"
+  },
+  "bundleDependencies": false,
+  "dependencies": {
+    "d3-force": "^2.0.1",
+    "vega-dataflow": "^5.5.1",
+    "vega-util": "^1.13.2"
+  },
+  "deprecated": false,
+  "description": "Force simulation transform for Vega dataflows.",
+  "devDependencies": {
+    "vega-transforms": "*"
+  },
+  "gitHead": "35e31c5c6b54db9dc3a577b5adad8d15ec274d32",
+  "homepage": "https://github.com/vega/vega#readme",
+  "keywords": [
+    "vega",
+    "force"
+  ],
+  "license": "BSD-3-Clause",
+  "main": "build/vega-force.js",
+  "module": "index",
+  "name": "vega-force",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vega/vega.git"
+  },
+  "scripts": {
+    "build": "yarn rollup",
+    "postbuild": "terser build/vega-force.js -c -m -o build/vega-force.min.js",
+    "postpublish": "git push && git push --tags",
+    "prebuild": "rimraf build && mkdir build",
+    "prepublishOnly": "yarn test && yarn build",
+    "pretest": "yarn prebuild && yarn rollup",
+    "rollup": "rollup -g d3-force:d3,vega-dataflow:vega,vega-util:vega -f umd -n vega.transforms -o build/vega-force.js -- index.js",
+    "test": "tape 'test/**/*-test.js'"
+  },
+  "version": "4.0.4"
+}

node_modules/vega-force/src/Force.js

@@ -0,0 +1,248 @@
+import {Transform} from 'vega-dataflow';
+import {
+  accessorFields, array, error, hasOwnProperty,
+  inherits, isFunction
+} from 'vega-util';
+import {
+  forceCenter, forceCollide, forceLink,
+  forceManyBody, forceSimulation, forceX, forceY
+} from 'd3-force';
+
+var ForceMap = {
+  center: forceCenter,
+  collide: forceCollide,
+  nbody: forceManyBody,
+  link: forceLink,
+  x: forceX,
+  y: forceY
+};
+
+var Forces = 'forces',
+    ForceParams = [
+      'alpha', 'alphaMin', 'alphaTarget',
+      'velocityDecay', 'forces'
+    ],
+    ForceConfig = ['static', 'iterations'],
+    ForceOutput = ['x', 'y', 'vx', 'vy'];
+
+/**
+ * Force simulation layout.
+ * @constructor
+ * @param {object} params - The parameters for this operator.
+ * @param {Array<object>} params.forces - The forces to apply.
+ */
+export default function Force(params) {
+  Transform.call(this, null, params);
+}
+
+Force.Definition = {
+  'type': 'Force',
+  'metadata': {'modifies': true},
+  'params': [
+    { 'name': 'static', 'type': 'boolean', 'default': false },
+    { 'name': 'restart', 'type': 'boolean', 'default': false },
+    { 'name': 'iterations', 'type': 'number', 'default': 300 },
+    { 'name': 'alpha', 'type': 'number', 'default': 1 },
+    { 'name': 'alphaMin', 'type': 'number', 'default': 0.001 },
+    { 'name': 'alphaTarget', 'type': 'number', 'default': 0 },
+    { 'name': 'velocityDecay', 'type': 'number', 'default': 0.4 },
+    { 'name': 'forces', 'type': 'param', 'array': true,
+      'params': [
+        {
+          'key': {'force': 'center'},
+          'params': [
+            { 'name': 'x', 'type': 'number', 'default': 0 },
+            { 'name': 'y', 'type': 'number', 'default': 0 }
+          ]
+        },
+        {
+          'key': {'force': 'collide'},
+          'params': [
+            { 'name': 'radius', 'type': 'number', 'expr': true },
+            { 'name': 'strength', 'type': 'number', 'default': 0.7 },
+            { 'name': 'iterations', 'type': 'number', 'default': 1 }
+          ]
+        },
+        {
+          'key': {'force': 'nbody'},
+          'params': [
+            { 'name': 'strength', 'type': 'number', 'default': -30 },
+            { 'name': 'theta', 'type': 'number', 'default': 0.9 },
+            { 'name': 'distanceMin', 'type': 'number', 'default': 1 },
+            { 'name': 'distanceMax', 'type': 'number' }
+          ]
+        },
+        {
+          'key': {'force': 'link'},
+          'params': [
+            { 'name': 'links', 'type': 'data' },
+            { 'name': 'id', 'type': 'field' },
+            { 'name': 'distance', 'type': 'number', 'default': 30, 'expr': true },
+            { 'name': 'strength', 'type': 'number', 'expr': true },
+            { 'name': 'iterations', 'type': 'number', 'default': 1 }
+          ]
+        },
+        {
+          'key': {'force': 'x'},
+          'params': [
+            { 'name': 'strength', 'type': 'number', 'default': 0.1 },
+            { 'name': 'x', 'type': 'field' }
+          ]
+        },
+        {
+          'key': {'force': 'y'},
+          'params': [
+            { 'name': 'strength', 'type': 'number', 'default': 0.1 },
+            { 'name': 'y', 'type': 'field' }
+          ]
+        }
+      ] },
+    {
+      'name': 'as', 'type': 'string', 'array': true, 'modify': false,
+      'default': ForceOutput
+    }
+  ]
+};
+
+var prototype = inherits(Force, Transform);
+
+prototype.transform = function(_, pulse) {
+  var sim = this.value,
+      change = pulse.changed(pulse.ADD_REM),
+      params = _.modified(ForceParams),
+      iters = _.iterations || 300;
+
+  // configure simulation
+  if (!sim) {
+    this.value = sim = simulation(pulse.source, _);
+    sim.on('tick', rerun(pulse.dataflow, this));
+    if (!_.static) {
+      change = true;
+      sim.tick(); // ensure we run on init
+    }
+    pulse.modifies('index');
+  } else {
+    if (change) {
+      pulse.modifies('index');
+      sim.nodes(pulse.source);
+    }
+    if (params || pulse.changed(pulse.MOD)) {
+      setup(sim, _, 0, pulse);
+    }
+  }
+
+  // run simulation
+  if (params || change || _.modified(ForceConfig)
+      || (pulse.changed() && _.restart))
+  {
+    sim.alpha(Math.max(sim.alpha(), _.alpha || 1))
+       .alphaDecay(1 - Math.pow(sim.alphaMin(), 1 / iters));
+
+    if (_.static) {
+      for (sim.stop(); --iters >= 0;) sim.tick();
+    } else {
+      if (sim.stopped()) sim.restart();
+      if (!change) return pulse.StopPropagation; // defer to sim ticks
+    }
+  }
+
+  return this.finish(_, pulse);
+};
+
+prototype.finish = function(_, pulse) {
+  var dataflow = pulse.dataflow;
+
+  // inspect dependencies, touch link source data
+  for (var args=this._argops, j=0, m=args.length, arg; j<m; ++j) {
+    arg = args[j];
+    if (arg.name !== Forces || arg.op._argval.force !== 'link') {
+      continue;
+    }
+    for (var ops=arg.op._argops, i=0, n=ops.length, op; i<n; ++i) {
+      if (ops[i].name === 'links' && (op = ops[i].op.source)) {
+        dataflow.pulse(op, dataflow.changeset().reflow());
+        break;
+      }
+    }
+  }
+
+  // reflow all nodes
+  return pulse.reflow(_.modified()).modifies(ForceOutput);
+};
+
+function rerun(df, op) {
+  return function() { df.touch(op).run(); };
+}
+
+function simulation(nodes, _) {
+  var sim = forceSimulation(nodes),
+      stopped = false,
+      stop = sim.stop,
+      restart = sim.restart;
+
+  sim.stopped = function() {
+    return stopped;
+  };
+  sim.restart = function() {
+    stopped = false;
+    return restart();
+  };
+  sim.stop = function() {
+    stopped = true;
+    return stop();
+  };
+
+  return setup(sim, _, true).on('end', function() { stopped = true; });
+}
+
+function setup(sim, _, init, pulse) {
+  var f = array(_.forces), i, n, p, name;
+
+  for (i=0, n=ForceParams.length; i<n; ++i) {
+    p = ForceParams[i];
+    if (p !== Forces && _.modified(p)) sim[p](_[p]);
+  }
+
+  for (i=0, n=f.length; i<n; ++i) {
+    name = Forces + i;
+    p = init || _.modified(Forces, i) ? getForce(f[i])
+      : pulse && modified(f[i], pulse) ? sim.force(name)
+      : null;
+    if (p) sim.force(name, p);
+  }
+
+  for (n=(sim.numForces || 0); i<n; ++i) {
+    sim.force(Forces + i, null); // remove
+  }
+
+  sim.numForces = f.length;
+  return sim;
+}
+
+function modified(f, pulse) {
+  var k, v;
+  for (k in f) {
+    if (isFunction(v = f[k]) && pulse.modified(accessorFields(v)))
+      return 1;
+  }
+  return 0;
+}
+
+function getForce(_) {
+  var f, p;
+
+  if (!hasOwnProperty(ForceMap, _.force)) {
+    error('Unrecognized force: ' + _.force);
+  }
+  f = ForceMap[_.force]();
+
+  for (p in _) {
+    if (isFunction(f[p])) setForceParam(f[p], _[p], _);
+  }
+
+  return f;
+}
+
+function setForceParam(f, v, _) {
+  f(isFunction(v) ? function(d) { return v(d, _); } : v);
+}