Bar graph added.

node_modules/vega-wordcloud/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-wordcloud/README.md

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

node_modules/vega-wordcloud/build/vega-wordcloud.js

@@ -0,0 +1,544 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('vega-canvas'), require('vega-dataflow'), require('vega-util'), require('vega-scale'), require('vega-statistics')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'vega-canvas', 'vega-dataflow', 'vega-util', 'vega-scale', 'vega-statistics'], factory) :
+  (global = global || self, factory((global.vega = global.vega || {}, global.vega.transforms = {}), global.vega, global.vega, global.vega, global.vega, global.vega));
+}(this, (function (exports, vegaCanvas, vegaDataflow, vegaUtil, vegaScale, vegaStatistics) { 'use strict';
+
+  /*
+  Copyright (c) 2013, Jason Davies.
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice, this
+      list of conditions and the following disclaimer.
+
+    * 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.
+
+    * The name Jason Davies may not 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 JASON DAVIES 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.
+  */
+
+  // Word cloud layout by Jason Davies, https://www.jasondavies.com/wordcloud/
+  // Algorithm due to Jonathan Feinberg, http://static.mrfeinberg.com/bv_ch03.pdf
+
+  var cloudRadians = Math.PI / 180,
+      cw = 1 << 11 >> 5,
+      ch = 1 << 11;
+
+  function cloud() {
+    var size = [256, 256],
+        text,
+        font,
+        fontSize,
+        fontStyle,
+        fontWeight,
+        rotate,
+        padding,
+        spiral = archimedeanSpiral,
+        words = [],
+        random = Math.random,
+        cloud = {};
+
+    cloud.layout = function() {
+      var contextAndRatio = getContext(vegaCanvas.canvas()),
+          board = zeroArray((size[0] >> 5) * size[1]),
+          bounds = null,
+          n = words.length,
+          i = -1,
+          tags = [],
+          data = words.map(function(d) {
+            return {
+              text: text(d),
+              font: font(d),
+              style: fontStyle(d),
+              weight: fontWeight(d),
+              rotate: rotate(d),
+              size: ~~(fontSize(d) + 1e-14),
+              padding: padding(d),
+              xoff: 0,
+              yoff: 0,
+              x1: 0,
+              y1: 0,
+              x0: 0,
+              y0: 0,
+              hasText: false,
+              sprite: null,
+              datum: d
+            };
+          }).sort(function(a, b) { return b.size - a.size; });
+
+      while (++i < n) {
+        var d = data[i];
+        d.x = (size[0] * (random() + .5)) >> 1;
+        d.y = (size[1] * (random() + .5)) >> 1;
+        cloudSprite(contextAndRatio, d, data, i);
+        if (d.hasText && place(board, d, bounds)) {
+          tags.push(d);
+          if (bounds) cloudBounds(bounds, d);
+          else bounds = [{x: d.x + d.x0, y: d.y + d.y0}, {x: d.x + d.x1, y: d.y + d.y1}];
+          // Temporary hack
+          d.x -= size[0] >> 1;
+          d.y -= size[1] >> 1;
+        }
+      }
+
+      return tags;
+    };
+
+    function getContext(canvas) {
+      canvas.width = canvas.height = 1;
+      var ratio = Math.sqrt(canvas.getContext('2d').getImageData(0, 0, 1, 1).data.length >> 2);
+      canvas.width = (cw << 5) / ratio;
+      canvas.height = ch / ratio;
+
+      var context = canvas.getContext('2d');
+      context.fillStyle = context.strokeStyle = 'red';
+      context.textAlign = 'center';
+
+      return {context: context, ratio: ratio};
+    }
+
+    function place(board, tag, bounds) {
+      var startX = tag.x,
+          startY = tag.y,
+          maxDelta = Math.sqrt(size[0] * size[0] + size[1] * size[1]),
+          s = spiral(size),
+          dt = random() < .5 ? 1 : -1,
+          t = -dt,
+          dxdy,
+          dx,
+          dy;
+
+      while (dxdy = s(t += dt)) {
+        dx = ~~dxdy[0];
+        dy = ~~dxdy[1];
+
+        if (Math.min(Math.abs(dx), Math.abs(dy)) >= maxDelta) break;
+
+        tag.x = startX + dx;
+        tag.y = startY + dy;
+
+        if (tag.x + tag.x0 < 0 || tag.y + tag.y0 < 0 ||
+            tag.x + tag.x1 > size[0] || tag.y + tag.y1 > size[1]) continue;
+        // TODO only check for collisions within current bounds.
+        if (!bounds || !cloudCollide(tag, board, size[0])) {
+          if (!bounds || collideRects(tag, bounds)) {
+            var sprite = tag.sprite,
+                w = tag.width >> 5,
+                sw = size[0] >> 5,
+                lx = tag.x - (w << 4),
+                sx = lx & 0x7f,
+                msx = 32 - sx,
+                h = tag.y1 - tag.y0,
+                x = (tag.y + tag.y0) * sw + (lx >> 5),
+                last;
+            for (var j = 0; j < h; j++) {
+              last = 0;
+              for (var i = 0; i <= w; i++) {
+                board[x + i] |= (last << msx) | (i < w ? (last = sprite[j * w + i]) >>> sx : 0);
+              }
+              x += sw;
+            }
+            tag.sprite = null;
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+
+    cloud.words = function(_) {
+      if (arguments.length) {
+        words = _;
+        return cloud;
+      } else {
+        return words;
+      }
+    };
+
+    cloud.size = function(_) {
+      if (arguments.length) {
+        size = [+_[0], +_[1]];
+        return cloud;
+      } else {
+        return size;
+      }
+    };
+
+    cloud.font = function(_) {
+      if (arguments.length) {
+        font = functor(_);
+        return cloud;
+      } else {
+        return font;
+      }
+    };
+
+    cloud.fontStyle = function(_) {
+      if (arguments.length) {
+        fontStyle = functor(_);
+        return cloud;
+      } else {
+        return fontStyle;
+      }
+    };
+
+    cloud.fontWeight = function(_) {
+      if (arguments.length) {
+        fontWeight = functor(_);
+        return cloud;
+      } else {
+        return fontWeight;
+      }
+    };
+
+    cloud.rotate = function(_) {
+      if (arguments.length) {
+        rotate = functor(_);
+        return cloud;
+      } else {
+        return rotate;
+      }
+    };
+
+    cloud.text = function(_) {
+      if (arguments.length) {
+        text = functor(_);
+        return cloud;
+      } else {
+        return text;
+      }
+    };
+
+    cloud.spiral = function(_) {
+      if (arguments.length) {
+        spiral = spirals[_] || _;
+        return cloud;
+      } else {
+        return spiral;
+      }
+    };
+
+    cloud.fontSize = function(_) {
+      if (arguments.length) {
+        fontSize = functor(_);
+        return cloud;
+      } else {
+        return fontSize;
+      }
+    };
+
+    cloud.padding = function(_) {
+      if (arguments.length) {
+        padding = functor(_);
+        return cloud;
+      } else {
+        return padding;
+      }
+    };
+
+    cloud.random = function(_) {
+      if (arguments.length) {
+        random = _;
+        return cloud;
+      } else {
+        return random;
+      }
+    };
+
+    return cloud;
+  }
+
+  // Fetches a monochrome sprite bitmap for the specified text.
+  // Load in batches for speed.
+  function cloudSprite(contextAndRatio, d, data, di) {
+    if (d.sprite) return;
+    var c = contextAndRatio.context,
+        ratio = contextAndRatio.ratio;
+
+    c.clearRect(0, 0, (cw << 5) / ratio, ch / ratio);
+    var x = 0,
+        y = 0,
+        maxh = 0,
+        n = data.length,
+        w, w32, h, i, j;
+    --di;
+    while (++di < n) {
+      d = data[di];
+      c.save();
+      c.font = d.style + ' ' + d.weight + ' ' + ~~((d.size + 1) / ratio) + 'px ' + d.font;
+      w = c.measureText(d.text + 'm').width * ratio;
+      h = d.size << 1;
+      if (d.rotate) {
+        var sr = Math.sin(d.rotate * cloudRadians),
+            cr = Math.cos(d.rotate * cloudRadians),
+            wcr = w * cr,
+            wsr = w * sr,
+            hcr = h * cr,
+            hsr = h * sr;
+        w = (Math.max(Math.abs(wcr + hsr), Math.abs(wcr - hsr)) + 0x1f) >> 5 << 5;
+        h = ~~Math.max(Math.abs(wsr + hcr), Math.abs(wsr - hcr));
+      } else {
+        w = (w + 0x1f) >> 5 << 5;
+      }
+      if (h > maxh) maxh = h;
+      if (x + w >= (cw << 5)) {
+        x = 0;
+        y += maxh;
+        maxh = 0;
+      }
+      if (y + h >= ch) break;
+      c.translate((x + (w >> 1)) / ratio, (y + (h >> 1)) / ratio);
+      if (d.rotate) c.rotate(d.rotate * cloudRadians);
+      c.fillText(d.text, 0, 0);
+      if (d.padding) {
+        c.lineWidth = 2 * d.padding;
+        c.strokeText(d.text, 0, 0);
+      }
+      c.restore();
+      d.width = w;
+      d.height = h;
+      d.xoff = x;
+      d.yoff = y;
+      d.x1 = w >> 1;
+      d.y1 = h >> 1;
+      d.x0 = -d.x1;
+      d.y0 = -d.y1;
+      d.hasText = true;
+      x += w;
+    }
+    var pixels = c.getImageData(0, 0, (cw << 5) / ratio, ch / ratio).data,
+        sprite = [];
+    while (--di >= 0) {
+      d = data[di];
+      if (!d.hasText) continue;
+      w = d.width;
+      w32 = w >> 5;
+      h = d.y1 - d.y0;
+      // Zero the buffer
+      for (i = 0; i < h * w32; i++) sprite[i] = 0;
+      x = d.xoff;
+      if (x == null) return;
+      y = d.yoff;
+      var seen = 0,
+          seenRow = -1;
+      for (j = 0; j < h; j++) {
+        for (i = 0; i < w; i++) {
+          var k = w32 * j + (i >> 5),
+              m = pixels[((y + j) * (cw << 5) + (x + i)) << 2] ? 1 << (31 - (i % 32)) : 0;
+          sprite[k] |= m;
+          seen |= m;
+        }
+        if (seen) seenRow = j;
+        else {
+          d.y0++;
+          h--;
+          j--;
+          y++;
+        }
+      }
+      d.y1 = d.y0 + seenRow;
+      d.sprite = sprite.slice(0, (d.y1 - d.y0) * w32);
+    }
+  }
+
+  // Use mask-based collision detection.
+  function cloudCollide(tag, board, sw) {
+    sw >>= 5;
+    var sprite = tag.sprite,
+        w = tag.width >> 5,
+        lx = tag.x - (w << 4),
+        sx = lx & 0x7f,
+        msx = 32 - sx,
+        h = tag.y1 - tag.y0,
+        x = (tag.y + tag.y0) * sw + (lx >> 5),
+        last;
+    for (var j = 0; j < h; j++) {
+      last = 0;
+      for (var i = 0; i <= w; i++) {
+        if (((last << msx) | (i < w ? (last = sprite[j * w + i]) >>> sx : 0))
+            & board[x + i]) return true;
+      }
+      x += sw;
+    }
+    return false;
+  }
+
+  function cloudBounds(bounds, d) {
+    var b0 = bounds[0],
+        b1 = bounds[1];
+    if (d.x + d.x0 < b0.x) b0.x = d.x + d.x0;
+    if (d.y + d.y0 < b0.y) b0.y = d.y + d.y0;
+    if (d.x + d.x1 > b1.x) b1.x = d.x + d.x1;
+    if (d.y + d.y1 > b1.y) b1.y = d.y + d.y1;
+  }
+
+  function collideRects(a, b) {
+    return a.x + a.x1 > b[0].x && a.x + a.x0 < b[1].x && a.y + a.y1 > b[0].y && a.y + a.y0 < b[1].y;
+  }
+
+  function archimedeanSpiral(size) {
+    var e = size[0] / size[1];
+    return function(t) {
+      return [e * (t *= .1) * Math.cos(t), t * Math.sin(t)];
+    };
+  }
+
+  function rectangularSpiral(size) {
+    var dy = 4,
+        dx = dy * size[0] / size[1],
+        x = 0,
+        y = 0;
+    return function(t) {
+      var sign = t < 0 ? -1 : 1;
+      // See triangular numbers: T_n = n * (n + 1) / 2.
+      switch ((Math.sqrt(1 + 4 * sign * t) - sign) & 3) {
+        case 0:  x += dx; break;
+        case 1:  y += dy; break;
+        case 2:  x -= dx; break;
+        default: y -= dy; break;
+      }
+      return [x, y];
+    };
+  }
+
+  // TODO reuse arrays?
+  function zeroArray(n) {
+    var a = [],
+        i = -1;
+    while (++i < n) a[i] = 0;
+    return a;
+  }
+
+  function functor(d) {
+    return typeof d === 'function' ? d : function() { return d; };
+  }
+
+  var spirals = {
+    archimedean: archimedeanSpiral,
+    rectangular: rectangularSpiral
+  };
+
+  var Output = ['x', 'y', 'font', 'fontSize', 'fontStyle', 'fontWeight', 'angle'];
+
+  var Params = ['text', 'font', 'rotate', 'fontSize', 'fontStyle', 'fontWeight'];
+
+  function Wordcloud(params) {
+    vegaDataflow.Transform.call(this, cloud(), params);
+  }
+
+  Wordcloud.Definition = {
+    'type': 'Wordcloud',
+    'metadata': {'modifies': true},
+    'params': [
+      { 'name': 'size', 'type': 'number', 'array': true, 'length': 2 },
+      { 'name': 'font', 'type': 'string', 'expr': true, 'default': 'sans-serif' },
+      { 'name': 'fontStyle', 'type': 'string', 'expr': true, 'default': 'normal' },
+      { 'name': 'fontWeight', 'type': 'string', 'expr': true, 'default': 'normal' },
+      { 'name': 'fontSize', 'type': 'number', 'expr': true, 'default': 14 },
+      { 'name': 'fontSizeRange', 'type': 'number', 'array': 'nullable', 'default': [10, 50] },
+      { 'name': 'rotate', 'type': 'number', 'expr': true, 'default': 0 },
+      { 'name': 'text', 'type': 'field' },
+      { 'name': 'spiral', 'type': 'string', 'values': ['archimedean', 'rectangular'] },
+      { 'name': 'padding', 'type': 'number', 'expr': true },
+      { 'name': 'as', 'type': 'string', 'array': true, 'length': 7, 'default': Output }
+    ]
+  };
+
+  var prototype = vegaUtil.inherits(Wordcloud, vegaDataflow.Transform);
+
+  prototype.transform = function(_, pulse) {
+    if (_.size && !(_.size[0] && _.size[1])) {
+      vegaUtil.error('Wordcloud size dimensions must be non-zero.');
+    }
+
+    function modp(param) {
+      var p = _[param];
+      return vegaUtil.isFunction(p) && pulse.modified(p.fields);
+    }
+
+    var mod = _.modified();
+    if (!(mod || pulse.changed(pulse.ADD_REM) || Params.some(modp))) return;
+
+    var data = pulse.materialize(pulse.SOURCE).source,
+        layout = this.value,
+        as = _.as || Output,
+        fontSize = _.fontSize || 14,
+        range;
+
+    vegaUtil.isFunction(fontSize)
+      ? (range = _.fontSizeRange)
+      : (fontSize = vegaUtil.constant(fontSize));
+
+    // create font size scaling function as needed
+    if (range) {
+      var fsize = fontSize,
+          sizeScale = vegaScale.scale('sqrt')()
+            .domain(vegaUtil.extent(data, fsize))
+            .range(range);
+      fontSize = function(x) { return sizeScale(fsize(x)); };
+    }
+
+    data.forEach(function(t) {
+      t[as[0]] = NaN;
+      t[as[1]] = NaN;
+      t[as[3]] = 0;
+    });
+
+    // configure layout
+    var words = layout
+      .words(data)
+      .text(_.text)
+      .size(_.size || [500, 500])
+      .padding(_.padding || 1)
+      .spiral(_.spiral || 'archimedean')
+      .rotate(_.rotate || 0)
+      .font(_.font || 'sans-serif')
+      .fontStyle(_.fontStyle || 'normal')
+      .fontWeight(_.fontWeight || 'normal')
+      .fontSize(fontSize)
+      .random(vegaStatistics.random)
+      .layout();
+
+    var size = layout.size(),
+        dx = size[0] >> 1,
+        dy = size[1] >> 1,
+        i = 0,
+        n = words.length,
+        w, t;
+
+    for (; i<n; ++i) {
+      w = words[i];
+      t = w.datum;
+      t[as[0]] = w.x + dx;
+      t[as[1]] = w.y + dy;
+      t[as[2]] = w.font;
+      t[as[3]] = w.size;
+      t[as[4]] = w.style;
+      t[as[5]] = w.weight;
+      t[as[6]] = w.rotate;
+    }
+
+    return pulse.reflow(mod).modifies(as);
+  };
+
+  exports.wordcloud = Wordcloud;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+})));

node_modules/vega-wordcloud/index.js

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

node_modules/vega-wordcloud/package.json

@@ -0,0 +1,71 @@
+{
+  "_from": "vega-wordcloud@~4.1.0",
+  "_id": "vega-wordcloud@4.1.0",
+  "_inBundle": false,
+  "_integrity": "sha512-WiISiNlHdbTL6QsnxyzxbniUgcPmjzwdwZzu6clQSHXNRz9kThCPhXOyLwYdbFV+9sjd4sJlW0YOaCcx7wMT2Q==",
+  "_location": "/vega-wordcloud",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "vega-wordcloud@~4.1.0",
+    "name": "vega-wordcloud",
+    "escapedName": "vega-wordcloud",
+    "rawSpec": "~4.1.0",
+    "saveSpec": null,
+    "fetchSpec": "~4.1.0"
+  },
+  "_requiredBy": [
+    "/vega"
+  ],
+  "_resolved": "https://registry.npmjs.org/vega-wordcloud/-/vega-wordcloud-4.1.0.tgz",
+  "_shasum": "edf020a99378eb88109cb9ac4702fec0e0ac8cdd",
+  "_spec": "vega-wordcloud@~4.1.0",
+  "_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": {
+    "vega-canvas": "^1.2.2",
+    "vega-dataflow": "^5.6.0",
+    "vega-scale": "^7.0.0",
+    "vega-statistics": "^1.7.5",
+    "vega-util": "^1.14.0"
+  },
+  "deprecated": false,
+  "description": "Wordcloud layout transform for Vega dataflows.",
+  "devDependencies": {
+    "vega-transforms": "*"
+  },
+  "gitHead": "48c85218f2202242171aa569f2dca0f53cf2b51f",
+  "homepage": "https://github.com/vega/vega#readme",
+  "keywords": [
+    "vega",
+    "wordcloud",
+    "layout"
+  ],
+  "license": "BSD-3-Clause",
+  "main": "build/vega-wordcloud.js",
+  "module": "index",
+  "name": "vega-wordcloud",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vega/vega.git"
+  },
+  "scripts": {
+    "build": "yarn rollup",
+    "postbuild": "terser build/vega-wordcloud.js -c -m -o build/vega-wordcloud.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 vega-canvas:vega,vega-dataflow:vega,vega-scale:vega,vega-statistics:vega,vega-util:vega -f umd -n vega.transforms -o build/vega-wordcloud.js -- index.js",
+    "test": "tape 'test/**/*-test.js'"
+  },
+  "version": "4.1.0"
+}

node_modules/vega-wordcloud/src/CloudLayout.js

@@ -0,0 +1,431 @@
+import {canvas} from 'vega-canvas';
+
+/*
+Copyright (c) 2013, Jason Davies.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice, this
+    list of conditions and the following disclaimer.
+
+  * 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.
+
+  * The name Jason Davies may not 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 JASON DAVIES 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.
+*/
+
+// Word cloud layout by Jason Davies, https://www.jasondavies.com/wordcloud/
+// Algorithm due to Jonathan Feinberg, http://static.mrfeinberg.com/bv_ch03.pdf
+
+var cloudRadians = Math.PI / 180,
+    cw = 1 << 11 >> 5,
+    ch = 1 << 11;
+
+export default function() {
+  var size = [256, 256],
+      text,
+      font,
+      fontSize,
+      fontStyle,
+      fontWeight,
+      rotate,
+      padding,
+      spiral = archimedeanSpiral,
+      words = [],
+      random = Math.random,
+      cloud = {};
+
+  cloud.layout = function() {
+    var contextAndRatio = getContext(canvas()),
+        board = zeroArray((size[0] >> 5) * size[1]),
+        bounds = null,
+        n = words.length,
+        i = -1,
+        tags = [],
+        data = words.map(function(d) {
+          return {
+            text: text(d),
+            font: font(d),
+            style: fontStyle(d),
+            weight: fontWeight(d),
+            rotate: rotate(d),
+            size: ~~(fontSize(d) + 1e-14),
+            padding: padding(d),
+            xoff: 0,
+            yoff: 0,
+            x1: 0,
+            y1: 0,
+            x0: 0,
+            y0: 0,
+            hasText: false,
+            sprite: null,
+            datum: d
+          };
+        }).sort(function(a, b) { return b.size - a.size; });
+
+    while (++i < n) {
+      var d = data[i];
+      d.x = (size[0] * (random() + .5)) >> 1;
+      d.y = (size[1] * (random() + .5)) >> 1;
+      cloudSprite(contextAndRatio, d, data, i);
+      if (d.hasText && place(board, d, bounds)) {
+        tags.push(d);
+        if (bounds) cloudBounds(bounds, d);
+        else bounds = [{x: d.x + d.x0, y: d.y + d.y0}, {x: d.x + d.x1, y: d.y + d.y1}];
+        // Temporary hack
+        d.x -= size[0] >> 1;
+        d.y -= size[1] >> 1;
+      }
+    }
+
+    return tags;
+  };
+
+  function getContext(canvas) {
+    canvas.width = canvas.height = 1;
+    var ratio = Math.sqrt(canvas.getContext('2d').getImageData(0, 0, 1, 1).data.length >> 2);
+    canvas.width = (cw << 5) / ratio;
+    canvas.height = ch / ratio;
+
+    var context = canvas.getContext('2d');
+    context.fillStyle = context.strokeStyle = 'red';
+    context.textAlign = 'center';
+
+    return {context: context, ratio: ratio};
+  }
+
+  function place(board, tag, bounds) {
+    var startX = tag.x,
+        startY = tag.y,
+        maxDelta = Math.sqrt(size[0] * size[0] + size[1] * size[1]),
+        s = spiral(size),
+        dt = random() < .5 ? 1 : -1,
+        t = -dt,
+        dxdy,
+        dx,
+        dy;
+
+    while (dxdy = s(t += dt)) {
+      dx = ~~dxdy[0];
+      dy = ~~dxdy[1];
+
+      if (Math.min(Math.abs(dx), Math.abs(dy)) >= maxDelta) break;
+
+      tag.x = startX + dx;
+      tag.y = startY + dy;
+
+      if (tag.x + tag.x0 < 0 || tag.y + tag.y0 < 0 ||
+          tag.x + tag.x1 > size[0] || tag.y + tag.y1 > size[1]) continue;
+      // TODO only check for collisions within current bounds.
+      if (!bounds || !cloudCollide(tag, board, size[0])) {
+        if (!bounds || collideRects(tag, bounds)) {
+          var sprite = tag.sprite,
+              w = tag.width >> 5,
+              sw = size[0] >> 5,
+              lx = tag.x - (w << 4),
+              sx = lx & 0x7f,
+              msx = 32 - sx,
+              h = tag.y1 - tag.y0,
+              x = (tag.y + tag.y0) * sw + (lx >> 5),
+              last;
+          for (var j = 0; j < h; j++) {
+            last = 0;
+            for (var i = 0; i <= w; i++) {
+              board[x + i] |= (last << msx) | (i < w ? (last = sprite[j * w + i]) >>> sx : 0);
+            }
+            x += sw;
+          }
+          tag.sprite = null;
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  cloud.words = function(_) {
+    if (arguments.length) {
+      words = _;
+      return cloud;
+    } else {
+      return words;
+    }
+  };
+
+  cloud.size = function(_) {
+    if (arguments.length) {
+      size = [+_[0], +_[1]];
+      return cloud;
+    } else {
+      return size;
+    }
+  };
+
+  cloud.font = function(_) {
+    if (arguments.length) {
+      font = functor(_);
+      return cloud;
+    } else {
+      return font;
+    }
+  };
+
+  cloud.fontStyle = function(_) {
+    if (arguments.length) {
+      fontStyle = functor(_);
+      return cloud;
+    } else {
+      return fontStyle;
+    }
+  };
+
+  cloud.fontWeight = function(_) {
+    if (arguments.length) {
+      fontWeight = functor(_);
+      return cloud;
+    } else {
+      return fontWeight;
+    }
+  };
+
+  cloud.rotate = function(_) {
+    if (arguments.length) {
+      rotate = functor(_);
+      return cloud;
+    } else {
+      return rotate;
+    }
+  };
+
+  cloud.text = function(_) {
+    if (arguments.length) {
+      text = functor(_);
+      return cloud;
+    } else {
+      return text;
+    }
+  };
+
+  cloud.spiral = function(_) {
+    if (arguments.length) {
+      spiral = spirals[_] || _;
+      return cloud;
+    } else {
+      return spiral;
+    }
+  };
+
+  cloud.fontSize = function(_) {
+    if (arguments.length) {
+      fontSize = functor(_);
+      return cloud;
+    } else {
+      return fontSize;
+    }
+  };
+
+  cloud.padding = function(_) {
+    if (arguments.length) {
+      padding = functor(_);
+      return cloud;
+    } else {
+      return padding;
+    }
+  };
+
+  cloud.random = function(_) {
+    if (arguments.length) {
+      random = _;
+      return cloud;
+    } else {
+      return random;
+    }
+  };
+
+  return cloud;
+}
+
+// Fetches a monochrome sprite bitmap for the specified text.
+// Load in batches for speed.
+function cloudSprite(contextAndRatio, d, data, di) {
+  if (d.sprite) return;
+  var c = contextAndRatio.context,
+      ratio = contextAndRatio.ratio;
+
+  c.clearRect(0, 0, (cw << 5) / ratio, ch / ratio);
+  var x = 0,
+      y = 0,
+      maxh = 0,
+      n = data.length,
+      w, w32, h, i, j;
+  --di;
+  while (++di < n) {
+    d = data[di];
+    c.save();
+    c.font = d.style + ' ' + d.weight + ' ' + ~~((d.size + 1) / ratio) + 'px ' + d.font;
+    w = c.measureText(d.text + 'm').width * ratio;
+    h = d.size << 1;
+    if (d.rotate) {
+      var sr = Math.sin(d.rotate * cloudRadians),
+          cr = Math.cos(d.rotate * cloudRadians),
+          wcr = w * cr,
+          wsr = w * sr,
+          hcr = h * cr,
+          hsr = h * sr;
+      w = (Math.max(Math.abs(wcr + hsr), Math.abs(wcr - hsr)) + 0x1f) >> 5 << 5;
+      h = ~~Math.max(Math.abs(wsr + hcr), Math.abs(wsr - hcr));
+    } else {
+      w = (w + 0x1f) >> 5 << 5;
+    }
+    if (h > maxh) maxh = h;
+    if (x + w >= (cw << 5)) {
+      x = 0;
+      y += maxh;
+      maxh = 0;
+    }
+    if (y + h >= ch) break;
+    c.translate((x + (w >> 1)) / ratio, (y + (h >> 1)) / ratio);
+    if (d.rotate) c.rotate(d.rotate * cloudRadians);
+    c.fillText(d.text, 0, 0);
+    if (d.padding) {
+      c.lineWidth = 2 * d.padding;
+      c.strokeText(d.text, 0, 0);
+    }
+    c.restore();
+    d.width = w;
+    d.height = h;
+    d.xoff = x;
+    d.yoff = y;
+    d.x1 = w >> 1;
+    d.y1 = h >> 1;
+    d.x0 = -d.x1;
+    d.y0 = -d.y1;
+    d.hasText = true;
+    x += w;
+  }
+  var pixels = c.getImageData(0, 0, (cw << 5) / ratio, ch / ratio).data,
+      sprite = [];
+  while (--di >= 0) {
+    d = data[di];
+    if (!d.hasText) continue;
+    w = d.width;
+    w32 = w >> 5;
+    h = d.y1 - d.y0;
+    // Zero the buffer
+    for (i = 0; i < h * w32; i++) sprite[i] = 0;
+    x = d.xoff;
+    if (x == null) return;
+    y = d.yoff;
+    var seen = 0,
+        seenRow = -1;
+    for (j = 0; j < h; j++) {
+      for (i = 0; i < w; i++) {
+        var k = w32 * j + (i >> 5),
+            m = pixels[((y + j) * (cw << 5) + (x + i)) << 2] ? 1 << (31 - (i % 32)) : 0;
+        sprite[k] |= m;
+        seen |= m;
+      }
+      if (seen) seenRow = j;
+      else {
+        d.y0++;
+        h--;
+        j--;
+        y++;
+      }
+    }
+    d.y1 = d.y0 + seenRow;
+    d.sprite = sprite.slice(0, (d.y1 - d.y0) * w32);
+  }
+}
+
+// Use mask-based collision detection.
+function cloudCollide(tag, board, sw) {
+  sw >>= 5;
+  var sprite = tag.sprite,
+      w = tag.width >> 5,
+      lx = tag.x - (w << 4),
+      sx = lx & 0x7f,
+      msx = 32 - sx,
+      h = tag.y1 - tag.y0,
+      x = (tag.y + tag.y0) * sw + (lx >> 5),
+      last;
+  for (var j = 0; j < h; j++) {
+    last = 0;
+    for (var i = 0; i <= w; i++) {
+      if (((last << msx) | (i < w ? (last = sprite[j * w + i]) >>> sx : 0))
+          & board[x + i]) return true;
+    }
+    x += sw;
+  }
+  return false;
+}
+
+function cloudBounds(bounds, d) {
+  var b0 = bounds[0],
+      b1 = bounds[1];
+  if (d.x + d.x0 < b0.x) b0.x = d.x + d.x0;
+  if (d.y + d.y0 < b0.y) b0.y = d.y + d.y0;
+  if (d.x + d.x1 > b1.x) b1.x = d.x + d.x1;
+  if (d.y + d.y1 > b1.y) b1.y = d.y + d.y1;
+}
+
+function collideRects(a, b) {
+  return a.x + a.x1 > b[0].x && a.x + a.x0 < b[1].x && a.y + a.y1 > b[0].y && a.y + a.y0 < b[1].y;
+}
+
+function archimedeanSpiral(size) {
+  var e = size[0] / size[1];
+  return function(t) {
+    return [e * (t *= .1) * Math.cos(t), t * Math.sin(t)];
+  };
+}
+
+function rectangularSpiral(size) {
+  var dy = 4,
+      dx = dy * size[0] / size[1],
+      x = 0,
+      y = 0;
+  return function(t) {
+    var sign = t < 0 ? -1 : 1;
+    // See triangular numbers: T_n = n * (n + 1) / 2.
+    switch ((Math.sqrt(1 + 4 * sign * t) - sign) & 3) {
+      case 0:  x += dx; break;
+      case 1:  y += dy; break;
+      case 2:  x -= dx; break;
+      default: y -= dy; break;
+    }
+    return [x, y];
+  };
+}
+
+// TODO reuse arrays?
+function zeroArray(n) {
+  var a = [],
+      i = -1;
+  while (++i < n) a[i] = 0;
+  return a;
+}
+
+function functor(d) {
+  return typeof d === 'function' ? d : function() { return d; };
+}
+
+var spirals = {
+  archimedean: archimedeanSpiral,
+  rectangular: rectangularSpiral
+};

node_modules/vega-wordcloud/src/Wordcloud.js

@@ -0,0 +1,108 @@
+import cloud from './CloudLayout';
+import {Transform} from 'vega-dataflow';
+import {constant, error, extent, inherits, isFunction} from 'vega-util';
+import {scale} from 'vega-scale';
+import {random} from 'vega-statistics';
+
+var Output = ['x', 'y', 'font', 'fontSize', 'fontStyle', 'fontWeight', 'angle'];
+
+var Params = ['text', 'font', 'rotate', 'fontSize', 'fontStyle', 'fontWeight'];
+
+export default function Wordcloud(params) {
+  Transform.call(this, cloud(), params);
+}
+
+Wordcloud.Definition = {
+  'type': 'Wordcloud',
+  'metadata': {'modifies': true},
+  'params': [
+    { 'name': 'size', 'type': 'number', 'array': true, 'length': 2 },
+    { 'name': 'font', 'type': 'string', 'expr': true, 'default': 'sans-serif' },
+    { 'name': 'fontStyle', 'type': 'string', 'expr': true, 'default': 'normal' },
+    { 'name': 'fontWeight', 'type': 'string', 'expr': true, 'default': 'normal' },
+    { 'name': 'fontSize', 'type': 'number', 'expr': true, 'default': 14 },
+    { 'name': 'fontSizeRange', 'type': 'number', 'array': 'nullable', 'default': [10, 50] },
+    { 'name': 'rotate', 'type': 'number', 'expr': true, 'default': 0 },
+    { 'name': 'text', 'type': 'field' },
+    { 'name': 'spiral', 'type': 'string', 'values': ['archimedean', 'rectangular'] },
+    { 'name': 'padding', 'type': 'number', 'expr': true },
+    { 'name': 'as', 'type': 'string', 'array': true, 'length': 7, 'default': Output }
+  ]
+};
+
+var prototype = inherits(Wordcloud, Transform);
+
+prototype.transform = function(_, pulse) {
+  if (_.size && !(_.size[0] && _.size[1])) {
+    error('Wordcloud size dimensions must be non-zero.');
+  }
+
+  function modp(param) {
+    var p = _[param];
+    return isFunction(p) && pulse.modified(p.fields);
+  }
+
+  var mod = _.modified();
+  if (!(mod || pulse.changed(pulse.ADD_REM) || Params.some(modp))) return;
+
+  var data = pulse.materialize(pulse.SOURCE).source,
+      layout = this.value,
+      as = _.as || Output,
+      fontSize = _.fontSize || 14,
+      range;
+
+  isFunction(fontSize)
+    ? (range = _.fontSizeRange)
+    : (fontSize = constant(fontSize));
+
+  // create font size scaling function as needed
+  if (range) {
+    var fsize = fontSize,
+        sizeScale = scale('sqrt')()
+          .domain(extent(data, fsize))
+          .range(range);
+    fontSize = function(x) { return sizeScale(fsize(x)); };
+  }
+
+  data.forEach(function(t) {
+    t[as[0]] = NaN;
+    t[as[1]] = NaN;
+    t[as[3]] = 0;
+  });
+
+  // configure layout
+  var words = layout
+    .words(data)
+    .text(_.text)
+    .size(_.size || [500, 500])
+    .padding(_.padding || 1)
+    .spiral(_.spiral || 'archimedean')
+    .rotate(_.rotate || 0)
+    .font(_.font || 'sans-serif')
+    .fontStyle(_.fontStyle || 'normal')
+    .fontWeight(_.fontWeight || 'normal')
+    .fontSize(fontSize)
+    .random(random)
+    .layout();
+
+  var size = layout.size(),
+      dx = size[0] >> 1,
+      dy = size[1] >> 1,
+      i = 0,
+      n = words.length,
+      w, t;
+
+  for (; i<n; ++i) {
+    w = words[i];
+    t = w.datum;
+    t[as[0]] = w.x + dx;
+    t[as[1]] = w.y + dy;
+    t[as[2]] = w.font;
+    t[as[3]] = w.size;
+    t[as[4]] = w.style;
+    t[as[5]] = w.weight;
+    t[as[6]] = w.rotate;
+  }
+
+  return pulse.reflow(mod).modifies(as);
+};