comparison src/DML/VendorAssetsBundle/Resources/assets/vega/2.2.6/vega.js @ 0:493bcb69166c

added public content

+(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.vg = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+module.exports = {
+  version: '2.2.6',
+  dataflow: require('vega-dataflow'),
+  parse: require('./src/parse/'),
+  scene: {
+    Bounder: require('./src/scene/Bounder'),
+    Builder: require('./src/scene/Builder'),
+    Encoder: require('./src/scene/Encoder'),
+    GroupBuilder: require('./src/scene/GroupBuilder'),
+  },
+  transforms: require('./src/transforms'),
+  schema: require('./src/core/schema'),
+  config: require('./src/core/config'),
+  util:  require('datalib'),
+  debug: require('vega-logging').debug
+};
+},{"./src/core/config":88,"./src/core/schema":89,"./src/parse/":95,"./src/scene/Bounder":107,"./src/scene/Builder":108,"./src/scene/Encoder":109,"./src/scene/GroupBuilder":110,"./src/transforms":139,"datalib":24,"vega-dataflow":39,"vega-logging":45}],2:[function(require,module,exports){
+
+},{}],3:[function(require,module,exports){
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  factory((global.dsv = {}));
+}(this, function (exports) { 'use strict';
+
+  var dsv = function(delimiter) {
+    var reFormat = new RegExp("[\"" + delimiter + "\n]"),
+        delimiterCode = delimiter.charCodeAt(0);
+
+    function parse(text, f) {
+      var o;
+      return parseRows(text, function(row, i) {
+        if (o) return o(row, i - 1);
+        var a = new Function("d", "return {" + row.map(function(name, i) {
+          return JSON.stringify(name) + ": d[" + i + "]";
+        }).join(",") + "}");
+        o = f ? function(row, i) { return f(a(row), i); } : a;
+      });
+    }
+
+    function parseRows(text, f) {
+      var EOL = {}, // sentinel value for end-of-line
+          EOF = {}, // sentinel value for end-of-file
+          rows = [], // output rows
+          N = text.length,
+          I = 0, // current character index
+          n = 0, // the current line number
+          t, // the current token
+          eol; // is the current token followed by EOL?
+
+      function token() {
+        if (I >= N) return EOF; // special case: end of file
+        if (eol) return eol = false, EOL; // special case: end of line
+
+        // special case: quotes
+        var j = I;
+        if (text.charCodeAt(j) === 34) {
+          var i = j;
+          while (i++ < N) {
+            if (text.charCodeAt(i) === 34) {
+              if (text.charCodeAt(i + 1) !== 34) break;
+              ++i;
+            }
+          }
+          I = i + 2;
+          var c = text.charCodeAt(i + 1);
+          if (c === 13) {
+            eol = true;
+            if (text.charCodeAt(i + 2) === 10) ++I;
+          } else if (c === 10) {
+            eol = true;
+          }
+          return text.slice(j + 1, i).replace(/""/g, "\"");
+        }
+
+        // common case: find next delimiter or newline
+        while (I < N) {
+          var c = text.charCodeAt(I++), k = 1;
+          if (c === 10) eol = true; // \n
+          else if (c === 13) { eol = true; if (text.charCodeAt(I) === 10) ++I, ++k; } // \r|\r\n
+          else if (c !== delimiterCode) continue;
+          return text.slice(j, I - k);
+        }
+
+        // special case: last token before EOF
+        return text.slice(j);
+      }
+
+      while ((t = token()) !== EOF) {
+        var a = [];
+        while (t !== EOL && t !== EOF) {
+          a.push(t);
+          t = token();
+        }
+        if (f && (a = f(a, n++)) == null) continue;
+        rows.push(a);
+      }
+
+      return rows;
+    }
+
+    function format(rows) {
+      if (Array.isArray(rows[0])) return formatRows(rows); // deprecated; use formatRows
+      var fieldSet = Object.create(null), fields = [];
+
+      // Compute unique fields in order of discovery.
+      rows.forEach(function(row) {
+        for (var field in row) {
+          if (!((field += "") in fieldSet)) {
+            fields.push(fieldSet[field] = field);
+          }
+        }
+      });
+
+      return [fields.map(formatValue).join(delimiter)].concat(rows.map(function(row) {
+        return fields.map(function(field) {
+          return formatValue(row[field]);
+        }).join(delimiter);
+      })).join("\n");
+    }
+
+    function formatRows(rows) {
+      return rows.map(formatRow).join("\n");
+    }
+
+    function formatRow(row) {
+      return row.map(formatValue).join(delimiter);
+    }
+
+    function formatValue(text) {
+      return reFormat.test(text) ? "\"" + text.replace(/\"/g, "\"\"") + "\"" : text;
+    }
+
+    return {
+      parse: parse,
+      parseRows: parseRows,
+      format: format,
+      formatRows: formatRows
+    };
+  }
+
+  exports.csv = dsv(",");
+  exports.tsv = dsv("\t");
+
+  exports.dsv = dsv;
+
+}));
+},{}],4:[function(require,module,exports){
+if (typeof Map === "undefined") {
+  Map = function() { this.clear(); };
+  Map.prototype = {
+    set: function(k, v) { this._[k] = v; return this; },
+    get: function(k) { return this._[k]; },
+    has: function(k) { return k in this._; },
+    delete: function(k) { return k in this._ && delete this._[k]; },
+    clear: function() { this._ = Object.create(null); },
+    get size() { var n = 0; for (var k in this._) ++n; return n; },
+    forEach: function(c) { for (var k in this._) c(this._[k], k, this); }
+  };
+} else (function() {
+  var m = new Map;
+  if (m.set(0, 0) !== m) {
+    m = m.set;
+    Map.prototype.set = function() { m.apply(this, arguments); return this; };
+  }
+})();
+
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  factory((global.format = {}));
+}(this, function (exports) { 'use strict';
+
+  var zhCn = {
+    decimal: ".",
+    thousands: ",",
+    grouping: [3],
+    currency: ["¥", ""]
+  };
+
+  var ruRu = {
+    decimal: ",",
+    thousands: "\xa0",
+    grouping: [3],
+    currency: ["", "\xa0руб."]
+  };
+
+  var ptBr = {
+    decimal: ",",
+    thousands: ".",
+    grouping: [3],
+    currency: ["R$", ""]
+  };
+
+  var plPl = {
+    decimal: ",",
+    thousands: ".",
+    grouping: [3],
+    currency: ["", "zł"]
+  };
+
+  var nlNl = {
+    decimal: ",",
+    thousands: ".",
+    grouping: [3],
+    currency: ["€\xa0", ""]
+  };
+
+  var mkMk = {
+    decimal: ",",
+    thousands: ".",
+    grouping: [3],
+    currency: ["", "\xa0ден."]
+  };
+
+  var jaJp = {
+    decimal: ".",
+    thousands: ",",
+    grouping: [3],
+    currency: ["", "円"]
+  };
+
+  var itIt = {
+    decimal: ",",
+    thousands: ".",
+    grouping: [3],
+    currency: ["€", ""]
+  };
+
+  var heIl = {
+    decimal: ".",
+    thousands: ",",
+    grouping: [3],
+    currency: ["₪", ""]
+  };
+
+  var frFr = {
+    decimal: ",",
+    thousands: ".",
+    grouping: [3],
+    currency: ["", "\xa0€"]
+  };
+
+  var frCa = {
+    decimal: ",",
+    thousands: "\xa0",
+    grouping: [3],
+    currency: ["", "$"]
+  };
+
+  var fiFi = {
+    decimal: ",",
+    thousands: "\xa0",
+    grouping: [3],
+    currency: ["", "\xa0€"]
+  };
+
+  var esEs = {
+    decimal: ",",
+    thousands: ".",
+    grouping: [3],
+    currency: ["", "\xa0€"]
+  };
+
+  var enUs = {
+    decimal: ".",
+    thousands: ",",
+    grouping: [3],
+    currency: ["$", ""]
+  };
+
+  var enGb = {
+    decimal: ".",
+    thousands: ",",
+    grouping: [3],
+    currency: ["£", ""]
+  };
+
+  var enCa = {
+    decimal: ".",
+    thousands: ",",
+    grouping: [3],
+    currency: ["$", ""]
+  };
+
+  var deDe = {
+    decimal: ",",
+    thousands: ".",
+    grouping: [3],
+    currency: ["", "\xa0€"]
+  };
+
+  var caEs = {
+    decimal: ",",
+    thousands: ".",
+    grouping: [3],
+    currency: ["", "\xa0€"]
+  };
+
+
+  // Computes the decimal coefficient and exponent of the specified number x with
+  // significant digits p, where x is positive and p is in [1, 21] or undefined.
+  // For example, formatDecimal(1.23) returns ["123", 0].
+  function formatDecimal(x, p) {
+    if ((i = (x = p ? x.toExponential(p - 1) : x.toExponential()).indexOf("e")) < 0) return null; // NaN, ±Infinity
+    var i, coefficient = x.slice(0, i);
+
+    // The string returned by toExponential either has the form \d\.\d+e[-+]\d+
+    // (e.g., 1.2e+3) or the form \de[-+]\d+ (e.g., 1e+3).
+    return [
+      coefficient.length > 1 ? coefficient[0] + coefficient.slice(2) : coefficient,
+      +x.slice(i + 1)
+    ];
+  }
+
+  function exponent(x) {
+    return x = formatDecimal(Math.abs(x)), x ? x[1] : NaN;
+  }
+
+  var prefixExponent;
+
+  function formatPrefixAuto(x, p) {
+    var d = formatDecimal(x, p);
+    if (!d) return x + "";
+    var coefficient = d[0],
+        exponent = d[1],
+        i = exponent - (prefixExponent = Math.max(-8, Math.min(8, Math.floor(exponent / 3))) * 3) + 1,
+        n = coefficient.length;
+    return i === n ? coefficient
+        : i > n ? coefficient + new Array(i - n + 1).join("0")
+        : i > 0 ? coefficient.slice(0, i) + "." + coefficient.slice(i)
+        : "0." + new Array(1 - i).join("0") + formatDecimal(x, p + i - 1)[0]; // less than 1y!
+  }
+
+  function formatRounded(x, p) {
+    var d = formatDecimal(x, p);
+    if (!d) return x + "";
+    var coefficient = d[0],
+        exponent = d[1];
+    return exponent < 0 ? "0." + new Array(-exponent).join("0") + coefficient
+        : coefficient.length > exponent + 1 ? coefficient.slice(0, exponent + 1) + "." + coefficient.slice(exponent + 1)
+        : coefficient + new Array(exponent - coefficient.length + 2).join("0");
+  }
+
+  function formatDefault(x, p) {
+    x = x.toPrecision(p);
+
+    out: for (var n = x.length, i = 1, i0 = -1, i1; i < n; ++i) {
+      switch (x[i]) {
+        case ".": i0 = i1 = i; break;
+        case "0": if (i0 === 0) i0 = i; i1 = i; break;
+        case "e": break out;
+        default: if (i0 > 0) i0 = 0; break;
+      }
+    }
+
+    return i0 > 0 ? x.slice(0, i0) + x.slice(i1 + 1) : x;
+  }
+
+  var formatTypes = {
+    "": formatDefault,
+    "%": function(x, p) { return (x * 100).toFixed(p); },
+    "b": function(x) { return Math.round(x).toString(2); },
+    "c": function(x) { return x + ""; },
+    "d": function(x) { return Math.round(x).toString(10); },
+    "e": function(x, p) { return x.toExponential(p); },
+    "f": function(x, p) { return x.toFixed(p); },
+    "g": function(x, p) { return x.toPrecision(p); },
+    "o": function(x) { return Math.round(x).toString(8); },
+    "p": function(x, p) { return formatRounded(x * 100, p); },
+    "r": formatRounded,
+    "s": formatPrefixAuto,
+    "X": function(x) { return Math.round(x).toString(16).toUpperCase(); },
+    "x": function(x) { return Math.round(x).toString(16); }
+  };
+
+
+  // [[fill]align][sign][symbol][0][width][,][.precision][type]
+  var re = /^(?:(.)?([<>=^]))?([+\-\( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?([a-z%])?$/i;
+
+  function formatSpecifier(specifier) {
+    return new FormatSpecifier(specifier);
+  }
+
+  function FormatSpecifier(specifier) {
+    if (!(match = re.exec(specifier))) throw new Error("invalid format: " + specifier);
+
+    var match,
+        fill = match[1] || " ",
+        align = match[2] || ">",
+        sign = match[3] || "-",
+        symbol = match[4] || "",
+        zero = !!match[5],
+        width = match[6] && +match[6],
+        comma = !!match[7],
+        precision = match[8] && +match[8].slice(1),
+        type = match[9] || "";
+
+    // The "n" type is an alias for ",g".
+    if (type === "n") comma = true, type = "g";
+
+    // Map invalid types to the default format.
+    else if (!formatTypes[type]) type = "";
+
+    // If zero fill is specified, padding goes after sign and before digits.
+    if (zero || (fill === "0" && align === "=")) zero = true, fill = "0", align = "=";
+
+    this.fill = fill;
+    this.align = align;
+    this.sign = sign;
+    this.symbol = symbol;
+    this.zero = zero;
+    this.width = width;
+    this.comma = comma;
+    this.precision = precision;
+    this.type = type;
+  }
+
+  FormatSpecifier.prototype.toString = function() {
+    return this.fill
+        + this.align
+        + this.sign
+        + this.symbol
+        + (this.zero ? "0" : "")
+        + (this.width == null ? "" : Math.max(1, this.width | 0))
+        + (this.comma ? "," : "")
+        + (this.precision == null ? "" : "." + Math.max(0, this.precision | 0))
+        + this.type;
+  };
+
+  function formatGroup(grouping, thousands) {
+    return function(value, width) {
+      var i = value.length,
+          t = [],
+          j = 0,
+          g = grouping[0],
+          length = 0;
+
+      while (i > 0 && g > 0) {
+        if (length + g + 1 > width) g = Math.max(1, width - length);
+        t.push(value.substring(i -= g, i + g));
+        if ((length += g + 1) > width) break;
+        g = grouping[j = (j + 1) % grouping.length];
+      }
+
+      return t.reverse().join(thousands);
+    };
+  }
+
+  var prefixes = ["y","z","a","f","p","n","µ","m","","k","M","G","T","P","E","Z","Y"];
+
+  function identity(x) {
+    return x;
+  }
+
+  function locale(locale) {
+    var group = locale.grouping && locale.thousands ? formatGroup(locale.grouping, locale.thousands) : identity,
+        currency = locale.currency,
+        decimal = locale.decimal;
+
+    function format(specifier) {
+      specifier = formatSpecifier(specifier);
+
+      var fill = specifier.fill,
+          align = specifier.align,
+          sign = specifier.sign,
+          symbol = specifier.symbol,
+          zero = specifier.zero,
+          width = specifier.width,
+          comma = specifier.comma,
+          precision = specifier.precision,
+          type = specifier.type;
+
+      // Compute the prefix and suffix.
+      // For SI-prefix, the suffix is lazily computed.
+      var prefix = symbol === "$" ? currency[0] : symbol === "#" && /[boxX]/.test(type) ? "0" + type.toLowerCase() : "",
+          suffix = symbol === "$" ? currency[1] : /[%p]/.test(type) ? "%" : "";
+
+      // What format function should we use?
+      // Is this an integer type?
+      // Can this type generate exponential notation?
+      var formatType = formatTypes[type],
+          maybeSuffix = !type || /[defgprs%]/.test(type);
+
+      // Set the default precision if not specified,
+      // or clamp the specified precision to the supported range.
+      // For significant precision, it must be in [1, 21].
+      // For fixed precision, it must be in [0, 20].
+      precision = precision == null ? (type ? 6 : 12)
+          : /[gprs]/.test(type) ? Math.max(1, Math.min(21, precision))
+          : Math.max(0, Math.min(20, precision));
+
+      return function(value) {
+        var valuePrefix = prefix,
+            valueSuffix = suffix;
+
+        if (type === "c") {
+          valueSuffix = formatType(value) + valueSuffix;
+          value = "";
+        } else {
+          value = +value;
+
+          // Convert negative to positive, and compute the prefix.
+          // Note that -0 is not less than 0, but 1 / -0 is!
+          var valueNegative = (value < 0 || 1 / value < 0) && (value *= -1, true);
+
+          // Perform the initial formatting.
+          value = formatType(value, precision);
+
+          // Compute the prefix and suffix.
+          valuePrefix = (valueNegative ? (sign === "(" ? sign : "-") : sign === "-" || sign === "(" ? "" : sign) + valuePrefix;
+          valueSuffix = valueSuffix + (type === "s" ? prefixes[8 + prefixExponent / 3] : "") + (valueNegative && sign === "(" ? ")" : "");
+
+          // Break the formatted value into the integer “value” part that can be
+          // grouped, and fractional or exponential “suffix” part that is not.
+          if (maybeSuffix) {
+            var i = -1, n = value.length, c;
+            while (++i < n) {
+              if (c = value.charCodeAt(i), 48 > c || c > 57) {
+                valueSuffix = (c === 46 ? decimal + value.slice(i + 1) : value.slice(i)) + valueSuffix;
+                value = value.slice(0, i);
+                break;
+              }
+            }
+          }
+        }
+
+        // If the fill character is not "0", grouping is applied before padding.
+        if (comma && !zero) value = group(value, Infinity);
+
+        // Compute the padding.
+        var length = valuePrefix.length + value.length + valueSuffix.length,
+            padding = length < width ? new Array(width - length + 1).join(fill) : "";
+
+        // If the fill character is "0", grouping is applied after padding.
+        if (comma && zero) value = group(padding + value, padding.length ? width - valueSuffix.length : Infinity), padding = "";
+
+        // Reconstruct the final output based on the desired alignment.
+        switch (align) {
+          case "<": return valuePrefix + value + valueSuffix + padding;
+          case "=": return valuePrefix + padding + value + valueSuffix;
+          case "^": return padding.slice(0, length = padding.length >> 1) + valuePrefix + value + valueSuffix + padding.slice(length);
+        }
+        return padding + valuePrefix + value + valueSuffix;
+      };
+    }
+
+    function formatPrefix(specifier, value) {
+      var f = format((specifier = formatSpecifier(specifier), specifier.type = "f", specifier)),
+          e = Math.max(-8, Math.min(8, Math.floor(exponent(value) / 3))) * 3,
+          k = Math.pow(10, -e),
+          prefix = prefixes[8 + e / 3];
+      return function(value) {
+        return f(k * value) + prefix;
+      };
+    }
+
+    return {
+      format: format,
+      formatPrefix: formatPrefix
+    };
+  }
+
+  function precisionRound(step, max) {
+    return Math.max(0, exponent(Math.abs(max)) - exponent(Math.abs(step))) + 1;
+  }
+
+  function precisionPrefix(step, value) {
+    return Math.max(0, Math.max(-8, Math.min(8, Math.floor(exponent(value) / 3))) * 3 - exponent(Math.abs(step)));
+  }
+
+  function precisionFixed(step) {
+    return Math.max(0, -exponent(Math.abs(step)));
+  }
+
+  var localeDefinitions = (new Map)
+      .set("ca-ES", caEs)
+      .set("de-DE", deDe)
+      .set("en-CA", enCa)
+      .set("en-GB", enGb)
+      .set("en-US", enUs)
+      .set("es-ES", esEs)
+      .set("fi-FI", fiFi)
+      .set("fr-CA", frCa)
+      .set("fr-FR", frFr)
+      .set("he-IL", heIl)
+      .set("it-IT", itIt)
+      .set("ja-JP", jaJp)
+      .set("mk-MK", mkMk)
+      .set("nl-NL", nlNl)
+      .set("pl-PL", plPl)
+      .set("pt-BR", ptBr)
+      .set("ru-RU", ruRu)
+      .set("zh-CN", zhCn);
+
+  var defaultLocale = locale(enUs);
+  exports.format = defaultLocale.format;
+  exports.formatPrefix = defaultLocale.formatPrefix;
+
+  function localeFormat(definition) {
+    if (typeof definition === "string") {
+      definition = localeDefinitions.get(definition);
+      if (!definition) return null;
+    }
+    return locale(definition);
+  }
+  ;
+
+  exports.localeFormat = localeFormat;
+  exports.formatSpecifier = formatSpecifier;
+  exports.precisionFixed = precisionFixed;
+  exports.precisionPrefix = precisionPrefix;
+  exports.precisionRound = precisionRound;
+
+}));
+},{}],5:[function(require,module,exports){
+if (typeof Map === "undefined") {
+  Map = function() { this.clear(); };
+  Map.prototype = {
+    set: function(k, v) { this._[k] = v; return this; },
+    get: function(k) { return this._[k]; },
+    has: function(k) { return k in this._; },
+    delete: function(k) { return k in this._ && delete this._[k]; },
+    clear: function() { this._ = Object.create(null); },
+    get size() { var n = 0; for (var k in this._) ++n; return n; },
+    forEach: function(c) { for (var k in this._) c(this._[k], k, this); }
+  };
+} else (function() {
+  var m = new Map;
+  if (m.set(0, 0) !== m) {
+    m = m.set;
+    Map.prototype.set = function() { m.apply(this, arguments); return this; };
+  }
+})();
+
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  factory((global.timeFormat = {}));
+}(this, function (exports) { 'use strict';
+
+  var zhCn = {
+    dateTime: "%a %b %e %X %Y",
+    date: "%Y/%-m/%-d",
+    time: "%H:%M:%S",
+    periods: ["上午", "下午"],
+    days: ["星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"],
+    shortDays: ["星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"],
+    months: ["一月", "二月", "三月", "四月", "五月", "六月", "七月", "八月", "九月", "十月", "十一月", "十二月"],
+    shortMonths: ["一月", "二月", "三月", "四月", "五月", "六月", "七月", "八月", "九月", "十月", "十一月", "十二月"]
+  };
+
+  var ruRu = {
+    dateTime: "%A, %e %B %Y г. %X",
+    date: "%d.%m.%Y",
+    time: "%H:%M:%S",
+    periods: ["AM", "PM"],
+    days: ["воскресенье", "понедельник", "вторник", "среда", "четверг", "пятница", "суббота"],
+    shortDays: ["вс", "пн", "вт", "ср", "чт", "пт", "сб"],
+    months: ["января", "февраля", "марта", "апреля", "мая", "июня", "июля", "августа", "сентября", "октября", "ноября", "декабря"],
+    shortMonths: ["янв", "фев", "мар", "апр", "май", "июн", "июл", "авг", "сен", "окт", "ноя", "дек"]
+  };
+
+  var ptBr = {
+    dateTime: "%A, %e de %B de %Y. %X",
+    date: "%d/%m/%Y",
+    time: "%H:%M:%S",
+    periods: ["AM", "PM"],
+    days: ["Domingo", "Segunda", "Terça", "Quarta", "Quinta", "Sexta", "Sábado"],
+    shortDays: ["Dom", "Seg", "Ter", "Qua", "Qui", "Sex", "Sáb"],
+    months: ["Janeiro", "Fevereiro", "Março", "Abril", "Maio", "Junho", "Julho", "Agosto", "Setembro", "Outubro", "Novembro", "Dezembro"],
+    shortMonths: ["Jan", "Fev", "Mar", "Abr", "Mai", "Jun", "Jul", "Ago", "Set", "Out", "Nov", "Dez"]
+  };
+
+  var plPl = {
+    dateTime: "%A, %e %B %Y, %X",
+    date: "%d/%m/%Y",
+    time: "%H:%M:%S",
+    periods: ["AM", "PM"], // unused
+    days: ["Niedziela", "Poniedziałek", "Wtorek", "Środa", "Czwartek", "Piątek", "Sobota"],
+    shortDays: ["Niedz.", "Pon.", "Wt.", "Śr.", "Czw.", "Pt.", "Sob."],
+    months: ["Styczeń", "Luty", "Marzec", "Kwiecień", "Maj", "Czerwiec", "Lipiec", "Sierpień", "Wrzesień", "Październik", "Listopad", "Grudzień"],
+    shortMonths: ["Stycz.", "Luty", "Marz.", "Kwie.", "Maj", "Czerw.", "Lipc.", "Sierp.", "Wrz.", "Paźdz.", "Listop.", "Grudz."]/* In Polish language abbraviated months are not commonly used so there is a dispute about the proper abbraviations. */
+  };
+
+  var nlNl = {
+    dateTime: "%a %e %B %Y %T",
+    date: "%d-%m-%Y",
+    time: "%H:%M:%S",
+    periods: ["AM", "PM"], // unused
+    days: ["zondag", "maandag", "dinsdag", "woensdag", "donderdag", "vrijdag", "zaterdag"],
+    shortDays: ["zo", "ma", "di", "wo", "do", "vr", "za"],
+    months: ["januari", "februari", "maart", "april", "mei", "juni", "juli", "augustus", "september", "oktober", "november", "december"],
+    shortMonths: ["jan", "feb", "mrt", "apr", "mei", "jun", "jul", "aug", "sep", "okt", "nov", "dec"]
+  };
+
+  var mkMk = {
+    dateTime: "%A, %e %B %Y г. %X",
+    date: "%d.%m.%Y",
+    time: "%H:%M:%S",
+    periods: ["AM", "PM"],
+    days: ["недела", "понеделник", "вторник", "среда", "четврток", "петок", "сабота"],
+    shortDays: ["нед", "пон", "вто", "сре", "чет", "пет", "саб"],
+    months: ["јануари", "февруари", "март", "април", "мај", "јуни", "јули", "август", "септември", "октомври", "ноември", "декември"],
+    shortMonths: ["јан", "фев", "мар", "апр", "мај", "јун", "јул", "авг", "сеп", "окт", "ное", "дек"]
+  };
+
+  var jaJp = {
+    dateTime: "%Y %b %e %a %X",
+    date: "%Y/%m/%d",
+    time: "%H:%M:%S",
+    periods: ["AM", "PM"],
+    days: ["日曜日", "月曜日", "火曜日", "水曜日", "木曜日", "金曜日", "土曜日"],
+    shortDays: ["日", "月", "火", "水", "木", "金", "土"],
+    months: ["睦月", "如月", "弥生", "卯月", "皐月", "水無月", "文月", "葉月", "長月", "神無月", "霜月", "師走"],
+    shortMonths: ["1月", "2月", "3月", "4月", "5月", "6月", "7月", "8月", "9月", "10月", "11月", "12月"]
+  };
+
+  var itIt = {
+    dateTime: "%A %e %B %Y, %X",
+    date: "%d/%m/%Y",
+    time: "%H:%M:%S",
+    periods: ["AM", "PM"], // unused
+    days: ["Domenica", "Lunedì", "Martedì", "Mercoledì", "Giovedì", "Venerdì", "Sabato"],
+    shortDays: ["Dom", "Lun", "Mar", "Mer", "Gio", "Ven", "Sab"],
+    months: ["Gennaio", "Febbraio", "Marzo", "Aprile", "Maggio", "Giugno", "Luglio", "Agosto", "Settembre", "Ottobre", "Novembre", "Dicembre"],
+    shortMonths: ["Gen", "Feb", "Mar", "Apr", "Mag", "Giu", "Lug", "Ago", "Set", "Ott", "Nov", "Dic"]
+  };
+
+  var heIl = {
+    dateTime: "%A, %e ב%B %Y %X",
+    date: "%d.%m.%Y",
+    time: "%H:%M:%S",
+    periods: ["AM", "PM"],
+    days: ["ראשון", "שני", "שלישי", "רביעי", "חמישי", "שישי", "שבת"],
+    shortDays: ["א׳", "ב׳", "ג׳", "ד׳", "ה׳", "ו׳", "ש׳"],
+    months: ["ינואר", "פברואר", "מרץ", "אפריל", "מאי", "יוני", "יולי", "אוגוסט", "ספטמבר", "אוקטובר", "נובמבר", "דצמבר"],
+    shortMonths: ["ינו׳", "פבר׳", "מרץ", "אפר׳", "מאי", "יוני", "יולי", "אוג׳", "ספט׳", "אוק׳", "נוב׳", "דצמ׳"]
+  };
+
+  var frFr = {
+    dateTime: "%A, le %e %B %Y, %X",
+    date: "%d/%m/%Y",
+    time: "%H:%M:%S",
+    periods: ["AM", "PM"], // unused
+    days: ["dimanche", "lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi"],
+    shortDays: ["dim.", "lun.", "mar.", "mer.", "jeu.", "ven.", "sam."],
+    months: ["janvier", "février", "mars", "avril", "mai", "juin", "juillet", "août", "septembre", "octobre", "novembre", "décembre"],
+    shortMonths: ["janv.", "févr.", "mars", "avr.", "mai", "juin", "juil.", "août", "sept.", "oct.", "nov.", "déc."]
+  };
+
+  var frCa = {
+    dateTime: "%a %e %b %Y %X",
+    date: "%Y-%m-%d",
+    time: "%H:%M:%S",
+    periods: ["", ""],
+    days: ["dimanche", "lundi", "mardi", "mercredi", "jeudi", "vendredi", "samedi"],
+    shortDays: ["dim", "lun", "mar", "mer", "jeu", "ven", "sam"],
+    months: ["janvier", "février", "mars", "avril", "mai", "juin", "juillet", "août", "septembre", "octobre", "novembre", "décembre"],
+    shortMonths: ["jan", "fév", "mar", "avr", "mai", "jui", "jul", "aoû", "sep", "oct", "nov", "déc"]
+  };
+
+  var fiFi = {
+    dateTime: "%A, %-d. %Bta %Y klo %X",
+    date: "%-d.%-m.%Y",
+    time: "%H:%M:%S",
+    periods: ["a.m.", "p.m."],
+    days: ["sunnuntai", "maanantai", "tiistai", "keskiviikko", "torstai", "perjantai", "lauantai"],
+    shortDays: ["Su", "Ma", "Ti", "Ke", "To", "Pe", "La"],
+    months: ["tammikuu", "helmikuu", "maaliskuu", "huhtikuu", "toukokuu", "kesäkuu", "heinäkuu", "elokuu", "syyskuu", "lokakuu", "marraskuu", "joulukuu"],
+    shortMonths: ["Tammi", "Helmi", "Maalis", "Huhti", "Touko", "Kesä", "Heinä", "Elo", "Syys", "Loka", "Marras", "Joulu"]
+  };
+
+  var esEs = {
+    dateTime: "%A, %e de %B de %Y, %X",
+    date: "%d/%m/%Y",
+    time: "%H:%M:%S",
+    periods: ["AM", "PM"],
+    days: ["domingo", "lunes", "martes", "miércoles", "jueves", "viernes", "sábado"],
+    shortDays: ["dom", "lun", "mar", "mié", "jue", "vie", "sáb"],
+    months: ["enero", "febrero", "marzo", "abril", "mayo", "junio", "julio", "agosto", "septiembre", "octubre", "noviembre", "diciembre"],
+    shortMonths: ["ene", "feb", "mar", "abr", "may", "jun", "jul", "ago", "sep", "oct", "nov", "dic"]
+  };
+
+  var enUs = {
+    dateTime: "%a %b %e %X %Y",
+    date: "%m/%d/%Y",
+    time: "%H:%M:%S",
+    periods: ["AM", "PM"],
+    days: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
+    shortDays: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
+    months: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"],
+    shortMonths: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+  };
+
+  var enGb = {
+    dateTime: "%a %e %b %X %Y",
+    date: "%d/%m/%Y",
+    time: "%H:%M:%S",
+    periods: ["AM", "PM"],
+    days: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
+    shortDays: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
+    months: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"],
+    shortMonths: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+  };
+
+  var enCa = {
+    dateTime: "%a %b %e %X %Y",
+    date: "%Y-%m-%d",
+    time: "%H:%M:%S",
+    periods: ["AM", "PM"],
+    days: ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"],
+    shortDays: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
+    months: ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"],
+    shortMonths: ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+  };
+
+  var deDe = {
+    dateTime: "%A, der %e. %B %Y, %X",
+    date: "%d.%m.%Y",
+    time: "%H:%M:%S",
+    periods: ["AM", "PM"], // unused
+    days: ["Sonntag", "Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag"],
+    shortDays: ["So", "Mo", "Di", "Mi", "Do", "Fr", "Sa"],
+    months: ["Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November", "Dezember"],
+    shortMonths: ["Jan", "Feb", "Mrz", "Apr", "Mai", "Jun", "Jul", "Aug", "Sep", "Okt", "Nov", "Dez"]
+  };
+
+  var caEs = {
+    dateTime: "%A, %e de %B de %Y, %X",
+    date: "%d/%m/%Y",
+    time: "%H:%M:%S",
+    periods: ["AM", "PM"],
+    days: ["diumenge", "dilluns", "dimarts", "dimecres", "dijous", "divendres", "dissabte"],
+    shortDays: ["dg.", "dl.", "dt.", "dc.", "dj.", "dv.", "ds."],
+    months: ["gener", "febrer", "març", "abril", "maig", "juny", "juliol", "agost", "setembre", "octubre", "novembre", "desembre"],
+    shortMonths: ["gen.", "febr.", "març", "abr.", "maig", "juny", "jul.", "ag.", "set.", "oct.", "nov.", "des."]
+  };
+
+  var t0 = new Date;
+  var t1 = new Date;
+
+  function newInterval(floori, offseti, count) {
+
+    function interval(date) {
+      return floori(date = new Date(+date)), date;
+    }
+
+    interval.floor = interval;
+
+    interval.round = function(date) {
+      var d0 = new Date(+date),
+          d1 = new Date(date - 1);
+      floori(d0), floori(d1), offseti(d1, 1);
+      return date - d0 < d1 - date ? d0 : d1;
+    };
+
+    interval.ceil = function(date) {
+      return floori(date = new Date(date - 1)), offseti(date, 1), date;
+    };
+
+    interval.offset = function(date, step) {
+      return offseti(date = new Date(+date), step == null ? 1 : Math.floor(step)), date;
+    };
+
+    interval.range = function(start, stop, step) {
+      var range = [];
+      start = new Date(start - 1);
+      stop = new Date(+stop);
+      step = step == null ? 1 : Math.floor(step);
+      if (!(start < stop) || !(step > 0)) return range; // also handles Invalid Date
+      offseti(start, 1), floori(start);
+      if (start < stop) range.push(new Date(+start));
+      while (offseti(start, step), floori(start), start < stop) range.push(new Date(+start));
+      return range;
+    };
+
+    interval.filter = function(test) {
+      return newInterval(function(date) {
+        while (floori(date), !test(date)) date.setTime(date - 1);
+      }, function(date, step) {
+        while (--step >= 0) while (offseti(date, 1), !test(date));
+      });
+    };
+
+    if (count) interval.count = function(start, end) {
+      t0.setTime(+start), t1.setTime(+end);
+      floori(t0), floori(t1);
+      return Math.floor(count(t0, t1));
+    };
+
+    return interval;
+  }
+
+  var day = newInterval(function(date) {
+    date.setHours(0, 0, 0, 0);
+  }, function(date, step) {
+    date.setDate(date.getDate() + step);
+  }, function(start, end) {
+    return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * 6e4) / 864e5;
+  });
+
+  function weekday(i) {
+    return newInterval(function(date) {
+      date.setHours(0, 0, 0, 0);
+      date.setDate(date.getDate() - (date.getDay() + 7 - i) % 7);
+    }, function(date, step) {
+      date.setDate(date.getDate() + step * 7);
+    }, function(start, end) {
+      return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * 6e4) / 6048e5;
+    });
+  }
+
+  var sunday = weekday(0);
+  var monday = weekday(1);
+
+  var year = newInterval(function(date) {
+    date.setHours(0, 0, 0, 0);
+    date.setMonth(0, 1);
+  }, function(date, step) {
+    date.setFullYear(date.getFullYear() + step);
+  }, function(start, end) {
+    return end.getFullYear() - start.getFullYear();
+  });
+
+  var utcDay = newInterval(function(date) {
+    date.setUTCHours(0, 0, 0, 0);
+  }, function(date, step) {
+    date.setUTCDate(date.getUTCDate() + step);
+  }, function(start, end) {
+    return (end - start) / 864e5;
+  });
+
+  function utcWeekday(i) {
+    return newInterval(function(date) {
+      date.setUTCHours(0, 0, 0, 0);
+      date.setUTCDate(date.getUTCDate() - (date.getUTCDay() + 7 - i) % 7);
+    }, function(date, step) {
+      date.setUTCDate(date.getUTCDate() + step * 7);
+    }, function(start, end) {
+      return (end - start) / 6048e5;
+    });
+  }
+
+  var utcSunday = utcWeekday(0);
+  var utcMonday = utcWeekday(1);
+
+  var utcYear = newInterval(function(date) {
+    date.setUTCHours(0, 0, 0, 0);
+    date.setUTCMonth(0, 1);
+  }, function(date, step) {
+    date.setUTCFullYear(date.getUTCFullYear() + step);
+  }, function(start, end) {
+    return end.getUTCFullYear() - start.getUTCFullYear();
+  });
+
+  function localDate(d) {
+    if (0 <= d.y && d.y < 100) {
+      var date = new Date(-1, d.m, d.d, d.H, d.M, d.S, d.L);
+      date.setFullYear(d.y);
+      return date;
+    }
+    return new Date(d.y, d.m, d.d, d.H, d.M, d.S, d.L);
+  }
+
+  function utcDate(d) {
+    if (0 <= d.y && d.y < 100) {
+      var date = new Date(Date.UTC(-1, d.m, d.d, d.H, d.M, d.S, d.L));
+      date.setUTCFullYear(d.y);
+      return date;
+    }
+    return new Date(Date.UTC(d.y, d.m, d.d, d.H, d.M, d.S, d.L));
+  }
+
+  function newYear(y) {
+    return {y: y, m: 0, d: 1, H: 0, M: 0, S: 0, L: 0};
+  }
+
+  function locale(locale) {
+    var locale_dateTime = locale.dateTime,
+        locale_date = locale.date,
+        locale_time = locale.time,
+        locale_periods = locale.periods,
+        locale_weekdays = locale.days,
+        locale_shortWeekdays = locale.shortDays,
+        locale_months = locale.months,
+        locale_shortMonths = locale.shortMonths;
+
+    var periodLookup = formatLookup(locale_periods),
+        weekdayRe = formatRe(locale_weekdays),
+        weekdayLookup = formatLookup(locale_weekdays),
+        shortWeekdayRe = formatRe(locale_shortWeekdays),
+        shortWeekdayLookup = formatLookup(locale_shortWeekdays),
+        monthRe = formatRe(locale_months),
+        monthLookup = formatLookup(locale_months),
+        shortMonthRe = formatRe(locale_shortMonths),
+        shortMonthLookup = formatLookup(locale_shortMonths);
+
+    var formats = {
+      "a": formatShortWeekday,
+      "A": formatWeekday,
+      "b": formatShortMonth,
+      "B": formatMonth,
+      "c": null,
+      "d": formatDayOfMonth,
+      "e": formatDayOfMonth,
+      "H": formatHour24,
+      "I": formatHour12,
+      "j": formatDayOfYear,
+      "L": formatMilliseconds,
+      "m": formatMonthNumber,
+      "M": formatMinutes,
+      "p": formatPeriod,
+      "S": formatSeconds,
+      "U": formatWeekNumberSunday,
+      "w": formatWeekdayNumber,
+      "W": formatWeekNumberMonday,
+      "x": null,
+      "X": null,
+      "y": formatYear,
+      "Y": formatFullYear,
+      "Z": formatZone,
+      "%": formatLiteralPercent
+    };
+
+    var utcFormats = {
+      "a": formatUTCShortWeekday,
+      "A": formatUTCWeekday,
+      "b": formatUTCShortMonth,
+      "B": formatUTCMonth,
+      "c": null,
+      "d": formatUTCDayOfMonth,
+      "e": formatUTCDayOfMonth,
+      "H": formatUTCHour24,
+      "I": formatUTCHour12,
+      "j": formatUTCDayOfYear,
+      "L": formatUTCMilliseconds,
+      "m": formatUTCMonthNumber,
+      "M": formatUTCMinutes,
+      "p": formatUTCPeriod,
+      "S": formatUTCSeconds,
+      "U": formatUTCWeekNumberSunday,
+      "w": formatUTCWeekdayNumber,
+      "W": formatUTCWeekNumberMonday,
+      "x": null,
+      "X": null,
+      "y": formatUTCYear,
+      "Y": formatUTCFullYear,
+      "Z": formatUTCZone,
+      "%": formatLiteralPercent
+    };
+
+    var parses = {
+      "a": parseShortWeekday,
+      "A": parseWeekday,
+      "b": parseShortMonth,
+      "B": parseMonth,
+      "c": parseLocaleDateTime,
+      "d": parseDayOfMonth,
+      "e": parseDayOfMonth,
+      "H": parseHour24,
+      "I": parseHour24,
+      "j": parseDayOfYear,
+      "L": parseMilliseconds,
+      "m": parseMonthNumber,
+      "M": parseMinutes,
+      "p": parsePeriod,
+      "S": parseSeconds,
+      "U": parseWeekNumberSunday,
+      "w": parseWeekdayNumber,
+      "W": parseWeekNumberMonday,
+      "x": parseLocaleDate,
+      "X": parseLocaleTime,
+      "y": parseYear,
+      "Y": parseFullYear,
+      "Z": parseZone,
+      "%": parseLiteralPercent
+    };
+
+    // These recursive directive definitions must be deferred.
+    formats.x = newFormat(locale_date, formats);
+    formats.X = newFormat(locale_time, formats);
+    formats.c = newFormat(locale_dateTime, formats);
+    utcFormats.x = newFormat(locale_date, utcFormats);
+    utcFormats.X = newFormat(locale_time, utcFormats);
+    utcFormats.c = newFormat(locale_dateTime, utcFormats);
+
+    function newFormat(specifier, formats) {
+      return function(date) {
+        var string = [],
+            i = -1,
+            j = 0,
+            n = specifier.length,
+            c,
+            pad,
+            format;
+
+        while (++i < n) {
+          if (specifier.charCodeAt(i) === 37) {
+            string.push(specifier.slice(j, i));
+            if ((pad = pads[c = specifier.charAt(++i)]) != null) c = specifier.charAt(++i);
+            if (format = formats[c]) c = format(date, pad == null ? (c === "e" ? " " : "0") : pad);
+            string.push(c);
+            j = i + 1;
+          }
+        }
+
+        string.push(specifier.slice(j, i));
+        return string.join("");
+      };
+    }
+
+    function newParse(specifier, newDate) {
+      return function(string) {
+        var d = newYear(1900),
+            i = parseSpecifier(d, specifier, string, 0);
+        if (i != string.length) return null;
+
+        // The am-pm flag is 0 for AM, and 1 for PM.
+        if ("p" in d) d.H = d.H % 12 + d.p * 12;
+
+        // If a time zone is specified, all fields are interpreted as UTC and then
+        // offset according to the specified time zone.
+        if ("Z" in d) {
+          if ("w" in d && ("W" in d || "U" in d)) {
+            var day = utcDate(newYear(d.y)).getUTCDay();
+            if ("W" in d) d.U = d.W, d.w = (d.w + 6) % 7, --day;
+            d.m = 0;
+            d.d = d.w + d.U * 7 - (day + 6) % 7;
+          }
+          d.H += d.Z / 100 | 0;
+          d.M += d.Z % 100;
+          return utcDate(d);
+        }
+
+        // Otherwise, all fields are in local time.
+        if ("w" in d && ("W" in d || "U" in d)) {
+          var day = newDate(newYear(d.y)).getDay();
+          if ("W" in d) d.U = d.W, d.w = (d.w + 6) % 7, --day;
+          d.m = 0;
+          d.d = d.w + d.U * 7 - (day + 6) % 7;
+        }
+        return newDate(d);
+      };
+    }
+
+    function parseSpecifier(d, specifier, string, j) {
+      var i = 0,
+          n = specifier.length,
+          m = string.length,
+          c,
+          parse;
+
+      while (i < n) {
+        if (j >= m) return -1;
+        c = specifier.charCodeAt(i++);
+        if (c === 37) {
+          c = specifier.charAt(i++);
+          parse = parses[c in pads ? specifier.charAt(i++) : c];
+          if (!parse || ((j = parse(d, string, j)) < 0)) return -1;
+        } else if (c != string.charCodeAt(j++)) {
+          return -1;
+        }
+      }
+
+      return j;
+    }
+
+    function parseShortWeekday(d, string, i) {
+      var n = shortWeekdayRe.exec(string.slice(i));
+      return n ? (d.w = shortWeekdayLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
+    }
+
+    function parseWeekday(d, string, i) {
+      var n = weekdayRe.exec(string.slice(i));
+      return n ? (d.w = weekdayLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
+    }
+
+    function parseShortMonth(d, string, i) {
+      var n = shortMonthRe.exec(string.slice(i));
+      return n ? (d.m = shortMonthLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
+    }
+
+    function parseMonth(d, string, i) {
+      var n = monthRe.exec(string.slice(i));
+      return n ? (d.m = monthLookup.get(n[0].toLowerCase()), i + n[0].length) : -1;
+    }
+
+    function parseLocaleDateTime(d, string, i) {
+      return parseSpecifier(d, locale_dateTime, string, i);
+    }
+
+    function parseLocaleDate(d, string, i) {
+      return parseSpecifier(d, locale_date, string, i);
+    }
+
+    function parseLocaleTime(d, string, i) {
+      return parseSpecifier(d, locale_time, string, i);
+    }
+
+    function parsePeriod(d, string, i) {
+      var n = periodLookup.get(string.slice(i, i += 2).toLowerCase());
+      return n == null ? -1 : (d.p = n, i);
+    }
+
+    function formatShortWeekday(d) {
+      return locale_shortWeekdays[d.getDay()];
+    }
+
+    function formatWeekday(d) {
+      return locale_weekdays[d.getDay()];
+    }
+
+    function formatShortMonth(d) {
+      return locale_shortMonths[d.getMonth()];
+    }
+
+    function formatMonth(d) {
+      return locale_months[d.getMonth()];
+    }
+
+    function formatPeriod(d) {
+      return locale_periods[+(d.getHours() >= 12)];
+    }
+
+    function formatUTCShortWeekday(d) {
+      return locale_shortWeekdays[d.getUTCDay()];
+    }
+
+    function formatUTCWeekday(d) {
+      return locale_weekdays[d.getUTCDay()];
+    }
+
+    function formatUTCShortMonth(d) {
+      return locale_shortMonths[d.getUTCMonth()];
+    }
+
+    function formatUTCMonth(d) {
+      return locale_months[d.getUTCMonth()];
+    }
+
+    function formatUTCPeriod(d) {
+      return locale_periods[+(d.getUTCHours() >= 12)];
+    }
+
+    return {
+      format: function(specifier) {
+        var f = newFormat(specifier += "", formats);
+        f.parse = newParse(specifier, localDate);
+        f.toString = function() { return specifier; };
+        return f;
+      },
+      utcFormat: function(specifier) {
+        var f = newFormat(specifier += "", utcFormats);
+        f.parse = newParse(specifier, utcDate);
+        f.toString = function() { return specifier; };
+        return f;
+      }
+    };
+  }
+
+  var pads = {"-": "", "_": " ", "0": "0"};
+  var numberRe = /^\s*\d+/;
+  var percentRe = /^%/;
+  var requoteRe = /[\\\^\$\*\+\?\|\[\]\(\)\.\{\}]/g;
+
+  function pad(value, fill, width) {
+    var sign = value < 0 ? "-" : "",
+        string = (sign ? -value : value) + "",
+        length = string.length;
+    return sign + (length < width ? new Array(width - length + 1).join(fill) + string : string);
+  }
+
+  function requote(s) {
+    return s.replace(requoteRe, "\\$&");
+  }
+
+  function formatRe(names) {
+    return new RegExp("^(?:" + names.map(requote).join("|") + ")", "i");
+  }
+
+  function formatLookup(names) {
+    var map = new Map, i = -1, n = names.length;
+    while (++i < n) map.set(names[i].toLowerCase(), i);
+    return map;
+  }
+
+  function parseWeekdayNumber(d, string, i) {
+    var n = numberRe.exec(string.slice(i, i + 1));
+    return n ? (d.w = +n[0], i + n[0].length) : -1;
+  }
+
+  function parseWeekNumberSunday(d, string, i) {
+    var n = numberRe.exec(string.slice(i));
+    return n ? (d.U = +n[0], i + n[0].length) : -1;
+  }
+
+  function parseWeekNumberMonday(d, string, i) {
+    var n = numberRe.exec(string.slice(i));
+    return n ? (d.W = +n[0], i + n[0].length) : -1;
+  }
+
+  function parseFullYear(d, string, i) {
+    var n = numberRe.exec(string.slice(i, i + 4));
+    return n ? (d.y = +n[0], i + n[0].length) : -1;
+  }
+
+  function parseYear(d, string, i) {
+    var n = numberRe.exec(string.slice(i, i + 2));
+    return n ? (d.y = +n[0] + (+n[0] > 68 ? 1900 : 2000), i + n[0].length) : -1;
+  }
+
+  function parseZone(d, string, i) {
+    return /^[+-]\d{4}$/.test(string = string.slice(i, i + 5))
+        ? (d.Z = -string, i + 5) // sign differs from getTimezoneOffset!
+        : -1;
+  }
+
+  function parseMonthNumber(d, string, i) {
+    var n = numberRe.exec(string.slice(i, i + 2));
+    return n ? (d.m = n[0] - 1, i + n[0].length) : -1;
+  }
+
+  function parseDayOfMonth(d, string, i) {
+    var n = numberRe.exec(string.slice(i, i + 2));
+    return n ? (d.d = +n[0], i + n[0].length) : -1;
+  }
+
+  function parseDayOfYear(d, string, i) {
+    var n = numberRe.exec(string.slice(i, i + 3));
+    return n ? (d.m = 0, d.d = +n[0], i + n[0].length) : -1;
+  }
+
+  function parseHour24(d, string, i) {
+    var n = numberRe.exec(string.slice(i, i + 2));
+    return n ? (d.H = +n[0], i + n[0].length) : -1;
+  }
+
+  function parseMinutes(d, string, i) {
+    var n = numberRe.exec(string.slice(i, i + 2));
+    return n ? (d.M = +n[0], i + n[0].length) : -1;
+  }
+
+  function parseSeconds(d, string, i) {
+    var n = numberRe.exec(string.slice(i, i + 2));
+    return n ? (d.S = +n[0], i + n[0].length) : -1;
+  }
+
+  function parseMilliseconds(d, string, i) {
+    var n = numberRe.exec(string.slice(i, i + 3));
+    return n ? (d.L = +n[0], i + n[0].length) : -1;
+  }
+
+  function parseLiteralPercent(d, string, i) {
+    var n = percentRe.exec(string.slice(i, i + 1));
+    return n ? i + n[0].length : -1;
+  }
+
+  function formatDayOfMonth(d, p) {
+    return pad(d.getDate(), p, 2);
+  }
+
+  function formatHour24(d, p) {
+    return pad(d.getHours(), p, 2);
+  }
+
+  function formatHour12(d, p) {
+    return pad(d.getHours() % 12 || 12, p, 2);
+  }
+
+  function formatDayOfYear(d, p) {
+    return pad(1 + day.count(year(d), d), p, 3);
+  }
+
+  function formatMilliseconds(d, p) {
+    return pad(d.getMilliseconds(), p, 3);
+  }
+
+  function formatMonthNumber(d, p) {
+    return pad(d.getMonth() + 1, p, 2);
+  }
+
+  function formatMinutes(d, p) {
+    return pad(d.getMinutes(), p, 2);
+  }
+
+  function formatSeconds(d, p) {
+    return pad(d.getSeconds(), p, 2);
+  }
+
+  function formatWeekNumberSunday(d, p) {
+    return pad(sunday.count(year(d), d), p, 2);
+  }
+
+  function formatWeekdayNumber(d) {
+    return d.getDay();
+  }
+
+  function formatWeekNumberMonday(d, p) {
+    return pad(monday.count(year(d), d), p, 2);
+  }
+
+  function formatYear(d, p) {
+    return pad(d.getFullYear() % 100, p, 2);
+  }
+
+  function formatFullYear(d, p) {
+    return pad(d.getFullYear() % 10000, p, 4);
+  }
+
+  function formatZone(d) {
+    var z = d.getTimezoneOffset();
+    return (z > 0 ? "-" : (z *= -1, "+"))
+        + pad(z / 60 | 0, "0", 2)
+        + pad(z % 60, "0", 2);
+  }
+
+  function formatUTCDayOfMonth(d, p) {
+    return pad(d.getUTCDate(), p, 2);
+  }
+
+  function formatUTCHour24(d, p) {
+    return pad(d.getUTCHours(), p, 2);
+  }
+
+  function formatUTCHour12(d, p) {
+    return pad(d.getUTCHours() % 12 || 12, p, 2);
+  }
+
+  function formatUTCDayOfYear(d, p) {
+    return pad(1 + utcDay.count(utcYear(d), d), p, 3);
+  }
+
+  function formatUTCMilliseconds(d, p) {
+    return pad(d.getUTCMilliseconds(), p, 3);
+  }
+
+  function formatUTCMonthNumber(d, p) {
+    return pad(d.getUTCMonth() + 1, p, 2);
+  }
+
+  function formatUTCMinutes(d, p) {
+    return pad(d.getUTCMinutes(), p, 2);
+  }
+
+  function formatUTCSeconds(d, p) {
+    return pad(d.getUTCSeconds(), p, 2);
+  }
+
+  function formatUTCWeekNumberSunday(d, p) {
+    return pad(utcSunday.count(utcYear(d), d), p, 2);
+  }
+
+  function formatUTCWeekdayNumber(d) {
+    return d.getUTCDay();
+  }
+
+  function formatUTCWeekNumberMonday(d, p) {
+    return pad(utcMonday.count(utcYear(d), d), p, 2);
+  }
+
+  function formatUTCYear(d, p) {
+    return pad(d.getUTCFullYear() % 100, p, 2);
+  }
+
+  function formatUTCFullYear(d, p) {
+    return pad(d.getUTCFullYear() % 10000, p, 4);
+  }
+
+  function formatUTCZone() {
+    return "+0000";
+  }
+
+  function formatLiteralPercent() {
+    return "%";
+  }
+
+  var isoSpecifier = "%Y-%m-%dT%H:%M:%S.%LZ";
+
+  function formatIsoNative(date) {
+    return date.toISOString();
+  }
+
+  formatIsoNative.parse = function(string) {
+    var date = new Date(string);
+    return isNaN(date) ? null : date;
+  };
+
+  formatIsoNative.toString = function() {
+    return isoSpecifier;
+  };
+
+  var formatIso = Date.prototype.toISOString && +new Date("2000-01-01T00:00:00.000Z")
+      ? formatIsoNative
+      : enUs.utcFormat(isoSpecifier);
+
+  var isoFormat = formatIso;
+
+  var localeDefinitions = (new Map)
+      .set("ca-ES", caEs)
+      .set("de-DE", deDe)
+      .set("en-CA", enCa)
+      .set("en-GB", enGb)
+      .set("en-US", enUs)
+      .set("es-ES", esEs)
+      .set("fi-FI", fiFi)
+      .set("fr-CA", frCa)
+      .set("fr-FR", frFr)
+      .set("he-IL", heIl)
+      .set("it-IT", itIt)
+      .set("ja-JP", jaJp)
+      .set("mk-MK", mkMk)
+      .set("nl-NL", nlNl)
+      .set("pl-PL", plPl)
+      .set("pt-BR", ptBr)
+      .set("ru-RU", ruRu)
+      .set("zh-CN", zhCn);
+
+  var defaultLocale = locale(enUs);
+  exports.format = defaultLocale.format;
+  exports.utcFormat = defaultLocale.utcFormat;
+
+  function localeFormat(definition) {
+    if (typeof definition === "string") {
+      definition = localeDefinitions.get(definition);
+      if (!definition) return null;
+    }
+    return locale(definition);
+  }
+  ;
+
+  exports.localeFormat = localeFormat;
+  exports.isoFormat = isoFormat;
+
+}));
+},{}],6:[function(require,module,exports){
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  factory((global.time = {}));
+}(this, function (exports) { 'use strict';
+
+  var t1 = new Date;
+
+  var t0 = new Date;
+
+  function newInterval(floori, offseti, count) {
+
+    function interval(date) {
+      return floori(date = new Date(+date)), date;
+    }
+
+    interval.floor = interval;
+
+    interval.round = function(date) {
+      var d0 = new Date(+date),
+          d1 = new Date(date - 1);
+      floori(d0), floori(d1), offseti(d1, 1);
+      return date - d0 < d1 - date ? d0 : d1;
+    };
+
+    interval.ceil = function(date) {
+      return floori(date = new Date(date - 1)), offseti(date, 1), date;
+    };
+
+    interval.offset = function(date, step) {
+      return offseti(date = new Date(+date), step == null ? 1 : Math.floor(step)), date;
+    };
+
+    interval.range = function(start, stop, step) {
+      var range = [];
+      start = new Date(start - 1);
+      stop = new Date(+stop);
+      step = step == null ? 1 : Math.floor(step);
+      if (!(start < stop) || !(step > 0)) return range; // also handles Invalid Date
+      offseti(start, 1), floori(start);
+      if (start < stop) range.push(new Date(+start));
+      while (offseti(start, step), floori(start), start < stop) range.push(new Date(+start));
+      return range;
+    };
+
+    interval.filter = function(test) {
+      return newInterval(function(date) {
+        while (floori(date), !test(date)) date.setTime(date - 1);
+      }, function(date, step) {
+        while (--step >= 0) while (offseti(date, 1), !test(date));
+      });
+    };
+
+    if (count) interval.count = function(start, end) {
+      t0.setTime(+start), t1.setTime(+end);
+      floori(t0), floori(t1);
+      return Math.floor(count(t0, t1));
+    };
+
+    return interval;
+  }
+
+  var second = newInterval(function(date) {
+    date.setMilliseconds(0);
+  }, function(date, step) {
+    date.setTime(+date + step * 1e3);
+  }, function(start, end) {
+    return (end - start) / 1e3;
+  });
+
+  exports.seconds = second.range;
+
+  var minute = newInterval(function(date) {
+    date.setSeconds(0, 0);
+  }, function(date, step) {
+    date.setTime(+date + step * 6e4);
+  }, function(start, end) {
+    return (end - start) / 6e4;
+  });
+
+  exports.minutes = minute.range;
+
+  var hour = newInterval(function(date) {
+    date.setMinutes(0, 0, 0);
+  }, function(date, step) {
+    date.setTime(+date + step * 36e5);
+  }, function(start, end) {
+    return (end - start) / 36e5;
+  });
+
+  exports.hours = hour.range;
+
+  var day = newInterval(function(date) {
+    date.setHours(0, 0, 0, 0);
+  }, function(date, step) {
+    date.setDate(date.getDate() + step);
+  }, function(start, end) {
+    return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * 6e4) / 864e5;
+  });
+
+  exports.days = day.range;
+
+  function weekday(i) {
+    return newInterval(function(date) {
+      date.setHours(0, 0, 0, 0);
+      date.setDate(date.getDate() - (date.getDay() + 7 - i) % 7);
+    }, function(date, step) {
+      date.setDate(date.getDate() + step * 7);
+    }, function(start, end) {
+      return (end - start - (end.getTimezoneOffset() - start.getTimezoneOffset()) * 6e4) / 6048e5;
+    });
+  }
+
+  exports.sunday = weekday(0);
+
+  exports.sundays = exports.sunday.range;
+
+  exports.monday = weekday(1);
+
+  exports.mondays = exports.monday.range;
+
+  exports.tuesday = weekday(2);
+
+  exports.tuesdays = exports.tuesday.range;
+
+  exports.wednesday = weekday(3);
+
+  exports.wednesdays = exports.wednesday.range;
+
+  exports.thursday = weekday(4);
+
+  exports.thursdays = exports.thursday.range;
+
+  exports.friday = weekday(5);
+
+  exports.fridays = exports.friday.range;
+
+  exports.saturday = weekday(6);
+
+  exports.saturdays = exports.saturday.range;
+
+  var week = exports.sunday;
+
+  exports.weeks = week.range;
+
+  var month = newInterval(function(date) {
+    date.setHours(0, 0, 0, 0);
+    date.setDate(1);
+  }, function(date, step) {
+    date.setMonth(date.getMonth() + step);
+  }, function(start, end) {
+    return end.getMonth() - start.getMonth() + (end.getFullYear() - start.getFullYear()) * 12;
+  });
+
+  exports.months = month.range;
+
+  var year = newInterval(function(date) {
+    date.setHours(0, 0, 0, 0);
+    date.setMonth(0, 1);
+  }, function(date, step) {
+    date.setFullYear(date.getFullYear() + step);
+  }, function(start, end) {
+    return end.getFullYear() - start.getFullYear();
+  });
+
+  exports.years = year.range;
+
+  var utcSecond = newInterval(function(date) {
+    date.setUTCMilliseconds(0);
+  }, function(date, step) {
+    date.setTime(+date + step * 1e3);
+  }, function(start, end) {
+    return (end - start) / 1e3;
+  });
+
+  exports.utcSeconds = utcSecond.range;
+
+  var utcMinute = newInterval(function(date) {
+    date.setUTCSeconds(0, 0);
+  }, function(date, step) {
+    date.setTime(+date + step * 6e4);
+  }, function(start, end) {
+    return (end - start) / 6e4;
+  });
+
+  exports.utcMinutes = utcMinute.range;
+
+  var utcHour = newInterval(function(date) {
+    date.setUTCMinutes(0, 0, 0);
+  }, function(date, step) {
+    date.setTime(+date + step * 36e5);
+  }, function(start, end) {
+    return (end - start) / 36e5;
+  });
+
+  exports.utcHours = utcHour.range;
+
+  var utcDay = newInterval(function(date) {
+    date.setUTCHours(0, 0, 0, 0);
+  }, function(date, step) {
+    date.setUTCDate(date.getUTCDate() + step);
+  }, function(start, end) {
+    return (end - start) / 864e5;
+  });
+
+  exports.utcDays = utcDay.range;
+
+  function utcWeekday(i) {
+    return newInterval(function(date) {
+      date.setUTCHours(0, 0, 0, 0);
+      date.setUTCDate(date.getUTCDate() - (date.getUTCDay() + 7 - i) % 7);
+    }, function(date, step) {
+      date.setUTCDate(date.getUTCDate() + step * 7);
+    }, function(start, end) {
+      return (end - start) / 6048e5;
+    });
+  }
+
+  exports.utcSunday = utcWeekday(0);
+
+  exports.utcSundays = exports.utcSunday.range;
+
+  exports.utcMonday = utcWeekday(1);
+
+  exports.utcMondays = exports.utcMonday.range;
+
+  exports.utcTuesday = utcWeekday(2);
+
+  exports.utcTuesdays = exports.utcTuesday.range;
+
+  exports.utcWednesday = utcWeekday(3);
+
+  exports.utcWednesdays = exports.utcWednesday.range;
+
+  exports.utcThursday = utcWeekday(4);
+
+  exports.utcThursdays = exports.utcThursday.range;
+
+  exports.utcFriday = utcWeekday(5);
+
+  exports.utcFridays = exports.utcFriday.range;
+
+  exports.utcSaturday = utcWeekday(6);
+
+  exports.utcSaturdays = exports.utcSaturday.range;
+
+  var utcWeek = exports.utcSunday;
+
+  exports.utcWeeks = utcWeek.range;
+
+  var utcMonth = newInterval(function(date) {
+    date.setUTCHours(0, 0, 0, 0);
+    date.setUTCDate(1);
+  }, function(date, step) {
+    date.setUTCMonth(date.getUTCMonth() + step);
+  }, function(start, end) {
+    return end.getUTCMonth() - start.getUTCMonth() + (end.getUTCFullYear() - start.getUTCFullYear()) * 12;
+  });
+
+  exports.utcMonths = utcMonth.range;
+
+  var utcYear = newInterval(function(date) {
+    date.setUTCHours(0, 0, 0, 0);
+    date.setUTCMonth(0, 1);
+  }, function(date, step) {
+    date.setUTCFullYear(date.getUTCFullYear() + step);
+  }, function(start, end) {
+    return end.getUTCFullYear() - start.getUTCFullYear();
+  });
+
+  exports.utcYears = utcYear.range;
+
+  exports.interval = newInterval;
+  exports.second = second;
+  exports.minute = minute;
+  exports.hour = hour;
+  exports.day = day;
+  exports.week = week;
+  exports.month = month;
+  exports.year = year;
+  exports.utcSecond = utcSecond;
+  exports.utcMinute = utcMinute;
+  exports.utcHour = utcHour;
+  exports.utcDay = utcDay;
+  exports.utcWeek = utcWeek;
+  exports.utcMonth = utcMonth;
+  exports.utcYear = utcYear;
+
+}));
+},{}],7:[function(require,module,exports){
+var util = require('../util'),
+    Measures = require('./measures'),
+    Collector = require('./collector');
+
+function Aggregator() {
+  this._cells = {};
+  this._aggr = [];
+  this._stream = false;
+}
+
+var Flags = Aggregator.Flags = {
+  ADD_CELL: 1,
+  MOD_CELL: 2
+};
+
+var proto = Aggregator.prototype;
+
+// Parameters
+
+proto.stream = function(v) {
+  if (v == null) return this._stream;
+  this._stream = !!v;
+  this._aggr = [];
+  return this;
+};
+
+// key accessor to use for streaming removes
+proto.key = function(key) {
+  if (key == null) return this._key;
+  this._key = util.$(key);
+  return this;
+};
+
+// Input: array of objects of the form
+// {name: string, get: function}
+proto.groupby = function(dims) {
+  this._dims = util.array(dims).map(function(d, i) {
+    d = util.isString(d) ? {name: d, get: util.$(d)}
+      : util.isFunction(d) ? {name: util.name(d) || d.name || ('_' + i), get: d}
+      : (d.name && util.isFunction(d.get)) ? d : null;
+    if (d == null) throw 'Invalid groupby argument: ' + d;
+    return d;
+  });
+  return this.clear();
+};
+
+// Input: array of objects of the form
+// {name: string, ops: [string, ...]}
+proto.summarize = function(fields) {
+  fields = summarize_args(fields);
+  this._count = true;
+  var aggr = (this._aggr = []),
+      m, f, i, j, op, as, get;
+
+  for (i=0; i<fields.length; ++i) {
+    for (j=0, m=[], f=fields[i]; j<f.ops.length; ++j) {
+      op = f.ops[j];
+      if (op !== 'count') this._count = false;
+      as = (f.as && f.as[j]) || (op + (f.name==='*' ? '' : '_'+f.name));
+      m.push(Measures[op](as));
+    }
+    get = f.get && util.$(f.get) ||
+      (f.name === '*' ? util.identity : util.$(f.name));
+    aggr.push({
+      name: f.name,
+      measures: Measures.create(
+        m,
+        this._stream, // streaming remove flag
+        get,          // input tuple getter
+        this._assign) // output tuple setter
+    });
+  }
+  return this.clear();
+};
+
+// Convenience method to summarize by count
+proto.count = function() {
+  return this.summarize({'*':'count'});
+};
+
+// Override to perform custom tuple value assignment
+proto._assign = function(object, name, value) {
+  object[name] = value;
+};
+
+function summarize_args(fields) {
+  if (util.isArray(fields)) { return fields; }
+  if (fields == null) { return []; }
+  var a = [], name, ops;
+  for (name in fields) {
+    ops = util.array(fields[name]);
+    a.push({name: name, ops: ops});
+  }
+  return a;
+}
+
+// Cell Management
+
+proto.clear = function() {
+  return (this._cells = {}, this);
+};
+
+proto._cellkey = function(x) {
+  var d = this._dims,
+      n = d.length, i,
+      k = String(d[0].get(x));
+  for (i=1; i<n; ++i) {
+    k += '|' + d[i].get(x);
+  }
+  return k;
+};
+
+proto._cell = function(x) {
+  var key = this._dims.length ? this._cellkey(x) : '';
+  return this._cells[key] || (this._cells[key] = this._newcell(x, key));
+};
+
+proto._newcell = function(x, key) {
+  var cell = {
+    num:   0,
+    tuple: this._newtuple(x, key),
+    flag:  Flags.ADD_CELL,
+    aggs:  {}
+  };
+
+  var aggr = this._aggr, i;
+  for (i=0; i<aggr.length; ++i) {
+    cell.aggs[aggr[i].name] = new aggr[i].measures(cell, cell.tuple);
+  }
+  if (cell.collect) {
+    cell.data = new Collector(this._key);
+  }
+  return cell;
+};
+
+proto._newtuple = function(x) {
+  var dims = this._dims,
+      t = {}, i, n;
+  for (i=0, n=dims.length; i<n; ++i) {
+    t[dims[i].name] = dims[i].get(x);
+  }
+  return this._ingest(t);
+};
+
+// Override to perform custom tuple ingestion
+proto._ingest = util.identity;
+
+// Process Tuples
+
+proto._add = function(x) {
+  var cell = this._cell(x),
+      aggr = this._aggr, i;
+
+  cell.num += 1;
+  if (!this._count) { // skip if count-only
+    if (cell.collect) cell.data.add(x);
+    for (i=0; i<aggr.length; ++i) {
+      cell.aggs[aggr[i].name].add(x);
+    }
+  }
+  cell.flag |= Flags.MOD_CELL;
+  if (this._on_add) this._on_add(x, cell);
+};
+
+proto._rem = function(x) {
+  var cell = this._cell(x),
+      aggr = this._aggr, i;
+
+  cell.num -= 1;
+  if (!this._count) { // skip if count-only
+    if (cell.collect) cell.data.rem(x);
+    for (i=0; i<aggr.length; ++i) {
+      cell.aggs[aggr[i].name].rem(x);
+    }
+  }
+  cell.flag |= Flags.MOD_CELL;
+  if (this._on_rem) this._on_rem(x, cell);
+};
+
+proto._mod = function(curr, prev) {
+  var cell0 = this._cell(prev),
+      cell1 = this._cell(curr),
+      aggr = this._aggr, i;
+
+  if (cell0 !== cell1) {
+    cell0.num -= 1;
+    cell1.num += 1;
+    if (cell0.collect) cell0.data.rem(prev);
+    if (cell1.collect) cell1.data.add(curr);
+  } else if (cell0.collect && !util.isObject(curr)) {
+    cell0.data.rem(prev);
+    cell0.data.add(curr);
+  }
+
+  for (i=0; i<aggr.length; ++i) {
+    cell0.aggs[aggr[i].name].rem(prev);
+    cell1.aggs[aggr[i].name].add(curr);
+  }
+  cell0.flag |= Flags.MOD_CELL;
+  cell1.flag |= Flags.MOD_CELL;
+  if (this._on_mod) this._on_mod(curr, prev, cell0, cell1);
+};
+
+proto.result = function() {
+  var result = [],
+      aggr = this._aggr,
+      cell, i, k;
+
+  for (k in this._cells) {
+    cell = this._cells[k];
+    if (cell.num > 0) {
+      // consolidate collector values
+      if (cell.collect) {
+        cell.data.values();
+      }
+      // update tuple properties
+      for (i=0; i<aggr.length; ++i) {
+        cell.aggs[aggr[i].name].set();
+      }
+      // add output tuple
+      result.push(cell.tuple);
+    } else {
+      delete this._cells[k];
+    }
+    cell.flag = 0;
+  }
+
+  this._rems = false;
+  return result;
+};
+
+proto.changes = function(output) {
+  var changes = output || {add:[], rem:[], mod:[]},
+      aggr = this._aggr,
+      cell, flag, i, k;
+
+  for (k in this._cells) {
+    cell = this._cells[k];
+    flag = cell.flag;
+
+    // consolidate collector values
+    if (cell.collect) {
+      cell.data.values();
+    }
+
+    // update tuple properties
+    for (i=0; i<aggr.length; ++i) {
+      cell.aggs[aggr[i].name].set();
+    }
+
+    // organize output tuples
+    if (cell.num <= 0) {
+      changes.rem.push(cell.tuple); // if (flag === Flags.MOD_CELL) { ??
+      delete this._cells[k];
+      if (this._on_drop) this._on_drop(cell);
+    } else {
+      if (this._on_keep) this._on_keep(cell);
+      if (flag & Flags.ADD_CELL) {
+        changes.add.push(cell.tuple);
+      } else if (flag & Flags.MOD_CELL) {
+        changes.mod.push(cell.tuple);
+      }
+    }
+
+    cell.flag = 0;
+  }
+
+  this._rems = false;
+  return changes;
+};
+
+proto.execute = function(input) {
+  return this.clear().insert(input).result();
+};
+
+proto.insert = function(input) {
+  this._consolidate();
+  for (var i=0; i<input.length; ++i) {
+    this._add(input[i]);
+  }
+  return this;
+};
+
+proto.remove = function(input) {
+  if (!this._stream) {
+    throw 'Aggregator not configured for streaming removes.' +
+      ' Call stream(true) prior to calling summarize.';
+  }
+  for (var i=0; i<input.length; ++i) {
+    this._rem(input[i]);
+  }
+  this._rems = true;
+  return this;
+};
+
+// consolidate removals
+proto._consolidate = function() {
+  if (!this._rems) return;
+  for (var k in this._cells) {
+    if (this._cells[k].collect) {
+      this._cells[k].data.values();
+    }
+  }
+  this._rems = false;
+};
+
+module.exports = Aggregator;
+},{"../util":29,"./collector":8,"./measures":10}],8:[function(require,module,exports){
+var util = require('../util');
+var stats = require('../stats');
+
+var REM = '__dl_rem__';
+
+function Collector(key) {
+  this._add = [];
+  this._rem = [];
+  this._key = key || null;
+  this._last = null;
+}
+
+var proto = Collector.prototype;
+
+proto.add = function(v) {
+  this._add.push(v);
+};
+
+proto.rem = function(v) {
+  this._rem.push(v);
+};
+
+proto.values = function() {
+  this._get = null;
+  if (this._rem.length === 0) return this._add;
+
+  var a = this._add,
+      r = this._rem,
+      k = this._key,
+      x = Array(a.length - r.length),
+      i, j, n, m;
+
+  if (!util.isObject(r[0])) {
+    // processing raw values
+    m = stats.count.map(r);
+    for (i=0, j=0, n=a.length; i<n; ++i) {
+      if (m[a[i]] > 0) {
+        m[a[i]] -= 1;
+      } else {
+        x[j++] = a[i];
+      }
+    }
+  } else if (k) {
+    // has unique key field, so use that
+    m = util.toMap(r, k);
+    for (i=0, j=0, n=a.length; i<n; ++i) {
+      if (!m.hasOwnProperty(k(a[i]))) { x[j++] = a[i]; }
+    }
+  } else {
+    // no unique key, mark tuples directly
+    for (i=0, n=r.length; i<n; ++i) {
+      r[i][REM] = 1;
+    }
+    for (i=0, j=0, n=a.length; i<n; ++i) {
+      if (!a[i][REM]) { x[j++] = a[i]; }
+    }
+    for (i=0, n=r.length; i<n; ++i) {
+      delete r[i][REM];
+    }
+  }
+
+  this._rem = [];
+  return (this._add = x);
+};
+
+// memoizing statistics methods
+
+proto.extent = function(get) {
+  if (this._get !== get || !this._ext) {
+    var v = this.values(),
+        i = stats.extent.index(v, get);
+    this._ext = [v[i[0]], v[i[1]]];
+    this._get = get;    
+  }
+  return this._ext;
+};
+
+proto.argmin = function(get) {
+  return this.extent(get)[0];
+};
+
+proto.argmax = function(get) {
+  return this.extent(get)[1];
+};
+
+proto.min = function(get) {
+  var m = this.extent(get)[0];
+  return m ? get(m) : +Infinity;
+};
+
+proto.max = function(get) {
+  var m = this.extent(get)[1];
+  return m ? get(m) : -Infinity;
+};
+
+proto.quartile = function(get) {
+  if (this._get !== get || !this._q) {
+    this._q = stats.quartile(this.values(), get);
+    this._get = get;    
+  }
+  return this._q;
+};
+
+proto.q1 = function(get) {
+  return this.quartile(get)[0];
+};
+
+proto.q2 = function(get) {
+  return this.quartile(get)[1];
+};
+
+proto.q3 = function(get) {
+  return this.quartile(get)[2];
+};
+
+module.exports = Collector;
+
+},{"../stats":26,"../util":29}],9:[function(require,module,exports){
+var util = require('../util');
+var Aggregator = require('./aggregator');
+
+module.exports = function() {
+  // flatten arguments into a single array
+  var args = [].reduce.call(arguments, function(a, x) {
+    return a.concat(util.array(x));
+  }, []);
+  // create and return an aggregator
+  return new Aggregator()
+    .groupby(args)
+    .summarize({'*':'values'});
+};
+
+},{"../util":29,"./aggregator":7}],10:[function(require,module,exports){
+var util = require('../util');
+
+var types = {
+  'values': measure({
+    name: 'values',
+    init: 'cell.collect = true;',
+    set:  'cell.data.values()', idx: -1
+  }),
+  'count': measure({
+    name: 'count',
+    set:  'cell.num'
+  }),
+  'missing': measure({
+    name: 'missing',
+    set:  'this.missing'
+  }),
+  'valid': measure({
+    name: 'valid',
+    set:  'this.valid'
+  }),
+  'sum': measure({
+    name: 'sum',
+    init: 'this.sum = 0;',
+    add:  'this.sum += v;',
+    rem:  'this.sum -= v;',
+    set:  'this.sum'
+  }),
+  'mean': measure({
+    name: 'mean',
+    init: 'this.mean = 0;',
+    add:  'var d = v - this.mean; this.mean += d / this.valid;',
+    rem:  'var d = v - this.mean; this.mean -= this.valid ? d / this.valid : this.mean;',
+    set:  'this.mean'
+  }),
+  'average': measure({
+    name: 'average',
+    set:  'this.mean',
+    req:  ['mean'], idx: 1
+  }),
+  'variance': measure({
+    name: 'variance',
+    init: 'this.dev = 0;',
+    add:  'this.dev += d * (v - this.mean);',
+    rem:  'this.dev -= d * (v - this.mean);',
+    set:  'this.valid > 1 ? this.dev / (this.valid-1) : 0',
+    req:  ['mean'], idx: 1
+  }),
+  'variancep': measure({
+    name: 'variancep',
+    set:  'this.valid > 1 ? this.dev / this.valid : 0',
+    req:  ['variance'], idx: 2
+  }),
+  'stdev': measure({
+    name: 'stdev',
+    set:  'this.valid > 1 ? Math.sqrt(this.dev / (this.valid-1)) : 0',
+    req:  ['variance'], idx: 2
+  }),
+  'stdevp': measure({
+    name: 'stdevp',
+    set:  'this.valid > 1 ? Math.sqrt(this.dev / this.valid) : 0',
+    req:  ['variance'], idx: 2
+  }),
+  'median': measure({
+    name: 'median',
+    set:  'cell.data.q2(this.get)',
+    req:  ['values'], idx: 3
+  }),
+  'q1': measure({
+    name: 'q1',
+    set:  'cell.data.q1(this.get)',
+    req:  ['values'], idx: 3
+  }),
+  'q3': measure({
+    name: 'q3',
+    set:  'cell.data.q3(this.get)',
+    req:  ['values'], idx: 3
+  }),
+  'distinct': measure({
+    name: 'distinct',
+    set:  'this.distinct(cell.data.values(), this.get)',
+    req:  ['values'], idx: 3
+  }),
+  'argmin': measure({
+    name: 'argmin',
+    add:  'if (v < this.min) this.argmin = t;',
+    rem:  'if (v <= this.min) this.argmin = null;',
+    set:  'this.argmin = this.argmin || cell.data.argmin(this.get)',
+    req:  ['min'], str: ['values'], idx: 3
+  }),
+  'argmax': measure({
+    name: 'argmax',
+    add:  'if (v > this.max) this.argmax = t;',
+    rem:  'if (v >= this.max) this.argmax = null;',
+    set:  'this.argmax = this.argmax || cell.data.argmax(this.get)',
+    req:  ['max'], str: ['values'], idx: 3
+  }),
+  'min': measure({
+    name: 'min',
+    init: 'this.min = +Infinity;',
+    add:  'if (v < this.min) this.min = v;',
+    rem:  'if (v <= this.min) this.min = NaN;',
+    set:  'this.min = (isNaN(this.min) ? cell.data.min(this.get) : this.min)',
+    str:  ['values'], idx: 4
+  }),
+  'max': measure({
+    name: 'max',
+    init: 'this.max = -Infinity;',
+    add:  'if (v > this.max) this.max = v;',
+    rem:  'if (v >= this.max) this.max = NaN;',
+    set:  'this.max = (isNaN(this.max) ? cell.data.max(this.get) : this.max)',
+    str:  ['values'], idx: 4
+  }),
+  'modeskew': measure({
+    name: 'modeskew',
+    set:  'this.dev===0 ? 0 : (this.mean - cell.data.q2(this.get)) / Math.sqrt(this.dev/(this.valid-1))',
+    req:  ['mean', 'stdev', 'median'], idx: 5
+  })
+};
+
+function measure(base) {
+  return function(out) {
+    var m = util.extend({init:'', add:'', rem:'', idx:0}, base);
+    m.out = out || base.name;
+    return m;
+  };
+}
+
+function resolve(agg, stream) {
+  function collect(m, a) {
+    function helper(r) { if (!m[r]) collect(m, m[r] = types[r]()); }
+    if (a.req) a.req.forEach(helper);
+    if (stream && a.str) a.str.forEach(helper);
+    return m;
+  }
+  var map = agg.reduce(
+    collect,
+    agg.reduce(function(m, a) { return (m[a.name] = a, m); }, {})
+  );
+  return util.vals(map).sort(function(a, b) { return a.idx - b.idx; });
+}
+
+function create(agg, stream, accessor, mutator) {
+  var all = resolve(agg, stream),
+      ctr = 'this.cell = cell; this.tuple = t; this.valid = 0; this.missing = 0;',
+      add = 'if (v==null) this.missing++; if (!this.isValid(v)) return; ++this.valid;',
+      rem = 'if (v==null) this.missing--; if (!this.isValid(v)) return; --this.valid;',
+      set = 'var t = this.tuple; var cell = this.cell;';
+
+  all.forEach(function(a) {
+    if (a.idx < 0) {
+      ctr = a.init + ctr;
+      add = a.add + add;
+      rem = a.rem + rem;
+    } else {
+      ctr += a.init;
+      add += a.add;
+      rem += a.rem;
+    }
+  });
+  agg.slice()
+    .sort(function(a, b) { return a.idx - b.idx; })
+    .forEach(function(a) {
+      set += 'this.assign(t,\''+a.out+'\','+a.set+');';
+    });
+  set += 'return t;';
+
+  /* jshint evil: true */
+  ctr = Function('cell', 't', ctr);
+  ctr.prototype.assign = mutator;
+  ctr.prototype.add = Function('t', 'var v = this.get(t);' + add);
+  ctr.prototype.rem = Function('t', 'var v = this.get(t);' + rem);
+  ctr.prototype.set = Function(set);
+  ctr.prototype.get = accessor;
+  ctr.prototype.distinct = require('../stats').count.distinct;
+  ctr.prototype.isValid = util.isValid;
+  ctr.fields = agg.map(util.$('out'));
+  return ctr;
+}
+
+types.create = create;
+module.exports = types;
+},{"../stats":26,"../util":29}],11:[function(require,module,exports){
+var util = require('../util'),
+    time = require('../time'),
+    EPSILON = 1e-15;
+
+function bins(opt) {
+  if (!opt) { throw Error("Missing binning options."); }
+
+  // determine range
+  var maxb = opt.maxbins || 15,
+      base = opt.base || 10,
+      logb = Math.log(base),
+      div = opt.div || [5, 2],      
+      min = opt.min,
+      max = opt.max,
+      span = max - min,
+      step, level, minstep, precision, v, i, eps;
+
+  if (opt.step) {
+    // if step size is explicitly given, use that
+    step = opt.step;
+  } else if (opt.steps) {
+    // if provided, limit choice to acceptable step sizes
+    step = opt.steps[Math.min(
+      opt.steps.length - 1,
+      bisect(opt.steps, span/maxb, 0, opt.steps.length)
+    )];
+  } else {
+    // else use span to determine step size
+    level = Math.ceil(Math.log(maxb) / logb);
+    minstep = opt.minstep || 0;
+    step = Math.max(
+      minstep,
+      Math.pow(base, Math.round(Math.log(span) / logb) - level)
+    );
+    
+    // increase step size if too many bins
+    do { step *= base; } while (Math.ceil(span/step) > maxb);
+
+    // decrease step size if allowed
+    for (i=0; i<div.length; ++i) {
+      v = step / div[i];
+      if (v >= minstep && span / v <= maxb) step = v;
+    }
+  }
+
+  // update precision, min and max
+  v = Math.log(step);
+  precision = v >= 0 ? 0 : ~~(-v / logb) + 1;
+  eps = Math.pow(base, -precision - 1);
+  min = Math.min(min, Math.floor(min / step + eps) * step);
+  max = Math.ceil(max / step) * step;
+
+  return {
+    start: min,
+    stop:  max,
+    step:  step,
+    unit:  {precision: precision},
+    value: value,
+    index: index
+  };
+}
+
+function bisect(a, x, lo, hi) {
+  while (lo < hi) {
+    var mid = lo + hi >>> 1;
+    if (util.cmp(a[mid], x) < 0) { lo = mid + 1; }
+    else { hi = mid; }
+  }
+  return lo;
+}
+
+function value(v) {
+  return this.step * Math.floor(v / this.step + EPSILON);
+}
+
+function index(v) {
+  return Math.floor((v - this.start) / this.step + EPSILON);
+}
+
+function date_value(v) {
+  return this.unit.date(value.call(this, v));
+}
+
+function date_index(v) {
+  return index.call(this, this.unit.unit(v));
+}
+
+bins.date = function(opt) {
+  if (!opt) { throw Error("Missing date binning options."); }
+
+  // find time step, then bin
+  var units = opt.utc ? time.utc : time,
+      dmin = opt.min,
+      dmax = opt.max,
+      maxb = opt.maxbins || 20,
+      minb = opt.minbins || 4,
+      span = (+dmax) - (+dmin),
+      unit = opt.unit ? units[opt.unit] : units.find(span, minb, maxb),
+      spec = bins({
+        min:     unit.min != null ? unit.min : unit.unit(dmin),
+        max:     unit.max != null ? unit.max : unit.unit(dmax),
+        maxbins: maxb,
+        minstep: unit.minstep,
+        steps:   unit.step
+      });
+
+  spec.unit = unit;
+  spec.index = date_index;
+  if (!opt.raw) spec.value = date_value;
+  return spec;
+};
+
+module.exports = bins;
+
+},{"../time":28,"../util":29}],12:[function(require,module,exports){
+var bins = require('./bins'),
+    gen  = require('../generate'),
+    type = require('../import/type'),
+    util = require('../util'),
+    stats = require('../stats');
+
+var qtype = {
+  'integer': 1,
+  'number': 1,
+  'date': 1
+};
+
+function $bin(values, f, opt) {
+  opt = options(values, f, opt);
+  var b = spec(opt);
+  return !b ? (opt.accessor || util.identity) :
+    util.$func('bin', b.unit.unit ?
+      function(x) { return b.value(b.unit.unit(x)); } :
+      function(x) { return b.value(x); }
+    )(opt.accessor);
+}
+
+function histogram(values, f, opt) {
+  opt = options(values, f, opt);
+  var b = spec(opt);
+  return b ?
+    numerical(values, opt.accessor, b) :
+    categorical(values, opt.accessor, opt && opt.sort);
+}
+
+function spec(opt) {
+  var t = opt.type, b = null;
+  if (t == null || qtype[t]) {
+    if (t === 'integer' && opt.minstep == null) opt.minstep = 1;
+    b = (t === 'date') ? bins.date(opt) : bins(opt);
+  }
+  return b;
+}
+
+function options() {
+  var a = arguments,
+      i = 0,
+      values = util.isArray(a[i]) ? a[i++] : null,
+      f = util.isFunction(a[i]) || util.isString(a[i]) ? util.$(a[i++]) : null,
+      opt = util.extend({}, a[i]);
+  
+  if (values) {
+    opt.type = opt.type || type(values, f);
+    if (qtype[opt.type]) {
+      var ext = stats.extent(values, f);
+      opt = util.extend({min: ext[0], max: ext[1]}, opt);
+    }
+  }
+  if (f) { opt.accessor = f; }
+  return opt;
+}
+
+function numerical(values, f, b) {
+  var h = gen.range(b.start, b.stop + b.step/2, b.step)
+    .map(function(v) { return {value: b.value(v), count: 0}; });
+
+  for (var i=0, v, j; i<values.length; ++i) {
+    v = f ? f(values[i]) : values[i];
+    if (util.isValid(v)) {
+      j = b.index(v);
+      if (j < 0 || j >= h.length || !isFinite(j)) continue;
+      h[j].count += 1;
+    }
+  }
+  h.bins = b;
+  return h;
+}
+
+function categorical(values, f, sort) {
+  var u = stats.unique(values, f),
+      c = stats.count.map(values, f);
+  return u.map(function(k) { return {value: k, count: c[k]}; })
+    .sort(util.comparator(sort ? '-count' : '+value'));
+}
+
+module.exports = {
+  $bin: $bin,
+  histogram: histogram
+};
+},{"../generate":14,"../import/type":23,"../stats":26,"../util":29,"./bins":11}],13:[function(require,module,exports){
+var d3_time = require('d3-time'),
+    d3_timeF = require('d3-time-format'),
+    d3_numberF = require('d3-format'),
+    numberF = d3_numberF, // defaults to EN-US
+    timeF = d3_timeF;     // defaults to EN-US
+
+function numberLocale(l) {
+  var f = d3_numberF.localeFormat(l);
+  if (f == null) throw Error('Unrecognized locale: ' + l);
+  numberF = f;
+}
+
+function timeLocale(l) {
+  var f = d3_timeF.localeFormat(l);
+  if (f == null) throw Error('Unrecognized locale: ' + l);
+  timeF = f;
+}
+
+module.exports = {
+  // Update number formatter to use provided locale configuration.
+  // For more see https://github.com/d3/d3-format
+  numberLocale: numberLocale,
+  number:       function(f) { return numberF.format(f); },
+  numberPrefix: function(f, v) { return numberF.formatPrefix(f, v); },
+
+  // Update time formatter to use provided locale configuration.
+  // For more see https://github.com/d3/d3-time-format
+  timeLocale:   timeLocale,
+  time:         function(f) { return timeF.format(f); },  
+  utc:          function(f) { return timeF.utcFormat(f); },
+
+  // Set number and time locale simultaneously.
+  locale:       function(l) { numberLocale(l); timeLocale(l); },
+
+  // automatic formatting functions
+  auto: {
+    number:   numberAutoFormat,
+    time:     function() { return timeAutoFormat(); },
+    utc:      function() { return utcAutoFormat(); }
+  }
+};
+
+var e10 = Math.sqrt(50),
+    e5 = Math.sqrt(10),
+    e2 = Math.sqrt(2);
+
+function intervals(domain, count) {
+  if (!domain.length) domain = [0];
+  if (count == null) count = 10;
+
+  var start = domain[0],
+      stop = domain[domain.length - 1];
+
+  if (stop < start) { error = stop; stop = start; start = error; }
+
+  var span = (stop - start) || (count = 1, start || stop || 1),
+      step = Math.pow(10, Math.floor(Math.log(span / count) / Math.LN10)),
+      error = span / count / step;
+
+  // Filter ticks to get closer to the desired count.
+  if (error >= e10) step *= 10;
+  else if (error >= e5) step *= 5;
+  else if (error >= e2) step *= 2;
+
+  // Round start and stop values to step interval.
+  return [
+    Math.ceil(start / step) * step,
+    Math.floor(stop / step) * step + step / 2, // inclusive
+    step
+  ];
+}
+
+function numberAutoFormat(domain, count, f) {
+  var range = intervals(domain, count);
+  if (f == null) {
+    f = ',.' + d3_numberF.precisionFixed(range[2]) + 'f';
+  } else {
+    switch (f = d3_numberF.formatSpecifier(f), f.type) {
+      case 's': {
+        var value = Math.max(Math.abs(range[0]), Math.abs(range[1]));
+        if (f.precision == null) f.precision = d3_numberF.precisionPrefix(range[2], value);
+        return numberF.formatPrefix(f, value);
+      }
+      case '':
+      case 'e':
+      case 'g':
+      case 'p':
+      case 'r': {
+        if (f.precision == null) f.precision = d3_numberF.precisionRound(range[2], Math.max(Math.abs(range[0]), Math.abs(range[1]))) - (f.type === 'e');
+        break;
+      }
+      case 'f':
+      case '%': {
+        if (f.precision == null) f.precision = d3_numberF.precisionFixed(range[2]) - (f.type === '%') * 2;
+        break;
+      }
+    }
+  }
+  return numberF.format(f);
+}
+
+function timeAutoFormat() {
+  var f = timeF.format,
+      formatMillisecond = f('.%L'),
+      formatSecond = f(':%S'),
+      formatMinute = f('%I:%M'),
+      formatHour = f('%I %p'),
+      formatDay = f('%a %d'),
+      formatWeek = f('%b %d'),
+      formatMonth = f('%B'),
+      formatYear = f('%Y');
+
+  return function(date) {
+    var d = +date;
+    return (d3_time.second(date) < d ? formatMillisecond
+        : d3_time.minute(date) < d ? formatSecond
+        : d3_time.hour(date) < d ? formatMinute
+        : d3_time.day(date) < d ? formatHour
+        : d3_time.month(date) < d ?
+          (d3_time.week(date) < d ? formatDay : formatWeek)
+        : d3_time.year(date) < d ? formatMonth
+        : formatYear)(date);
+  };
+}
+
+function utcAutoFormat() {
+  var f = timeF.utcFormat,
+      formatMillisecond = f('.%L'),
+      formatSecond = f(':%S'),
+      formatMinute = f('%I:%M'),
+      formatHour = f('%I %p'),
+      formatDay = f('%a %d'),
+      formatWeek = f('%b %d'),
+      formatMonth = f('%B'),
+      formatYear = f('%Y');
+
+  return function(date) {
+    var d = +date;
+    return (d3_time.utcSecond(date) < d ? formatMillisecond
+        : d3_time.utcMinute(date) < d ? formatSecond
+        : d3_time.utcHour(date) < d ? formatMinute
+        : d3_time.utcDay(date) < d ? formatHour
+        : d3_time.utcMonth(date) < d ?
+          (d3_time.utcWeek(date) < d ? formatDay : formatWeek)
+        : d3_time.utcYear(date) < d ? formatMonth
+        : formatYear)(date);
+  };
+}
+
+},{"d3-format":4,"d3-time":6,"d3-time-format":5}],14:[function(require,module,exports){
+var gen = module.exports = {};
+
+gen.repeat = function(val, n) {
+  var a = Array(n), i;
+  for (i=0; i<n; ++i) a[i] = val;
+  return a;
+};
+
+gen.zeros = function(n) {
+  return gen.repeat(0, n);
+};
+
+gen.range = function(start, stop, step) {
+  if (arguments.length < 3) {
+    step = 1;
+    if (arguments.length < 2) {
+      stop = start;
+      start = 0;
+    }
+  }
+  if ((stop - start) / step == Infinity) throw new Error('Infinite range');
+  var range = [], i = -1, j;
+  if (step < 0) while ((j = start + step * ++i) > stop) range.push(j);
+  else while ((j = start + step * ++i) < stop) range.push(j);
+  return range;
+};
+
+gen.random = {};
+
+gen.random.uniform = function(min, max) {
+  if (max === undefined) {
+    max = min === undefined ? 1 : min;
+    min = 0;
+  }
+  var d = max - min;
+  var f = function() {
+    return min + d * Math.random();
+  };
+  f.samples = function(n) { return gen.zeros(n).map(f); };
+  return f;
+};
+
+gen.random.integer = function(a, b) {
+  if (b === undefined) {
+    b = a;
+    a = 0;
+  }
+  var d = b - a;
+  var f = function() {
+    return a + Math.floor(d * Math.random());
+  };
+  f.samples = function(n) { return gen.zeros(n).map(f); };
+  return f;
+};
+
+gen.random.normal = function(mean, stdev) {
+  mean = mean || 0;
+  stdev = stdev || 1;
+  var next;
+  var f = function() {
+    var x = 0, y = 0, rds, c;
+    if (next !== undefined) {
+      x = next;
+      next = undefined;
+      return x;
+    }
+    do {
+      x = Math.random()*2-1;
+      y = Math.random()*2-1;
+      rds = x*x + y*y;
+    } while (rds === 0 || rds > 1);
+    c = Math.sqrt(-2*Math.log(rds)/rds); // Box-Muller transform
+    next = mean + y*c*stdev;
+    return mean + x*c*stdev;
+  };
+  f.samples = function(n) { return gen.zeros(n).map(f); };
+  return f;
+};
+},{}],15:[function(require,module,exports){
+var util = require('../../util');
+var d3_dsv = require('d3-dsv');
+
+function dsv(data, format) {
+  if (data) {
+    var h = format.header;
+    data = (h ? h.join(format.delimiter) + '\n' : '') + data;
+  }
+  return d3_dsv.dsv(format.delimiter).parse(data);
+}
+
+dsv.delimiter = function(delim) {
+  var fmt = {delimiter: delim};
+  return function(data, format) {
+    return dsv(data, format ? util.extend(format, fmt) : fmt);
+  };
+};
+
+module.exports = dsv;
+},{"../../util":29,"d3-dsv":3}],16:[function(require,module,exports){
+var dsv = require('./dsv');
+
+module.exports = {
+  json: require('./json'),
+  topojson: require('./topojson'),
+  treejson: require('./treejson'),
+  dsv: dsv,
+  csv: dsv.delimiter(','),
+  tsv: dsv.delimiter('\t')
+};
+},{"./dsv":15,"./json":17,"./topojson":18,"./treejson":19}],17:[function(require,module,exports){
+var util = require('../../util');
+
+module.exports = function(data, format) {
+  var d = util.isObject(data) && !util.isBuffer(data) ?
+    data : JSON.parse(data);
+  if (format && format.property) {
+    d = util.accessor(format.property)(d);
+  }
+  return d;
+};
+
+},{"../../util":29}],18:[function(require,module,exports){
+(function (global){
+var json = require('./json');
+
+var reader = function(data, format) {
+  var topojson = reader.topojson;
+  if (topojson == null) { throw Error('TopoJSON library not loaded.'); }
+
+  var t = json(data, format), obj;
+
+  if (format && format.feature) {
+    if ((obj = t.objects[format.feature])) {
+      return topojson.feature(t, obj).features;
+    } else {
+      throw Error('Invalid TopoJSON object: ' + format.feature);
+    }
+  } else if (format && format.mesh) {
+    if ((obj = t.objects[format.mesh])) {
+      return [topojson.mesh(t, t.objects[format.mesh])];
+    } else {
+      throw Error('Invalid TopoJSON object: ' + format.mesh);
+    }
+  } else {
+    throw Error('Missing TopoJSON feature or mesh parameter.');
+  }
+};
+
+reader.topojson = (typeof window !== "undefined" ? window['topojson'] : typeof global !== "undefined" ? global['topojson'] : null);
+module.exports = reader;
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{"./json":17}],19:[function(require,module,exports){
+var json = require('./json');
+
+module.exports = function(data, format) {
+  data = json(data, format);
+  return toTable(data, (format && format.children));
+};
+
+function toTable(root, childrenField) {
+  childrenField = childrenField || 'children';
+  var table = [];
+  
+  function visit(node) {
+    table.push(node);
+    var children = node[childrenField];
+    if (children) {
+      for (var i=0; i<children.length; ++i) {
+        visit(children[i], node);
+      }
+    }
+  }
+  
+  visit(root, null);
+  return (table.root = root, table);
+}
+},{"./json":17}],20:[function(require,module,exports){
+// Matches absolute URLs with optional protocol
+//   https://...    file://...    //...
+var protocol_re = /^([A-Za-z]+:)?\/\//;
+
+// Special treatment in node.js for the file: protocol
+var fileProtocol = 'file://';
+
+// Validate and cleanup URL to ensure that it is allowed to be accessed
+// Returns cleaned up URL, or false if access is not allowed
+function sanitizeUrl(opt) {
+  var url = opt.url;
+  if (!url && opt.file) { return fileProtocol + opt.file; }
+
+  // In case this is a relative url (has no host), prepend opt.baseURL
+  if (opt.baseURL && !protocol_re.test(url)) {
+    if (!startsWith(url, '/') && opt.baseURL[opt.baseURL.length-1] !== '/') {
+      url = '/' + url; // Ensure that there is a slash between the baseURL (e.g. hostname) and url
+    }
+    url = opt.baseURL + url;
+  }
+  // relative protocol, starts with '//'
+  if (!load.useXHR && startsWith(url, '//')) {
+    url = (opt.defaultProtocol || 'http') + ':' + url;
+  }
+  // If opt.domainWhiteList is set, only allows url, whose hostname
+  // * Is the same as the origin (window.location.hostname)
+  // * Equals one of the values in the whitelist
+  // * Is a proper subdomain of one of the values in the whitelist
+  if (opt.domainWhiteList) {
+    var domain, origin;
+    if (load.useXHR) {
+      var a = document.createElement('a');
+      a.href = url;
+      // From http://stackoverflow.com/questions/736513/how-do-i-parse-a-url-into-hostname-and-path-in-javascript
+      // IE doesn't populate all link properties when setting .href with a relative URL,
+      // however .href will return an absolute URL which then can be used on itself
+      // to populate these additional fields.
+      if (a.host === '') {
+        a.href = a.href;
+      }
+      domain = a.hostname.toLowerCase();
+      origin = window.location.hostname;
+    } else {
+      // relative protocol is broken: https://github.com/defunctzombie/node-url/issues/5
+      var parts = require('url').parse(url);
+      domain = parts.hostname;
+      origin = null;
+    }
+
+    if (origin !== domain) {
+      var whiteListed = opt.domainWhiteList.some(function(d) {
+        var idx = domain.length - d.length;
+        return d === domain ||
+          (idx > 1 && domain[idx-1] === '.' && domain.lastIndexOf(d) === idx);
+      });
+      if (!whiteListed) {
+        throw 'URL is not whitelisted: ' + url;
+      }
+    }
+  }
+  return url;
+}
+
+function load(opt, callback) {
+  var error = callback || function(e) { throw e; }, url;
+
+  try {
+    url = load.sanitizeUrl(opt); // enable override
+  } catch (err) {
+    error(err);
+    return;
+  }
+
+  if (!url) {
+    error('Invalid URL: ' + opt.url);
+  } else if (load.useXHR) {
+    // on client, use xhr
+    return xhr(url, callback);
+  } else if (startsWith(url, fileProtocol)) {
+    // on server, if url starts with 'file://', strip it and load from file
+    return file(url.slice(fileProtocol.length), callback);
+  } else if (url.indexOf('://') < 0) { // TODO better protocol check?
+    // on server, if no protocol assume file
+    return file(url, callback);
+  } else {
+    // for regular URLs on server
+    return http(url, callback);
+  }
+}
+
+function xhrHasResponse(request) {
+  var type = request.responseType;
+  return type && type !== 'text' ?
+    request.response : // null on error
+    request.responseText; // '' on error
+}
+
+function xhr(url, callback) {
+  var async = !!callback;
+  var request = new XMLHttpRequest();
+  // If IE does not support CORS, use XDomainRequest (copied from d3.xhr)
+  if (this.XDomainRequest &&
+      !('withCredentials' in request) &&
+      /^(http(s)?:)?\/\//.test(url)) request = new XDomainRequest();
+
+  function respond() {
+    var status = request.status;
+    if (!status && xhrHasResponse(request) || status >= 200 && status < 300 || status === 304) {
+      callback(null, request.responseText);
+    } else {
+      callback(request, null);
+    }
+  }
+
+  if (async) {
+    if ('onload' in request) {
+      request.onload = request.onerror = respond;
+    } else {
+      request.onreadystatechange = function() {
+        if (request.readyState > 3) respond();
+      };
+    }
+  }
+  
+  request.open('GET', url, async);
+  request.send();
+  
+  if (!async && xhrHasResponse(request)) {
+    return request.responseText;
+  }
+}
+
+function file(filename, callback) {
+  var fs = require('fs');
+  if (!callback) {
+    return fs.readFileSync(filename, 'utf8');
+  }
+  fs.readFile(filename, callback);
+}
+
+function http(url, callback) {
+  if (!callback) {
+    return require('sync-request')('GET', url).getBody();
+  }
+  
+  var options = {url: url, encoding: null, gzip: true};
+  require('request')(options, function(error, response, body) {
+    if (!error && response.statusCode === 200) {
+      callback(null, body);
+    } else {
+      error = error ||
+        'Load failed with response code ' + response.statusCode + '.';
+      callback(error, null);
+    }
+  });
+}
+
+function startsWith(string, searchString) {
+  return string == null ? false : string.lastIndexOf(searchString, 0) === 0;
+}
+
+load.sanitizeUrl = sanitizeUrl;
+
+load.useXHR = (typeof XMLHttpRequest !== 'undefined');
+
+module.exports = load;
+
+},{"fs":2,"request":2,"sync-request":2,"url":2}],21:[function(require,module,exports){
+var util = require('../util');
+var type = require('./type');
+var formats = require('./formats');
+
+function read(data, format) {
+  var type = (format && format.type) || 'json';
+  data = formats[type](data, format);
+  if (format && format.parse) parse(data, format.parse);
+  return data;
+}
+
+function parse(data, types) {
+  var cols, parsers, d, i, j, clen, len = data.length;
+
+  types = (types==='auto') ? type.inferAll(data) : util.duplicate(types);
+  cols = util.keys(types);
+  parsers = cols.map(function(c) { return type.parsers[types[c]]; });
+
+  for (i=0, clen=cols.length; i<len; ++i) {
+    d = data[i];
+    for (j=0; j<clen; ++j) {
+      d[cols[j]] = parsers[j](d[cols[j]]);
+    }
+  }
+  type.annotation(data, types);
+}
+
+read.formats = formats;
+module.exports = read;
+
+},{"../util":29,"./formats":16,"./type":23}],22:[function(require,module,exports){
+var util = require('../util');
+var load = require('./load');
+var read = require('./read');
+
+module.exports = util
+  .keys(read.formats)
+  .reduce(function(out, type) {
+    out[type] = function(opt, format, callback) {
+      // process arguments
+      if (util.isString(opt)) { opt = {url: opt}; }
+      if (arguments.length === 2 && util.isFunction(format)) {
+        callback = format;
+        format = undefined;
+      }
+
+      // set up read format
+      format = util.extend({parse: 'auto'}, format);
+      format.type = type;
+
+      // load data
+      var data = load(opt, callback ? function(error, data) {
+        if (error) { callback(error, null); return; }
+        try {
+          // data loaded, now parse it (async)
+          data = read(data, format);
+          callback(null, data);
+        } catch (e) {
+          callback(e, null);
+        }
+      } : undefined);
+      
+      // data loaded, now parse it (sync)
+      if (!callback) return read(data, format);
+    };
+    return out;
+  }, {});
+
+},{"../util":29,"./load":20,"./read":21}],23:[function(require,module,exports){
+var util = require('../util');
+
+var TYPES = '__types__';
+
+var PARSERS = {
+  boolean: util.boolean,
+  integer: util.number,
+  number:  util.number,
+  date:    util.date,
+  string:  function(x) { return x==='' ? null : x; }
+};
+
+var TESTS = {
+  boolean: function(x) { return x==='true' || x==='false' || util.isBoolean(x); },
+  integer: function(x) { return TESTS.number(x) && (x=+x) === ~~x; },
+  number: function(x) { return !isNaN(+x) && !util.isDate(x); },
+  date: function(x) { return !isNaN(Date.parse(x)); }
+};
+
+function annotation(data, types) {
+  if (!types) return data && data[TYPES] || null;
+  data[TYPES] = types;
+}
+
+function type(values, f) {
+  f = util.$(f);
+  var v, i, n;
+
+  // if data array has type annotations, use them
+  if (values[TYPES]) {
+    v = f(values[TYPES]);
+    if (util.isString(v)) return v;
+  }
+
+  for (i=0, n=values.length; !util.isValid(v) && i<n; ++i) {
+    v = f ? f(values[i]) : values[i];
+  }
+
+  return util.isDate(v) ? 'date' :
+    util.isNumber(v)    ? 'number' :
+    util.isBoolean(v)   ? 'boolean' :
+    util.isString(v)    ? 'string' : null;
+}
+
+function typeAll(data, fields) {
+  if (!data.length) return;
+  fields = fields || util.keys(data[0]);
+  return fields.reduce(function(types, f) {
+    return (types[f] = type(data, f), types);
+  }, {});
+}
+
+function infer(values, f) {
+  f = util.$(f);
+  var i, j, v;
+
+  // types to test for, in precedence order
+  var types = ['boolean', 'integer', 'number', 'date'];
+
+  for (i=0; i<values.length; ++i) {
+    // get next value to test
+    v = f ? f(values[i]) : values[i];
+    // test value against remaining types
+    for (j=0; j<types.length; ++j) {
+      if (util.isValid(v) && !TESTS[types[j]](v)) {
+        types.splice(j, 1);
+        j -= 1;
+      }
+    }
+    // if no types left, return 'string'
+    if (types.length === 0) return 'string';
+  }
+
+  return types[0];
+}
+
+function inferAll(data, fields) {
+  fields = fields || util.keys(data[0]);
+  return fields.reduce(function(types, f) {
+    types[f] = infer(data, f);
+    return types;
+  }, {});
+}
+
+type.annotation = annotation;
+type.all = typeAll;
+type.infer = infer;
+type.inferAll = inferAll;
+type.parsers = PARSERS;
+module.exports = type;
+},{"../util":29}],24:[function(require,module,exports){
+var util = require('./util');
+
+var dl = {
+  version:    '1.4.6',
+  load:       require('./import/load'),
+  read:       require('./import/read'),
+  type:       require('./import/type'),
+  Aggregator: require('./aggregate/aggregator'),
+  groupby:    require('./aggregate/groupby'),
+  bins:       require('./bins/bins'),
+  $bin:       require('./bins/histogram').$bin,
+  histogram:  require('./bins/histogram').histogram,
+  format:     require('./format'),
+  print:      require('./print'),
+  template:   require('./template'),
+  time:       require('./time')
+};
+
+util.extend(dl, util);
+util.extend(dl, require('./generate'));
+util.extend(dl, require('./stats'));
+util.extend(dl, require('./import/readers'));
+
+module.exports = dl;
+},{"./aggregate/aggregator":7,"./aggregate/groupby":9,"./bins/bins":11,"./bins/histogram":12,"./format":13,"./generate":14,"./import/load":20,"./import/read":21,"./import/readers":22,"./import/type":23,"./print":25,"./stats":26,"./template":27,"./time":28,"./util":29}],25:[function(require,module,exports){
+var util = require('./util');
+var type = require('./import/type');
+var stats = require('./stats');
+var template = require('./template');
+
+var FMT = {
+  'date':    '|time:"%m/%d/%Y %H:%M:%S"',
+  'number':  '|number:".4f"',
+  'integer': '|number:"d"'
+};
+
+var POS = {
+  'number':  'left',
+  'integer': 'left'
+};
+
+module.exports.table = function(data, opt) {
+  opt = util.extend({separator:' ', minwidth: 8, maxwidth: 15}, opt);
+  var fields = opt.fields || util.keys(data[0]),
+      types = type.all(data);
+
+  if (opt.start || opt.limit) {
+    var a = opt.start || 0,
+        b = opt.limit ? a + opt.limit : data.length;
+    data = data.slice(a, b);
+  }
+
+  // determine char width of fields
+  var lens = fields.map(function(name) {
+    var format = FMT[types[name]] || '',
+        t = template('{{' + name + format + '}}'),
+        l = stats.max(data, function(x) { return t(x).length; });
+    l = Math.max(Math.min(name.length, opt.minwidth), l);
+    return opt.maxwidth > 0 ? Math.min(l, opt.maxwidth) : l;
+  });
+
+  // print header row
+  var head = fields.map(function(name, i) {
+    return util.truncate(util.pad(name, lens[i], 'center'), lens[i]);
+  }).join(opt.separator);
+
+  // build template function for each row
+  var tmpl = template(fields.map(function(name, i) {
+    return '{{' +
+      name +
+      (FMT[types[name]] || '') +
+      ('|pad:' + lens[i] + ',' + (POS[types[name]] || 'right')) +
+      ('|truncate:' + lens[i]) +
+    '}}';
+  }).join(opt.separator));
+
+  // print table
+  return head + "\n" + data.map(tmpl).join('\n');
+};
+
+module.exports.summary = function(s) {
+  s = s ? s.__summary__ ? s : stats.summary(s) : this;
+  var str = [], i, n;
+  for (i=0, n=s.length; i<n; ++i) {
+    str.push('-- ' + s[i].field + ' --');
+    if (s[i].type === 'string' || s[i].distinct < 10) {
+      str.push(printCategoricalProfile(s[i]));
+    } else {
+      str.push(printQuantitativeProfile(s[i]));
+    }
+    str.push('');
+  }
+  return str.join('\n');
+};
+
+function printQuantitativeProfile(p) {
+  return [
+    'valid:    ' + p.valid,
+    'missing:  ' + p.missing,
+    'distinct: ' + p.distinct,
+    'min:      ' + p.min,
+    'max:      ' + p.max,
+    'median:   ' + p.median,
+    'mean:     ' + p.mean,
+    'stdev:    ' + p.stdev,
+    'modeskew: ' + p.modeskew
+  ].join('\n');
+}
+
+function printCategoricalProfile(p) {
+  var list = [
+    'valid:    ' + p.valid,
+    'missing:  ' + p.missing,
+    'distinct: ' + p.distinct,
+    'top values: '
+  ];
+  var u = p.unique;
+  var top = util.keys(u)
+    .sort(function(a,b) { return u[b] - u[a]; })
+    .slice(0, 6)
+    .map(function(v) { return ' \'' + v + '\' (' + u[v] + ')'; });
+  return list.concat(top).join('\n');
+}
+},{"./import/type":23,"./stats":26,"./template":27,"./util":29}],26:[function(require,module,exports){
+var util = require('./util');
+var type = require('./import/type');
+var gen = require('./generate');
+var stats = {};
+
+// Collect unique values.
+// Output: an array of unique values, in first-observed order
+stats.unique = function(values, f, results) {
+  f = util.$(f);
+  results = results || [];
+  var u = {}, v, i, n;
+  for (i=0, n=values.length; i<n; ++i) {
+    v = f ? f(values[i]) : values[i];
+    if (v in u) continue;
+    u[v] = 1;
+    results.push(v);
+  }
+  return results;
+};
+
+// Return the length of the input array.
+stats.count = function(values) {
+  return values && values.length || 0;
+};
+
+// Count the number of non-null, non-undefined, non-NaN values.
+stats.count.valid = function(values, f) {
+  f = util.$(f);
+  var v, i, n, valid = 0;
+  for (i=0, n=values.length; i<n; ++i) {
+    v = f ? f(values[i]) : values[i];
+    if (util.isValid(v)) valid += 1;
+  }
+  return valid;
+};
+
+// Count the number of null or undefined values.
+stats.count.missing = function(values, f) {
+  f = util.$(f);
+  var v, i, n, count = 0;
+  for (i=0, n=values.length; i<n; ++i) {
+    v = f ? f(values[i]) : values[i];
+    if (v == null) count += 1;
+  }
+  return count;
+};
+
+// Count the number of distinct values.
+// Null, undefined and NaN are each considered distinct values.
+stats.count.distinct = function(values, f) {
+  f = util.$(f);
+  var u = {}, v, i, n, count = 0;
+  for (i=0, n=values.length; i<n; ++i) {
+    v = f ? f(values[i]) : values[i];
+    if (v in u) continue;
+    u[v] = 1;
+    count += 1;
+  }
+  return count;
+};
+
+// Construct a map from distinct values to occurrence counts.
+stats.count.map = function(values, f) {
+  f = util.$(f);
+  var map = {}, v, i, n;
+  for (i=0, n=values.length; i<n; ++i) {
+    v = f ? f(values[i]) : values[i];
+    map[v] = (v in map) ? map[v] + 1 : 1;
+  }
+  return map;
+};
+
+// Compute the median of an array of numbers.
+stats.median = function(values, f) {
+  if (f) values = values.map(util.$(f));
+  values = values.filter(util.isValid).sort(util.cmp);
+  return stats.quantile(values, 0.5);
+};
+
+// Computes the quartile boundaries of an array of numbers.
+stats.quartile = function(values, f) {
+  if (f) values = values.map(util.$(f));
+  values = values.filter(util.isValid).sort(util.cmp);
+  var q = stats.quantile;
+  return [q(values, 0.25), q(values, 0.50), q(values, 0.75)];
+};
+
+// Compute the quantile of a sorted array of numbers.
+// Adapted from the D3.js implementation.
+stats.quantile = function(values, f, p) {
+  if (p === undefined) { p = f; f = util.identity; }
+  f = util.$(f);
+  var H = (values.length - 1) * p + 1,
+      h = Math.floor(H),
+      v = +f(values[h - 1]),
+      e = H - h;
+  return e ? v + e * (f(values[h]) - v) : v;
+};
+
+// Compute the sum of an array of numbers.
+stats.sum = function(values, f) {
+  f = util.$(f);
+  for (var sum=0, i=0, n=values.length, v; i<n; ++i) {
+    v = f ? f(values[i]) : values[i];
+    if (util.isValid(v)) sum += v;
+  }
+  return sum;
+};
+
+// Compute the mean (average) of an array of numbers.
+stats.mean = function(values, f) {
+  f = util.$(f);
+  var mean = 0, delta, i, n, c, v;
+  for (i=0, c=0, n=values.length; i<n; ++i) {
+    v = f ? f(values[i]) : values[i];
+    if (util.isValid(v)) {
+      delta = v - mean;
+      mean = mean + delta / (++c);
+    }
+  }
+  return mean;
+};
+
+// Compute the sample variance of an array of numbers.
+stats.variance = function(values, f) {
+  f = util.$(f);
+  if (!util.isArray(values) || values.length < 2) return 0;
+  var mean = 0, M2 = 0, delta, i, c, v;
+  for (i=0, c=0; i<values.length; ++i) {
+    v = f ? f(values[i]) : values[i];
+    if (util.isValid(v)) {
+      delta = v - mean;
+      mean = mean + delta / (++c);
+      M2 = M2 + delta * (v - mean);
+    }
+  }
+  M2 = M2 / (c - 1);
+  return M2;
+};
+
+// Compute the sample standard deviation of an array of numbers.
+stats.stdev = function(values, f) {
+  return Math.sqrt(stats.variance(values, f));
+};
+
+// Compute the Pearson mode skewness ((median-mean)/stdev) of an array of numbers.
+stats.modeskew = function(values, f) {
+  var avg = stats.mean(values, f),
+      med = stats.median(values, f),
+      std = stats.stdev(values, f);
+  return std === 0 ? 0 : (avg - med) / std;
+};
+
+// Find the minimum value in an array.
+stats.min = function(values, f) {
+  return stats.extent(values, f)[0];
+};
+
+// Find the maximum value in an array.
+stats.max = function(values, f) {
+  return stats.extent(values, f)[1];
+};
+
+// Find the minimum and maximum of an array of values.
+stats.extent = function(values, f) {
+  f = util.$(f);
+  var a, b, v, i, n = values.length;
+  for (i=0; i<n; ++i) {
+    v = f ? f(values[i]) : values[i];
+    if (util.isValid(v)) { a = b = v; break; }
+  }
+  for (; i<n; ++i) {
+    v = f ? f(values[i]) : values[i];
+    if (util.isValid(v)) {
+      if (v < a) a = v;
+      if (v > b) b = v;
+    }
+  }
+  return [a, b];
+};
+
+// Find the integer indices of the minimum and maximum values.
+stats.extent.index = function(values, f) {
+  f = util.$(f);
+  var x = -1, y = -1, a, b, v, i, n = values.length;
+  for (i=0; i<n; ++i) {
+    v = f ? f(values[i]) : values[i];
+    if (util.isValid(v)) { a = b = v; x = y = i; break; }
+  }
+  for (; i<n; ++i) {
+    v = f ? f(values[i]) : values[i];
+    if (util.isValid(v)) {
+      if (v < a) { a = v; x = i; }
+      if (v > b) { b = v; y = i; }
+    }
+  }
+  return [x, y];
+};
+
+// Compute the dot product of two arrays of numbers.
+stats.dot = function(values, a, b) {
+  var sum = 0, i, v;
+  if (!b) {
+    if (values.length !== a.length) {
+      throw Error('Array lengths must match.');
+    }
+    for (i=0; i<values.length; ++i) {
+      v = values[i] * a[i];
+      if (v === v) sum += v;
+    }
+  } else {
+    a = util.$(a);
+    b = util.$(b);
+    for (i=0; i<values.length; ++i) {
+      v = a(values[i]) * b(values[i]);
+      if (v === v) sum += v;
+    }
+  }
+  return sum;
+};
+
+// Compute ascending rank scores for an array of values.
+// Ties are assigned their collective mean rank.
+stats.rank = function(values, f) {
+  f = util.$(f) || util.identity;
+  var a = values.map(function(v, i) {
+      return {idx: i, val: f(v)};
+    })
+    .sort(util.comparator('val'));
+
+  var n = values.length,
+      r = Array(n),
+      tie = -1, p = {}, i, v, mu;
+
+  for (i=0; i<n; ++i) {
+    v = a[i].val;
+    if (tie < 0 && p === v) {
+      tie = i - 1;
+    } else if (tie > -1 && p !== v) {
+      mu = 1 + (i-1 + tie) / 2;
+      for (; tie<i; ++tie) r[a[tie].idx] = mu;
+      tie = -1;
+    }
+    r[a[i].idx] = i + 1;
+    p = v;
+  }
+
+  if (tie > -1) {
+    mu = 1 + (n-1 + tie) / 2;
+    for (; tie<n; ++tie) r[a[tie].idx] = mu;
+  }
+
+  return r;
+};
+
+// Compute the sample Pearson product-moment correlation of two arrays of numbers.
+stats.cor = function(values, a, b) {
+  var fn = b;
+  b = fn ? values.map(util.$(b)) : a;
+  a = fn ? values.map(util.$(a)) : values;
+
+  var dot = stats.dot(a, b),
+      mua = stats.mean(a),
+      mub = stats.mean(b),
+      sda = stats.stdev(a),
+      sdb = stats.stdev(b),
+      n = values.length;
+
+  return (dot - n*mua*mub) / ((n-1) * sda * sdb);
+};
+
+// Compute the Spearman rank correlation of two arrays of values.
+stats.cor.rank = function(values, a, b) {
+  var ra = b ? stats.rank(values, util.$(a)) : stats.rank(values),
+      rb = b ? stats.rank(values, util.$(b)) : stats.rank(a),
+      n = values.length, i, s, d;
+
+  for (i=0, s=0; i<n; ++i) {
+    d = ra[i] - rb[i];
+    s += d * d;
+  }
+
+  return 1 - 6*s / (n * (n*n-1));
+};
+
+// Compute the distance correlation of two arrays of numbers.
+// http://en.wikipedia.org/wiki/Distance_correlation
+stats.cor.dist = function(values, a, b) {
+  var X = b ? values.map(util.$(a)) : values,
+      Y = b ? values.map(util.$(b)) : a;
+
+  var A = stats.dist.mat(X),
+      B = stats.dist.mat(Y),
+      n = A.length,
+      i, aa, bb, ab;
+
+  for (i=0, aa=0, bb=0, ab=0; i<n; ++i) {
+    aa += A[i]*A[i];
+    bb += B[i]*B[i];
+    ab += A[i]*B[i];
+  }
+
+  return Math.sqrt(ab / Math.sqrt(aa*bb));
+};
+
+// Compute the vector distance between two arrays of numbers.
+// Default is Euclidean (exp=2) distance, configurable via exp argument.
+stats.dist = function(values, a, b, exp) {
+  var f = util.isFunction(b) || util.isString(b),
+      X = values,
+      Y = f ? values : a,
+      e = f ? exp : b,
+      L2 = e === 2 || e == null,
+      n = values.length, s = 0, d, i;
+  if (f) {
+    a = util.$(a);
+    b = util.$(b);
+  }
+  for (i=0; i<n; ++i) {
+    d = f ? (a(X[i])-b(Y[i])) : (X[i]-Y[i]);
+    s += L2 ? d*d : Math.pow(Math.abs(d), e);
+  }
+  return L2 ? Math.sqrt(s) : Math.pow(s, 1/e);
+};
+
+// Construct a mean-centered distance matrix for an array of numbers.
+stats.dist.mat = function(X) {
+  var n = X.length,
+      m = n*n,
+      A = Array(m),
+      R = gen.zeros(n),
+      M = 0, v, i, j;
+
+  for (i=0; i<n; ++i) {
+    A[i*n+i] = 0;
+    for (j=i+1; j<n; ++j) {
+      A[i*n+j] = (v = Math.abs(X[i] - X[j]));
+      A[j*n+i] = v;
+      R[i] += v;
+      R[j] += v;
+    }
+  }
+
+  for (i=0; i<n; ++i) {
+    M += R[i];
+    R[i] /= n;
+  }
+  M /= m;
+
+  for (i=0; i<n; ++i) {
+    for (j=i; j<n; ++j) {
+      A[i*n+j] += M - R[i] - R[j];
+      A[j*n+i] = A[i*n+j];
+    }
+  }
+
+  return A;
+};
+
+// Compute the Shannon entropy (log base 2) of an array of counts.
+stats.entropy = function(counts, f) {
+  f = util.$(f);
+  var i, p, s = 0, H = 0, n = counts.length;
+  for (i=0; i<n; ++i) {
+    s += (f ? f(counts[i]) : counts[i]);
+  }
+  if (s === 0) return 0;
+  for (i=0; i<n; ++i) {
+    p = (f ? f(counts[i]) : counts[i]) / s;
+    if (p) H += p * Math.log(p);
+  }
+  return -H / Math.LN2;
+};
+
+// Compute the mutual information between two discrete variables.
+// Returns an array of the form [MI, MI_distance] 
+// MI_distance is defined as 1 - I(a,b) / H(a,b).
+// http://en.wikipedia.org/wiki/Mutual_information
+stats.mutual = function(values, a, b, counts) {
+  var x = counts ? values.map(util.$(a)) : values,
+      y = counts ? values.map(util.$(b)) : a,
+      z = counts ? values.map(util.$(counts)) : b;
+
+  var px = {},
+      py = {},
+      n = z.length,
+      s = 0, I = 0, H = 0, p, t, i;
+
+  for (i=0; i<n; ++i) {
+    px[x[i]] = 0;
+    py[y[i]] = 0;
+  }
+
+  for (i=0; i<n; ++i) {
+    px[x[i]] += z[i];
+    py[y[i]] += z[i];
+    s += z[i];
+  }
+
+  t = 1 / (s * Math.LN2);
+  for (i=0; i<n; ++i) {
+    if (z[i] === 0) continue;
+    p = (s * z[i]) / (px[x[i]] * py[y[i]]);
+    I += z[i] * t * Math.log(p);
+    H += z[i] * t * Math.log(z[i]/s);
+  }
+
+  return [I, 1 + I/H];
+};
+
+// Compute the mutual information between two discrete variables.
+stats.mutual.info = function(values, a, b, counts) {
+  return stats.mutual(values, a, b, counts)[0];
+};
+
+// Compute the mutual information distance between two discrete variables.
+// MI_distance is defined as 1 - I(a,b) / H(a,b).
+stats.mutual.dist = function(values, a, b, counts) {
+  return stats.mutual(values, a, b, counts)[1];
+};
+
+// Compute a profile of summary statistics for a variable.
+stats.profile = function(values, f) {
+  var mean = 0,
+      valid = 0,
+      missing = 0,
+      distinct = 0,
+      min = null,
+      max = null,
+      M2 = 0,
+      vals = [],
+      u = {}, delta, sd, i, v, x;
+
+  // compute summary stats
+  for (i=0; i<values.length; ++i) {
+    v = f ? f(values[i]) : values[i];
+
+    // update unique values
+    u[v] = (v in u) ? u[v] + 1 : (distinct += 1, 1);
+
+    if (v == null) {
+      ++missing;
+    } else if (util.isValid(v)) {
+      // update stats
+      x = (typeof v === 'string') ? v.length : v;
+      if (min===null || x < min) min = x;
+      if (max===null || x > max) max = x;
+      delta = x - mean;
+      mean = mean + delta / (++valid);
+      M2 = M2 + delta * (x - mean);
+      vals.push(x);
+    }
+  }
+  M2 = M2 / (valid - 1);
+  sd = Math.sqrt(M2);
+
+  // sort values for median and iqr
+  vals.sort(util.cmp);
+
+  return {
+    type:     type(values, f),
+    unique:   u,
+    count:    values.length,
+    valid:    valid,
+    missing:  missing,
+    distinct: distinct,
+    min:      min,
+    max:      max,
+    mean:     mean,
+    stdev:    sd,
+    median:   (v = stats.quantile(vals, 0.5)),
+    q1:       stats.quantile(vals, 0.25),
+    q3:       stats.quantile(vals, 0.75),
+    modeskew: sd === 0 ? 0 : (mean - v) / sd
+  };
+};
+
+// Compute profiles for all variables in a data set.
+stats.summary = function(data, fields) {
+  fields = fields || util.keys(data[0]);
+  var s = fields.map(function(f) {
+    var p = stats.profile(data, util.$(f));
+    return (p.field = f, p);
+  });
+  return (s.__summary__ = true, s);
+};
+
+module.exports = stats;
+},{"./generate":14,"./import/type":23,"./util":29}],27:[function(require,module,exports){
+var util = require('./util'),
+    format = require('./format');
+
+var context = {
+  formats:    [],
+  format_map: {},
+  truncate:   util.truncate,
+  pad:        util.pad
+};
+
+function template(text) {
+  var src = source(text, 'd');
+  src = 'var __t; return ' + src + ';';
+
+  /* jshint evil: true */
+  return (new Function('d', src)).bind(context);
+}
+
+template.source = source;
+template.context = context;
+module.exports = template;
+
+// Clear cache of format objects.
+// This can *break* prior template functions, so invoke with care!
+template.clearFormatCache = function() {
+  context.formats = [];
+  context.format_map = {};
+};
+
+// Generate property access code for use within template source.
+// object: the name of the object (variable) containing template data
+// property: the property access string, verbatim from template tag
+template.property = function(object, property) {
+  var src = util.field(property).map(util.str).join('][');
+  return object + '[' + src + ']';
+};
+
+// Generate source code for a template function.
+// text: the template text
+// variable: the name of the data object variable ('obj' by default)
+// properties: optional hash for collecting all accessed properties
+function source(text, variable, properties) {
+  variable = variable || 'obj';
+  var index = 0;
+  var src = '\'';
+  var regex = template_re;
+
+  // Compile the template source, escaping string literals appropriately.
+  text.replace(regex, function(match, interpolate, offset) {
+    src += text
+      .slice(index, offset)
+      .replace(template_escaper, template_escapeChar);
+    index = offset + match.length;
+
+    if (interpolate) {
+      src += '\'\n+((__t=(' +
+        template_var(interpolate, variable, properties) +
+        '))==null?\'\':__t)+\n\'';
+    }
+
+    // Adobe VMs need the match returned to produce the correct offest.
+    return match;
+  });
+  return src + '\'';
+}
+
+function template_var(text, variable, properties) {
+  var filters = text.match(filter_re);
+  var prop = filters.shift().trim();
+  var stringCast = true;
+
+  function strcall(fn) {
+    fn = fn || '';
+    if (stringCast) {
+      stringCast = false;
+      src = 'String(' + src + ')' + fn;
+    } else {
+      src += fn;
+    }
+    return src;
+  }
+
+  function date() {
+    return '(typeof ' + src + '==="number"?new Date('+src+'):'+src+')';
+  }
+
+  function number_format(fmt, key) {
+    a = template_format(args[0], key, fmt);
+    stringCast = false;
+    src = 'this.formats['+a+']('+src+')';
+  }
+  
+  function time_format(fmt, key) {
+    a = template_format(args[0], key, fmt);
+    stringCast = false;
+    src = 'this.formats['+a+']('+date()+')';
+  }
+
+  if (properties) properties[prop] = 1;
+  var src = template.property(variable, prop);
+
+  for (var i=0; i<filters.length; ++i) {
+    var f = filters[i], args = null, pidx, a, b;
+
+    if ((pidx=f.indexOf(':')) > 0) {
+      f = f.slice(0, pidx);
+      args = filters[i].slice(pidx+1)
+        .match(args_re)
+        .map(function(s) { return s.trim(); });
+    }
+    f = f.trim();
+
+    switch (f) {
+      case 'length':
+        strcall('.length');
+        break;
+      case 'lower':
+        strcall('.toLowerCase()');
+        break;
+      case 'upper':
+        strcall('.toUpperCase()');
+        break;
+      case 'lower-locale':
+        strcall('.toLocaleLowerCase()');
+        break;
+      case 'upper-locale':
+        strcall('.toLocaleUpperCase()');
+        break;
+      case 'trim':
+        strcall('.trim()');
+        break;
+      case 'left':
+        a = util.number(args[0]);
+        strcall('.slice(0,' + a + ')');
+        break;
+      case 'right':
+        a = util.number(args[0]);
+        strcall('.slice(-' + a +')');
+        break;
+      case 'mid':
+        a = util.number(args[0]);
+        b = a + util.number(args[1]);
+        strcall('.slice(+'+a+','+b+')');
+        break;
+      case 'slice':
+        a = util.number(args[0]);
+        strcall('.slice('+ a +
+          (args.length > 1 ? ',' + util.number(args[1]) : '') +
+          ')');
+        break;
+      case 'truncate':
+        a = util.number(args[0]);
+        b = args[1];
+        b = (b!=='left' && b!=='middle' && b!=='center') ? 'right' : b;
+        src = 'this.truncate(' + strcall() + ',' + a + ',\'' + b + '\')';
+        break;
+      case 'pad':
+        a = util.number(args[0]);
+        b = args[1];
+        b = (b!=='left' && b!=='middle' && b!=='center') ? 'right' : b;
+        src = 'this.pad(' + strcall() + ',' + a + ',\'' + b + '\')';
+        break;
+      case 'number':
+        number_format(format.number, 'number');
+        break;
+      case 'time':
+        time_format(format.time, 'time');
+        break;
+      case 'time-utc':
+        time_format(format.utc, 'time-utc');
+        break;
+      default:
+        throw Error('Unrecognized template filter: ' + f);
+    }
+  }
+
+  return src;
+}
+
+var template_re = /\{\{(.+?)\}\}|$/g,
+    filter_re = /(?:"[^"]*"|\'[^\']*\'|[^\|"]+|[^\|\']+)+/g,
+    args_re = /(?:"[^"]*"|\'[^\']*\'|[^,"]+|[^,\']+)+/g;
+
+// Certain characters need to be escaped so that they can be put into a
+// string literal.
+var template_escapes = {
+  '\'':     '\'',
+  '\\':     '\\',
+  '\r':     'r',
+  '\n':     'n',
+  '\u2028': 'u2028',
+  '\u2029': 'u2029'
+};
+
+var template_escaper = /\\|'|\r|\n|\u2028|\u2029/g;
+
+function template_escapeChar(match) {
+  return '\\' + template_escapes[match];
+}
+
+function template_format(pattern, key, fmt) {
+  if ((pattern[0] === '\'' && pattern[pattern.length-1] === '\'') ||
+      (pattern[0] === '"'  && pattern[pattern.length-1] === '"')) {
+    pattern = pattern.slice(1, -1);
+  } else {
+    throw Error('Format pattern must be quoted: ' + pattern);
+  }
+  key = key + ':' + pattern;
+  if (!context.format_map[key]) {
+    var f = fmt(pattern);
+    var i = context.formats.length;
+    context.formats.push(f);
+    context.format_map[key] = i;
+  }
+  return context.format_map[key];
+}
+
+},{"./format":13,"./util":29}],28:[function(require,module,exports){
+var d3_time = require('d3-time');
+
+var tempDate = new Date(),
+    baseDate = new Date(0, 0, 1).setFullYear(0), // Jan 1, 0 AD
+    utcBaseDate = new Date(Date.UTC(0, 0, 1)).setUTCFullYear(0);
+
+function date(d) {
+  return (tempDate.setTime(+d), tempDate);
+}
+
+// create a time unit entry
+function entry(type, date, unit, step, min, max) {
+  var e = {
+    type: type,
+    date: date,
+    unit: unit
+  };
+  if (step) {
+    e.step = step;
+  } else {
+    e.minstep = 1;
+  }
+  if (min != null) e.min = min;
+  if (max != null) e.max = max;
+  return e;
+}
+
+function create(type, unit, base, step, min, max) {
+  return entry(type,
+    function(d) { return unit.offset(base, d); },
+    function(d) { return unit.count(base, d); },
+    step, min, max);
+}
+
+var locale = [
+  create('second', d3_time.second, baseDate),
+  create('minute', d3_time.minute, baseDate),
+  create('hour',   d3_time.hour,   baseDate),
+  create('day',    d3_time.day,    baseDate, [1, 7]),
+  create('month',  d3_time.month,  baseDate, [1, 3, 6]),
+  create('year',   d3_time.year,   baseDate),
+
+  // periodic units
+  entry('seconds',
+    function(d) { return new Date(1970, 0, 1, 0, 0, d); },
+    function(d) { return date(d).getSeconds(); },
+    null, 0, 59
+  ),
+  entry('minutes',
+    function(d) { return new Date(1970, 0, 1, 0, d); },
+    function(d) { return date(d).getMinutes(); },
+    null, 0, 59
+  ),
+  entry('hours',
+    function(d) { return new Date(1970, 0, 1, d); },
+    function(d) { return date(d).getHours(); },
+    null, 0, 23
+  ),
+  entry('weekdays',
+    function(d) { return new Date(1970, 0, 4+d); },
+    function(d) { return date(d).getDay(); },
+    [1], 0, 6
+  ),
+  entry('dates',
+    function(d) { return new Date(1970, 0, d); },
+    function(d) { return date(d).getDate(); },
+    [1], 1, 31
+  ),
+  entry('months',
+    function(d) { return new Date(1970, d % 12, 1); },
+    function(d) { return date(d).getMonth(); },
+    [1], 0, 11
+  )
+];
+
+var utc = [
+  create('second', d3_time.utcSecond, utcBaseDate),
+  create('minute', d3_time.utcMinute, utcBaseDate),
+  create('hour',   d3_time.utcHour,   utcBaseDate),
+  create('day',    d3_time.utcDay,    utcBaseDate, [1, 7]),
+  create('month',  d3_time.utcMonth,  utcBaseDate, [1, 3, 6]),
+  create('year',   d3_time.utcYear,   utcBaseDate),
+
+  // periodic units
+  entry('seconds',
+    function(d) { return new Date(Date.UTC(1970, 0, 1, 0, 0, d)); },
+    function(d) { return date(d).getUTCSeconds(); },
+    null, 0, 59
+  ),
+  entry('minutes',
+    function(d) { return new Date(Date.UTC(1970, 0, 1, 0, d)); },
+    function(d) { return date(d).getUTCMinutes(); },
+    null, 0, 59
+  ),
+  entry('hours',
+    function(d) { return new Date(Date.UTC(1970, 0, 1, d)); },
+    function(d) { return date(d).getUTCHours(); },
+    null, 0, 23
+  ),
+  entry('weekdays',
+    function(d) { return new Date(Date.UTC(1970, 0, 4+d)); },
+    function(d) { return date(d).getUTCDay(); },
+    [1], 0, 6
+  ),
+  entry('dates',
+    function(d) { return new Date(Date.UTC(1970, 0, d)); },
+    function(d) { return date(d).getUTCDate(); },
+    [1], 1, 31
+  ),
+  entry('months',
+    function(d) { return new Date(Date.UTC(1970, d % 12, 1)); },
+    function(d) { return date(d).getUTCMonth(); },
+    [1], 0, 11
+  )
+];
+
+var STEPS = [
+  [31536e6, 5],  // 1-year
+  [7776e6, 4],   // 3-month
+  [2592e6, 4],   // 1-month
+  [12096e5, 3],  // 2-week
+  [6048e5, 3],   // 1-week
+  [1728e5, 3],   // 2-day
+  [864e5, 3],    // 1-day
+  [432e5, 2],    // 12-hour
+  [216e5, 2],    // 6-hour
+  [108e5, 2],    // 3-hour
+  [36e5, 2],     // 1-hour
+  [18e5, 1],     // 30-minute
+  [9e5, 1],      // 15-minute
+  [3e5, 1],      // 5-minute
+  [6e4, 1],      // 1-minute
+  [3e4, 0],      // 30-second
+  [15e3, 0],     // 15-second
+  [5e3, 0],      // 5-second
+  [1e3, 0]       // 1-second
+];
+
+function find(units, span, minb, maxb) {
+  var step = STEPS[0], i, n, bins;
+
+  for (i=1, n=STEPS.length; i<n; ++i) {
+    step = STEPS[i];
+    if (span > step[0]) {
+      bins = span / step[0];
+      if (bins > maxb) {
+        return units[STEPS[i-1][1]];
+      }
+      if (bins >= minb) {
+        return units[step[1]];
+      }
+    }
+  }
+  return units[STEPS[n-1][1]];
+}
+
+function toUnitMap(units) {
+  var map = {}, i, n;
+  for (i=0, n=units.length; i<n; ++i) {
+    map[units[i].type] = units[i];
+  }
+  map.find = function(span, minb, maxb) {
+    return find(units, span, minb, maxb);
+  };
+  return map;
+}
+
+module.exports = toUnitMap(locale);
+module.exports.utc = toUnitMap(utc);
+
+},{"d3-time":6}],29:[function(require,module,exports){
+var buffer = require('buffer'),
+    time = require('./time'),
+    utc = time.utc;
+
+var u = module.exports = {};
+
+// utility functions
+
+var FNAME = '__name__';
+
+u.namedfunc = function(name, f) { return (f[FNAME] = name, f); };
+
+u.name = function(f) { return f==null ? null : f[FNAME]; };
+
+u.identity = function(x) { return x; };
+
+u.true = u.namedfunc('true', function() { return true; });
+
+u.false = u.namedfunc('false', function() { return false; });
+
+u.duplicate = function(obj) {
+  return JSON.parse(JSON.stringify(obj));
+};
+
+u.equal = function(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+};
+
+u.extend = function(obj) {
+  for (var x, name, i=1, len=arguments.length; i<len; ++i) {
+    x = arguments[i];
+    for (name in x) { obj[name] = x[name]; }
+  }
+  return obj;
+};
+
+u.length = function(x) {
+  return x != null && x.length != null ? x.length : null;
+};
+
+u.keys = function(x) {
+  var keys = [], k;
+  for (k in x) keys.push(k);
+  return keys;
+};
+
+u.vals = function(x) {
+  var vals = [], k;
+  for (k in x) vals.push(x[k]);
+  return vals;
+};
+
+u.toMap = function(list, f) {
+  return (f = u.$(f)) ?
+    list.reduce(function(obj, x) { return (obj[f(x)] = 1, obj); }, {}) :
+    list.reduce(function(obj, x) { return (obj[x] = 1, obj); }, {});
+};
+
+u.keystr = function(values) {
+  // use to ensure consistent key generation across modules
+  var n = values.length;
+  if (!n) return '';
+  for (var s=String(values[0]), i=1; i<n; ++i) {
+    s += '|' + String(values[i]);
+  }
+  return s;
+};
+
+// type checking functions
+
+var toString = Object.prototype.toString;
+
+u.isObject = function(obj) {
+  return obj === Object(obj);
+};
+
+u.isFunction = function(obj) {
+  return toString.call(obj) === '[object Function]';
+};
+
+u.isString = function(obj) {
+  return typeof value === 'string' || toString.call(obj) === '[object String]';
+};
+
+u.isArray = Array.isArray || function(obj) {
+  return toString.call(obj) === '[object Array]';
+};
+
+u.isNumber = function(obj) {
+  return typeof obj === 'number' || toString.call(obj) === '[object Number]';
+};
+
+u.isBoolean = function(obj) {
+  return obj === true || obj === false || toString.call(obj) == '[object Boolean]';
+};
+
+u.isDate = function(obj) {
+  return toString.call(obj) === '[object Date]';
+};
+
+u.isValid = function(obj) {
+  return obj != null && obj === obj;
+};
+
+u.isBuffer = (buffer.Buffer && buffer.Buffer.isBuffer) || u.false;
+
+// type coercion functions
+
+u.number = function(s) {
+  return s == null || s === '' ? null : +s;
+};
+
+u.boolean = function(s) {
+  return s == null || s === '' ? null : s==='false' ? false : !!s;
+};
+
+u.date = function(s) {
+  return s == null || s === '' ? null : Date.parse(s);
+};
+
+u.array = function(x) {
+  return x != null ? (u.isArray(x) ? x : [x]) : [];
+};
+
+u.str = function(x) {
+  return u.isArray(x) ? '[' + x.map(u.str) + ']'
+    : u.isObject(x) ? JSON.stringify(x)
+    : u.isString(x) ? ('\''+util_escape_str(x)+'\'') : x;
+};
+
+var escape_str_re = /(^|[^\\])'/g;
+
+function util_escape_str(x) {
+  return x.replace(escape_str_re, '$1\\\'');
+}
+
+// data access functions
+
+var field_re = /\[(.*?)\]|[^.\[]+/g;
+
+u.field = function(f) {
+  return String(f).match(field_re).map(function(d) {
+    return d[0] !== '[' ? d :
+      d[1] !== "'" && d[1] !== '"' ? d.slice(1, -1) :
+      d.slice(2, -2).replace(/\\(["'])/g, '$1');
+  });
+};
+
+u.accessor = function(f) {
+  var s;
+  return f==null || u.isFunction(f) ? f :
+    u.namedfunc(f, (s = u.field(f)).length > 1 ?
+      function(x) { return s.reduce(function(x,f) { return x[f]; }, x); } :
+      function(x) { return x[f]; }
+    );
+};
+
+// short-cut for accessor
+u.$ = u.accessor;
+
+u.mutator = function(f) {
+  var s;
+  return u.isString(f) && (s=u.field(f)).length > 1 ?
+    function(x, v) {
+      for (var i=0; i<s.length-1; ++i) x = x[s[i]];
+      x[s[i]] = v;
+    } :
+    function(x, v) { x[f] = v; };
+};
+
+
+u.$func = function(name, op) {
+  return function(f) {
+    f = u.$(f) || u.identity;
+    var n = name + (u.name(f) ? '_'+u.name(f) : '');
+    return u.namedfunc(n, function(d) { return op(f(d)); });
+  };
+};
+
+u.$valid  = u.$func('valid', u.isValid);
+u.$length = u.$func('length', u.length);
+
+u.$in = function(f, values) {
+  f = u.$(f);
+  var map = u.isArray(values) ? u.toMap(values) : values;
+  return function(d) { return !!map[f(d)]; };
+};
+
+u.$year   = u.$func('year', time.year.unit);
+u.$month  = u.$func('month', time.months.unit);
+u.$date   = u.$func('date', time.dates.unit);
+u.$day    = u.$func('day', time.weekdays.unit);
+u.$hour   = u.$func('hour', time.hours.unit);
+u.$minute = u.$func('minute', time.minutes.unit);
+u.$second = u.$func('second', time.seconds.unit);
+
+u.$utcYear   = u.$func('utcYear', utc.year.unit);
+u.$utcMonth  = u.$func('utcMonth', utc.months.unit);
+u.$utcDate   = u.$func('utcDate', utc.dates.unit);
+u.$utcDay    = u.$func('utcDay', utc.weekdays.unit);
+u.$utcHour   = u.$func('utcHour', utc.hours.unit);
+u.$utcMinute = u.$func('utcMinute', utc.minutes.unit);
+u.$utcSecond = u.$func('utcSecond', utc.seconds.unit);
+
+// comparison / sorting functions
+
+u.comparator = function(sort) {
+  var sign = [];
+  if (sort === undefined) sort = [];
+  sort = u.array(sort).map(function(f) {
+    var s = 1;
+    if      (f[0] === '-') { s = -1; f = f.slice(1); }
+    else if (f[0] === '+') { s = +1; f = f.slice(1); }
+    sign.push(s);
+    return u.accessor(f);
+  });
+  return function(a,b) {
+    var i, n, f, x, y;
+    for (i=0, n=sort.length; i<n; ++i) {
+      f = sort[i]; x = f(a); y = f(b);
+      if (x < y) return -1 * sign[i];
+      if (x > y) return sign[i];
+    }
+    return 0;
+  };
+};
+
+u.cmp = function(a, b) {
+  if (a < b) {
+    return -1;
+  } else if (a > b) {
+    return 1;
+  } else if (a >= b) {
+    return 0;
+  } else if (a === null) {
+    return -1;
+  } else if (b === null) {
+    return 1;
+  }
+  return NaN;
+};
+
+u.numcmp = function(a, b) { return a - b; };
+
+u.stablesort = function(array, sortBy, keyFn) {
+  var indices = array.reduce(function(idx, v, i) {
+    return (idx[keyFn(v)] = i, idx);
+  }, {});
+
+  array.sort(function(a, b) {
+    var sa = sortBy(a),
+        sb = sortBy(b);
+    return sa < sb ? -1 : sa > sb ? 1
+         : (indices[keyFn(a)] - indices[keyFn(b)]);
+  });
+
+  return array;
+};
+
+
+// string functions
+
+u.pad = function(s, length, pos, padchar) {
+  padchar = padchar || " ";
+  var d = length - s.length;
+  if (d <= 0) return s;
+  switch (pos) {
+    case 'left':
+      return strrep(d, padchar) + s;
+    case 'middle':
+    case 'center':
+      return strrep(Math.floor(d/2), padchar) +
+         s + strrep(Math.ceil(d/2), padchar);
+    default:
+      return s + strrep(d, padchar);
+  }
+};
+
+function strrep(n, str) {
+  var s = "", i;
+  for (i=0; i<n; ++i) s += str;
+  return s;
+}
+
+u.truncate = function(s, length, pos, word, ellipsis) {
+  var len = s.length;
+  if (len <= length) return s;
+  ellipsis = ellipsis !== undefined ? String(ellipsis) : '\u2026';
+  var l = Math.max(0, length - ellipsis.length);
+
+  switch (pos) {
+    case 'left':
+      return ellipsis + (word ? truncateOnWord(s,l,1) : s.slice(len-l));
+    case 'middle':
+    case 'center':
+      var l1 = Math.ceil(l/2), l2 = Math.floor(l/2);
+      return (word ? truncateOnWord(s,l1) : s.slice(0,l1)) +
+        ellipsis + (word ? truncateOnWord(s,l2,1) : s.slice(len-l2));
+    default:
+      return (word ? truncateOnWord(s,l) : s.slice(0,l)) + ellipsis;
+  }
+};
+
+function truncateOnWord(s, len, rev) {
+  var cnt = 0, tok = s.split(truncate_word_re);
+  if (rev) {
+    s = (tok = tok.reverse())
+      .filter(function(w) { cnt += w.length; return cnt <= len; })
+      .reverse();
+  } else {
+    s = tok.filter(function(w) { cnt += w.length; return cnt <= len; });
+  }
+  return s.length ? s.join('').trim() : tok[0].slice(0, len);
+}
+
+var truncate_word_re = /([\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u2028\u2029\u3000\uFEFF])/;
+
+},{"./time":28,"buffer":2}],30:[function(require,module,exports){
+var DEPS = require('./Dependencies').ALL;
+
+function create(cs, reflow) {
+  var out = {};
+  copy(cs, out);
+
+  out.add = [];
+  out.mod = [];
+  out.rem = [];
+
+  out.reflow = reflow;
+
+  return out;
+}
+
+function copy(a, b) {
+  b.stamp = a ? a.stamp : 0;
+  b.sort  = a ? a.sort  : null;
+  b.facet = a ? a.facet : null;
+  b.trans = a ? a.trans : null;
+  b.dirty = a ? a.dirty : [];
+  b.request = a ? a.request : null;
+  for (var d, i=0, n=DEPS.length; i<n; ++i) {
+    b[d=DEPS[i]] = a ? a[d] : {};
+  }
+}
+
+module.exports = {
+  create: create,
+  copy: copy
+};
+},{"./Dependencies":33}],31:[function(require,module,exports){
+var log = require('vega-logging'),
+    Tuple = require('./Tuple'),
+    Base = require('./Node').prototype;
+
+function Collector(graph) {
+  Base.init.call(this, graph);
+  this._data = [];
+  this.router(true).collector(true);
+}
+
+var prototype = (Collector.prototype = Object.create(Base));
+prototype.constructor = Collector;
+
+prototype.data = function() {
+  return this._data;
+};
+
+prototype.evaluate = function(input) {
+  log.debug(input, ["collecting"]);
+
+  if (input.rem.length) {
+    this._data = Tuple.idFilter(this._data, input.rem);
+  }
+
+  if (input.add.length) {
+    this._data = this._data.length ? this._data.concat(input.add) : input.add;
+  }
+
+  if (input.sort) {
+    this._data.sort(input.sort);
+  }
+
+  if (input.reflow) {
+    input.mod = input.mod.concat(
+      Tuple.idFilter(this._data, input.add, input.mod, input.rem));
+    input.reflow = false;
+  }
+
+  return input;
+};
+
+module.exports = Collector;
+},{"./Node":36,"./Tuple":38,"vega-logging":45}],32:[function(require,module,exports){
+var log = require('vega-logging'),
+    ChangeSet = require('./ChangeSet'), 
+    Collector = require('./Collector'),
+    Tuple = require('./Tuple'),
+    Node = require('./Node'); // jshint ignore:line
+
+function DataSource(graph, name, facet) {
+  this._graph = graph;
+  this._name = name;
+  this._data = [];
+  this._source = null;
+  this._facet  = facet;
+  this._input  = ChangeSet.create();
+  this._output = null; // Output changeset
+
+  this._inputNode  = null;
+  this._outputNode = null;
+  this._pipeline  = null; // Pipeline of transformations.
+  this._collector = null; // Collector to materialize output of pipeline.
+  this._mutates = false;  // Does any pipeline operator mutate tuples?
+}
+
+var prototype = DataSource.prototype;
+
+prototype.name = function(name) {
+  if (!arguments.length) return this._name;
+  return (this._name = name, this);
+};
+
+prototype.source = function(src) {
+  if (!arguments.length) return this._source;
+  return (this._source = this._graph.data(src));
+};
+
+prototype.insert = function(tuples) {
+  this._input.add = this._input.add.concat(tuples.map(Tuple.ingest));
+  return this;
+};
+
+prototype.remove = function(where) {
+  var remove = this._data.filter(where);
+  this._input.rem = this._input.rem.concat(remove);
+  return this;
+};
+
+prototype.update = function(where, field, func) {
+  var mod = this._input.mod,
+      ids = Tuple.idMap(mod);
+
+  this._input.fields[field] = 1;
+
+  this._data.filter(where).forEach(function(x) {
+    var prev = x[field],
+        next = func(x);
+    if (prev !== next) {
+      Tuple.set(x, field, next);
+      if (ids[x._id] !== 1) {
+        mod.push(x);
+        ids[x._id] = 1;
+      }
+    }
+  });
+
+  return this;
+};
+
+prototype.values = function(data) {
+  if (!arguments.length) return this._collector.data();
+
+  // Replace backing data
+  this._input.rem = this._data.slice();
+  if (data) { this.insert(data); }
+  return this;
+};
+
+prototype.mutates = function(m) {
+  if (!arguments.length) return this._mutates;
+  this._mutates = this._mutates || m;
+  return this;
+};
+
+prototype.last = function() {
+  return this._output;
+};
+
+prototype.fire = function(input) {
+  if (input) this._input = input;
+  this._graph.propagate(this._input, this._pipeline[0]);
+  return this;
+};
+
+prototype.pipeline = function(pipeline) {
+  if (!arguments.length) return this._pipeline;
+
+  var graph = this._graph,
+      status;
+
+  pipeline.unshift(this._inputNode = DataSourceInput(this));
+  status = graph.preprocess(pipeline);
+
+  if (status.router) {
+    pipeline.push(status.collector = new Collector(graph));
+  }
+
+  pipeline.push(this._outputNode = DataSourceOutput(this));
+  this._collector = status.collector;
+  this._mutates = !!status.mutates;
+  graph.connect(this._pipeline = pipeline);
+
+  return this;
+};
+
+prototype.synchronize = function() {
+  this._graph.synchronize(this._pipeline);
+  return this;
+};
+
+prototype.listener = function() { 
+  return DataSourceListener(this).addListener(this._inputNode);
+};
+
+prototype.addListener = function(l) {
+  if (l instanceof DataSource) {
+    this._collector.addListener(l.listener());
+  } else {
+    this._outputNode.addListener(l);      
+  }
+  return this;
+};
+
+prototype.removeListener = function(l) {
+  this._outputNode.removeListener(l);
+};
+
+prototype.listeners = function(ds) {
+  return (ds ? this._collector : this._outputNode).listeners();
+};
+
+// Input node applies the datasource's delta, and propagates it to 
+// the rest of the pipeline. It receives touches to reflow data.
+function DataSourceInput(ds) {
+  var input = new Node(ds._graph)
+    .router(true)
+    .collector(true);
+
+  input.data = function() {
+    return ds._data;
+  };
+
+  input.evaluate = function(input) {
+    log.debug(input, ['input', ds._name]);
+
+    var delta = ds._input, 
+        out = ChangeSet.create(input), f;
+
+    // Delta might contain fields updated through API
+    for (f in delta.fields) {
+      out.fields[f] = 1;
+    }
+
+    // update data
+    if (delta.rem.length) {
+      ds._data = Tuple.idFilter(ds._data, delta.rem);
+    }
+
+    if (delta.add.length) {
+      ds._data = ds._data.concat(delta.add);
+    }
+
+    // if reflowing, add any other tuples not currently in changeset
+    if (input.reflow) {
+      delta.mod = delta.mod.concat(
+        Tuple.idFilter(ds._data, delta.add, delta.mod, delta.rem));
+    }
+
+    // reset change list
+    ds._input = ChangeSet.create();
+
+    out.add = delta.add; 
+    out.mod = delta.mod;
+    out.rem = delta.rem;
+    out.facet = ds._facet;
+    return out;
+  };
+
+  return input;
+}
+
+// Output node captures the last changeset seen by this datasource
+// (needed for joins and builds) and materializes any nested data.
+// If this datasource is faceted, materializes the values in the facet.
+function DataSourceOutput(ds) {
+  var output = new Node(ds._graph)
+    .router(true)
+    .reflows(true)
+    .collector(true);
+
+  output.data = function() {
+    return ds._collector ? ds._collector.data() : ds._data;
+  };
+
+  output.evaluate = function(input) {
+    log.debug(input, ['output', ds._name]);
+
+    var out = ChangeSet.create(input, true);
+
+    if (ds._facet) {
+      ds._facet.values = ds.values();
+      input.facet = null;
+    }
+
+    ds._output = input;
+    out.data[ds._name] = 1;
+    return out;
+  };
+
+  return output;
+}
+
+function DataSourceListener(ds) {
+  var l = new Node(ds._graph).router(true);
+
+  l.evaluate = function(input) {
+    // Tuple derivation carries a cost. So only derive if the pipeline has
+    // operators that mutate, and thus would override the source data.
+    if (ds.mutates()) {  
+      var map = ds._srcMap || (ds._srcMap = {}), // to propagate tuples correctly
+          output = ChangeSet.create(input);
+
+      output.add = input.add.map(function(t) {
+        return (map[t._id] = Tuple.derive(t));
+      });
+
+      output.mod = input.mod.map(function(t) {
+        return Tuple.rederive(t, map[t._id]);
+      });
+
+      output.rem = input.rem.map(function(t) { 
+        var o = map[t._id];
+        return (map[t._id] = null, o);
+      });
+
+      return (ds._input = output);
+    } else {
+      return (ds._input = input);
+    }
+  };
+
+  return l;
+}
+
+module.exports = DataSource;
+
+},{"./ChangeSet":30,"./Collector":31,"./Node":36,"./Tuple":38,"vega-logging":45}],33:[function(require,module,exports){
+var deps = module.exports = {
+  ALL: ['data', 'fields', 'scales', 'signals']
+};
+deps.ALL.forEach(function(k) { deps[k.toUpperCase()] = k; });
+
+},{}],34:[function(require,module,exports){
+var dl = require('datalib'),
+    Heap = require('./Heap'),
+    ChangeSet = require('./ChangeSet'),
+    DataSource = require('./DataSource'),
+    Collector = require('./Collector'),
+    Tuple = require('./Tuple'),
+    Signal = require('./Signal'),
+    Deps = require('./Dependencies');
+
+function Graph() {
+}
+
+var prototype = Graph.prototype;
+
+prototype.init = function() {
+  this._stamp = 0;
+  this._rank  = 0;
+
+  this._data = {};
+  this._signals = {};
+
+  this.doNotPropagate = {};
+};
+
+prototype.rank = function() {
+  return ++this._rank;
+};
+
+prototype.values = function(type, names, hash) {
+  var data = (type === Deps.SIGNALS ? this._signals : this._data),
+      n = (names !== undefined ? names : dl.keys(data)),
+      vals, i;
+
+  if (Array.isArray(n)) {
+    vals = hash || {};
+    for (i=0; i<n.length; ++i) {
+      vals[n[i]] = data[n[i]].values();
+    }
+    return vals;
+  } else {
+    return data[n].values();
+  }
+};
+
+// Retain for backwards-compatibility
+prototype.dataValues = function(names) {
+  return this.values(Deps.DATA, names);
+};
+
+// Retain for backwards-compatibility
+prototype.signalValues = function(names) {
+  return this.values(Deps.SIGNALS, names);
+};
+
+prototype.data = function(name, pipeline, facet) {
+  var db = this._data;
+  if (!arguments.length) {
+    var all = [], key;
+    for (key in db) { all.push(db[key]); }
+    return all;
+  } else if (arguments.length === 1) {
+    return db[name];
+  } else {
+    return (db[name] = new DataSource(this, name, facet).pipeline(pipeline));
+  }
+};
+
+prototype.signal = function(name, init) {
+  if (arguments.length === 1) {
+    var m = this;
+    return Array.isArray(name) ?
+      name.map(function(n) { return m._signals[n]; }) :
+      this._signals[name];
+  } else {
+    return (this._signals[name] = new Signal(this, name, init));
+  }
+};
+
+prototype.signalRef = function(ref) {
+  if (!Array.isArray(ref)) {
+    ref = dl.field(ref);
+  }
+
+  var value = this.signal(ref[0]).value();
+  if (ref.length > 1) {
+    for (var i=1, n=ref.length; i<n; ++i) {
+      value = value[ref[i]];
+    }
+  }
+  return value;
+};
+
+// Stamp should be specified with caution. It is necessary for inline datasources,
+// which need to be populated during the same cycle even though propagation has
+// passed that part of the dataflow graph.  
+prototype.propagate = function(pulse, node, stamp) {
+  var pulses = {},
+      listeners, next, nplse, tpls, ntpls, i, len;
+
+  // new PQ with each propagation cycle so that we can pulse branches
+  // of the dataflow graph during a propagation (e.g., when creating
+  // a new inline datasource).
+  var pq = new Heap(function(a, b) {
+    // Sort on qrank (queue-rank).
+    // Rank can change during propagation due to rewiring.
+    return a._qrank - b._qrank;
+  });
+
+  if (pulse.stamp) throw Error('Pulse already has a non-zero stamp.');
+
+  pulse.stamp = stamp || ++this._stamp;
+  pulses[node._id] = pulse;
+  pq.push(node.qrank(true));
+
+  while (pq.size() > 0) {
+    node  = pq.peek();
+    pulse = pulses[node._id];
+
+    if (node.rank() !== node.qrank()) {
+      // A node's rank might change during a propagation. Re-queue if so.
+      pq.replace(node.qrank(true));
+    } else {
+      // Evaluate node and propagate pulse.
+      pq.pop();
+      pulses[node._id] = null;
+      listeners = node._listeners;
+      pulse = this.evaluate(pulse, node);
+
+      // Propagate the pulse. 
+      if (pulse !== this.doNotPropagate) {
+        // Ensure reflow pulses always send reflow pulses even if skipped.
+        if (!pulse.reflow && node.reflows()) {
+          pulse = ChangeSet.create(pulse, true);
+        }
+
+        for (i=0, len=listeners.length; i<len; ++i) {
+          next = listeners[i];
+
+          if ((nplse = pulses[next._id]) !== undefined) {
+            if (nplse === null) throw Error('Already propagated to node.');
+            if (nplse === pulse) continue;  // Re-queueing the same pulse.
+
+            // We've already queued this node. Ensure there should be at most one
+            // pulse with tuples (add/mod/rem), and the remainder will be reflows. 
+            tpls  = pulse.add.length || pulse.mod.length || pulse.rem.length;
+            ntpls = nplse.add.length || nplse.mod.length || nplse.rem.length;
+
+            if (tpls && ntpls) throw Error('Multiple changeset pulses to same node');
+
+            // Combine reflow and tuples into a single pulse. 
+            pulses[next._id] = tpls ? pulse : nplse;
+            pulses[next._id].reflow = pulse.reflow || nplse.reflow;
+          } else {
+            // First time we're seeing this node, queue it for propagation.
+            pq.push(next.qrank(true));
+            pulses[next._id] = pulse;
+          }
+        }
+      }
+    }
+  }
+};
+
+// Process a new branch of the dataflow graph prior to connection:
+// (1) Insert new Collector nodes as needed. 
+// (2) Track + return mutation/routing status of the branch.
+prototype.preprocess = function(branch) {
+  var graph = this,
+      mutates = 0,
+      node, router, collector, collects;
+
+  for (var i=0; i<branch.length; ++i) {
+    node = branch[i];
+
+    // Batch nodes need access to a materialized dataset. 
+    if (node.batch() && !node._collector) {
+      if (router || !collector) {
+        node = new Collector(graph);
+        branch.splice(i, 0, node);
+        router = false;
+      } else {
+        node._collector = collector;
+      }
+    }
+
+    if ((collects = node.collector())) collector = node;
+    router  = router  || node.router() && !collects;
+    mutates = mutates || node.mutates();
+
+    // A collector needs to be inserted after tuple-producing
+    // nodes for correct previous value tracking.
+    if (node.produces()) {
+      branch.splice(i+1, 0, new Collector(graph));
+      router = false;
+    }
+  }
+
+  return {router: router, collector: collector, mutates: mutates};
+};
+
+prototype.connect = function(branch) {
+  var collector, node, data, signals, i, n, j, m;
+
+  // connect the pipeline
+  for (i=0, n=branch.length; i<n; ++i) {
+    node = branch[i];
+    if (node.collector()) collector = node;
+
+    data = node.dependency(Deps.DATA);
+    for (j=0, m=data.length; j<m; ++j) {
+      this.data(data[j]).addListener(collector);
+    }
+
+    signals = node.dependency(Deps.SIGNALS);
+    for (j=0, m=signals.length; j<m; ++j) {
+      this.signal(signals[j]).addListener(collector);
+    }
+
+    if (i > 0) branch[i-1].addListener(node);
+  }
+
+  return branch;
+};
+
+prototype.disconnect = function(branch) {
+  var collector, node, data, signals, i, n, j, m;
+
+  for (i=0, n=branch.length; i<n; ++i) {
+    node = branch[i];
+    if (node.collector()) collector = node;
+
+    data = node.dependency(Deps.DATA);
+    for (j=0, m=data.length; j<m; ++j) {
+      this.data(data[j]).removeListener(collector);
+    }
+
+    signals = node.dependency(Deps.SIGNALS);
+    for (j=0, m=signals.length; j<m; ++j) {
+      this.signal(signals[j]).removeListener(collector);
+    }
+
+    node.disconnect();
+  }
+
+  return branch;
+};
+
+prototype.synchronize = function(branch) {
+  var ids = {},
+      node, data, i, n, j, m, d, id;
+
+  for (i=0, n=branch.length; i<n; ++i) {
+    node = branch[i];
+    if (!node.collector()) continue;
+
+    for (j=0, data=node.data(), m=data.length; j<m; ++j) {
+      id = (d = data[j])._id;
+      if (ids[id]) continue; 
+      Tuple.prev_update(d);
+      ids[id] = 1; 
+    }
+  }
+
+  return this;
+};
+
+prototype.reevaluate = function(pulse, node) {
+  var reflowed = pulse.reflow && node.last() >= pulse.stamp,
+      run = node.router() || pulse.add.length || pulse.rem.length;
+
+  return run || !reflowed || node.reevaluate(pulse);
+};
+
+prototype.evaluate = function(pulse, node) {
+  if (!this.reevaluate(pulse, node)) return pulse;
+  pulse = node.evaluate(pulse);
+  node.last(pulse.stamp);
+  return pulse;
+};
+
+module.exports = Graph;
+
+},{"./ChangeSet":30,"./Collector":31,"./DataSource":32,"./Dependencies":33,"./Heap":35,"./Signal":37,"./Tuple":38,"datalib":24}],35:[function(require,module,exports){
+function Heap(comparator) {
+  this.cmp = comparator;
+  this.nodes = [];
+}
+
+var prototype = Heap.prototype;
+
+prototype.size = function() {
+  return this.nodes.length;
+};
+
+prototype.clear = function() {
+  return (this.nodes = [], this);
+};
+
+prototype.peek = function() {
+  return this.nodes[0];
+};
+
+prototype.push = function(x) {
+  var array = this.nodes;
+  array.push(x);
+  return _siftdown(array, 0, array.length-1, this.cmp);
+};
+
+prototype.pop = function() {
+  var array = this.nodes,
+      last = array.pop(),
+      item;
+
+  if (array.length) {
+    item = array[0];
+    array[0] = last;
+    _siftup(array, 0, this.cmp);
+  } else {
+    item = last;
+  }
+  return item;
+};
+
+prototype.replace = function(item) {
+  var array = this.nodes,
+      retval = array[0];
+  array[0] = item;
+  _siftup(array, 0, this.cmp);
+  return retval;
+};
+
+prototype.pushpop = function(item) {
+  var array = this.nodes, ref = array[0];
+  if (array.length && this.cmp(ref, item) < 0) {
+    array[0] = item;
+    item = ref;
+    _siftup(array, 0, this.cmp);
+  }
+  return item;
+};
+
+function _siftdown(array, start, idx, cmp) {
+  var item, parent, pidx;
+
+  item = array[idx];
+  while (idx > start) {
+    pidx = (idx - 1) >> 1;
+    parent = array[pidx];
+    if (cmp(item, parent) < 0) {
+      array[idx] = parent;
+      idx = pidx;
+      continue;
+    }
+    break;
+  }
+  return (array[idx] = item);
+}
+
+function _siftup(array, idx, cmp) {
+  var start = idx,
+      end = array.length,
+      item = array[idx],
+      cidx = 2 * idx + 1, ridx;
+
+  while (cidx < end) {
+    ridx = cidx + 1;
+    if (ridx < end && cmp(array[cidx], array[ridx]) >= 0) {
+      cidx = ridx;
+    }
+    array[idx] = array[cidx];
+    idx = cidx;
+    cidx = 2 * idx + 1;
+  }
+  array[idx] = item;
+  return _siftdown(array, start, idx, cmp);
+}
+
+module.exports = Heap;
+
+},{}],36:[function(require,module,exports){
+var DEPS = require('./Dependencies').ALL,
+    nodeID = 0;
+
+function Node(graph) {
+  if (graph) this.init(graph);
+}
+
+var Flags = Node.Flags = {
+  Router:     0x01, // Responsible for propagating tuples, cannot be skipped.
+  Collector:  0x02, // Holds a materialized dataset, pulse node to reflow.
+  Produces:   0x04, // Produces new tuples. 
+  Mutates:    0x08, // Sets properties of incoming tuples.
+  Reflows:    0x10, // Forwards a reflow pulse.
+  Batch:      0x20  // Performs batch data processing, needs collector.
+};
+
+var prototype = Node.prototype;
+
+prototype.init = function(graph) {
+  this._id = ++nodeID;
+  this._graph = graph;
+  this._rank  = graph.rank(); // Topological sort by rank
+  this._qrank = null; // Rank when enqueued for propagation
+  this._stamp = 0;    // Last stamp seen
+
+  this._listeners = [];
+  this._listeners._ids = {}; // To prevent duplicate listeners
+
+  // Initialize dependencies.
+  this._deps = {};
+  for (var i=0, n=DEPS.length; i<n; ++i) {
+    this._deps[DEPS[i]] = [];
+  }
+
+  // Initialize status flags.
+  this._flags = 0;
+
+  return this;
+};
+
+prototype.rank = function() {
+  return this._rank;
+};
+
+prototype.qrank = function(/* set */) {
+  if (!arguments.length) return this._qrank;
+  return (this._qrank = this._rank, this);
+};
+
+prototype.last = function(stamp) { 
+  if (!arguments.length) return this._stamp;
+  return (this._stamp = stamp, this);
+};
+
+// -- status flags ---
+
+prototype._setf = function(v, b) {
+  if (b) { this._flags |= v; } else { this._flags &= ~v; }
+  return this;
+};
+
+prototype.router = function(state) {
+  if (!arguments.length) return (this._flags & Flags.Router);
+  return this._setf(Flags.Router, state);
+};
+
+prototype.collector = function(state) {
+  if (!arguments.length) return (this._flags & Flags.Collector);
+  return this._setf(Flags.Collector, state);
+};
+
+prototype.produces = function(state) {
+  if (!arguments.length) return (this._flags & Flags.Produces);
+  return this._setf(Flags.Produces, state);
+};
+
+prototype.mutates = function(state) {
+  if (!arguments.length) return (this._flags & Flags.Mutates);
+  return this._setf(Flags.Mutates, state);
+};
+
+prototype.reflows = function(state) {
+  if (!arguments.length) return (this._flags & Flags.Reflows);
+  return this._setf(Flags.Reflows, state);
+};
+
+prototype.batch = function(state) {
+  if (!arguments.length) return (this._flags & Flags.Batch);
+  return this._setf(Flags.Batch, state);
+};
+
+prototype.dependency = function(type, deps) {
+  var d = this._deps[type],
+      n = d._names || (d._names = {});  // To prevent dupe deps
+
+  // Get dependencies of the given type
+  if (arguments.length === 1) {
+    return d;
+  }
+
+  if (deps === null) {
+    // Clear dependencies of the given type
+    d.splice(0, d.length);
+    d._names = {};
+  } else if (!Array.isArray(deps)) {
+    // Separate this case to avoid cost of array creation
+    if (n[deps]) return this;
+    d.push(deps);
+    n[deps] = 1;
+  } else {
+    for (var i=0, len=deps.length, dep; i<len; ++i) {
+      dep = deps[i];
+      if (n[dep]) continue;
+      d.push(dep);
+      n[dep] = 1;
+    }
+  }
+
+  return this;
+};
+
+prototype.listeners = function() {
+  return this._listeners;
+};
+
+prototype.addListener = function(l) {
+  if (!(l instanceof Node)) {
+    throw Error('Listener is not a Node');
+  }
+  if (this._listeners._ids[l._id]) return this;
+
+  this._listeners.push(l);
+  this._listeners._ids[l._id] = 1;
+  if (this._rank > l._rank) {
+    var q = [l],
+        g = this._graph, cur;
+    while (q.length) {
+      cur = q.shift();
+      cur._rank = g.rank();
+      q.unshift.apply(q, cur.listeners());
+    }
+  }
+
+  return this;
+};
+
+prototype.removeListener = function(l) {
+  if (!this._listeners._ids[l._id]) return false;
+  
+  var idx = this._listeners.indexOf(l),
+      b = idx >= 0;
+
+  if (b) {
+    this._listeners.splice(idx, 1);
+    this._listeners._ids[l._id] = null;
+  }
+  return b;
+};
+
+prototype.disconnect = function() {
+  this._listeners = [];
+  this._listeners._ids = {};
+};
+
+// Evaluate this dataflow node for the current pulse.
+// Subclasses should override to perform custom processing.
+prototype.evaluate = function(pulse) {
+  return pulse;
+};
+
+// Should this node be re-evaluated for the current pulse?
+// Searches pulse to see if any dependencies have updated.
+prototype.reevaluate = function(pulse) {
+  var prop, dep, i, n, j, m;
+
+  for (i=0, n=DEPS.length; i<n; ++i) {
+    prop = DEPS[i];
+    dep = this._deps[prop];
+    for (j=0, m=dep.length; j<m; ++j) {
+      if (pulse[prop][dep[j]]) return true;
+    }
+  }
+
+  return false;
+};
+
+Node.reset = function() { nodeID = 0; };
+
+module.exports = Node;
+
+},{"./Dependencies":33}],37:[function(require,module,exports){
+var ChangeSet = require('./ChangeSet'),
+    Node = require('./Node'), // jshint ignore:line
+    Base = Node.prototype;
+
+function Signal(graph, name, initialValue) {
+  Base.init.call(this, graph);
+  this._name  = name;
+  this._value = initialValue;
+  this._verbose = false; // Verbose signals re-pulse the graph even if prev === val.
+  this._handlers = [];
+  return this;
+}
+
+var prototype = (Signal.prototype = Object.create(Base));
+prototype.constructor = Signal;
+
+prototype.name = function() {
+  return this._name;
+};
+
+prototype.value = function(val) {
+  if (!arguments.length) return this._value;
+  return (this._value = val, this);
+};
+
+// Alias to value, for shared API with DataSource
+prototype.values = prototype.value;
+
+prototype.verbose = function(v) {
+  if (!arguments.length) return this._verbose;
+  return (this._verbose = !!v, this);
+};
+
+prototype.evaluate = function(input) {
+  return input.signals[this._name] ? input : this._graph.doNotPropagate;
+};
+
+prototype.fire = function(cs) {
+  if (!cs) cs = ChangeSet.create(null, true);
+  cs.signals[this._name] = 1;
+  this._graph.propagate(cs, this);
+};
+
+prototype.on = function(handler) {
+  var signal = this,
+      node = new Node(this._graph);
+
+  node.evaluate = function(input) {
+    handler(signal.name(), signal.value());
+    return input;
+  };
+
+  this._handlers.push({
+    handler: handler,
+    node: node
+  });
+
+  return this.addListener(node);
+};
+
+prototype.off = function(handler) {
+  var h = this._handlers, i, x;
+
+  for (i=h.length; --i>=0;) {
+    if (!handler || h[i].handler === handler) {
+      x = h.splice(i, 1)[0];
+      this.removeListener(x.node);
+    }
+  }
+
+  return this;
+};
+
+module.exports = Signal;
+
+},{"./ChangeSet":30,"./Node":36}],38:[function(require,module,exports){
+var tupleID = 0;
+
+function ingest(datum) {
+  datum = (datum === Object(datum)) ? datum : {data: datum};
+  datum._id = ++tupleID;
+  if (datum._prev) datum._prev = null;
+  return datum;
+}
+
+function idMap(a, ids) {
+  ids = ids || {};
+  for (var i=0, n=a.length; i<n; ++i) {
+    ids[a[i]._id] = 1;
+  }
+  return ids;
+}
+
+function copy(t, c) {
+  c = c || {};
+  for (var k in t) {
+    if (k !== '_prev' && k !== '_id') c[k] = t[k];
+  }
+  return c;
+}
+
+module.exports = {
+  ingest: ingest,
+  idMap: idMap,
+
+  derive: function(d) {
+    return ingest(copy(d));
+  },
+
+  rederive: function(d, t) {
+    return copy(d, t);
+  },
+
+  set: function(t, k, v) {
+    return t[k] === v ? 0 : (t[k] = v, 1);
+  },
+
+  prev: function(t) {
+    return t._prev || t;
+  },
+
+  prev_init: function(t) {
+    if (!t._prev) { t._prev = {_id: t._id}; }
+  },
+
+  prev_update: function(t) {
+    var p = t._prev, k, v;
+    if (p) for (k in t) {
+      if (k !== '_prev' && k !== '_id') {
+        p[k] = ((v=t[k]) instanceof Object && v._prev) ? v._prev : v;
+      }
+    }
+  },
+
+  reset: function() { tupleID = 0; },
+
+  idFilter: function(data) {
+    var ids = {};
+    for (var i=arguments.length; --i>0;) {
+      idMap(arguments[i], ids);
+    }
+    return data.filter(function(x) { return !ids[x._id]; });
+  }
+};
+
+},{}],39:[function(require,module,exports){
+module.exports = {
+  ChangeSet:    require('./ChangeSet'),
+  Collector:    require('./Collector'),
+  DataSource:   require('./DataSource'),
+  Dependencies: require('./Dependencies'),
+  Graph:        require('./Graph'),
+  Node:         require('./Node'),
+  Signal:       require('./Signal'),
+  Tuple:        require('./Tuple'),
+  debug:        require('vega-logging').debug
+};
+
+},{"./ChangeSet":30,"./Collector":31,"./DataSource":32,"./Dependencies":33,"./Graph":34,"./Node":36,"./Signal":37,"./Tuple":38,"vega-logging":45}],40:[function(require,module,exports){
+function toMap(list) {
+  var map = {}, i, n;
+  for (i=0, n=list.length; i<n; ++i) map[list[i]] = 1;
+  return map;
+}
+
+function keys(object) {
+  var list = [], k;
+  for (k in object) list.push(k);
+  return list;
+}
+
+module.exports = function(opt) {
+  opt = opt || {};
+  var constants = opt.constants || require('./constants'),
+      functions = (opt.functions || require('./functions'))(codegen),
+      idWhiteList = opt.idWhiteList ? toMap(opt.idWhiteList) : null,
+      idBlackList = opt.idBlackList ? toMap(opt.idBlackList) : null,
+      memberDepth = 0,
+      FIELD_VAR = opt.fieldVar || 'datum',
+      GLOBAL_VAR = opt.globalVar || 'signals',
+      globals = {},
+      fields = {};
+
+  function codegen_wrap(ast) {    
+    var retval = {
+      code: codegen(ast),
+      globals: keys(globals),
+      fields: keys(fields)
+    };
+    globals = {};
+    fields = {};
+    return retval;
+  }
+
+  function lookupGlobal(id) {
+    return GLOBAL_VAR + '["' + id + '"]';
+  }
+
+  function codegen(ast) {
+    if (typeof ast === 'string') return ast;
+    var generator = CODEGEN_TYPES[ast.type];
+    if (generator == null) {
+      throw new Error('Unsupported type: ' + ast.type);
+    }
+    return generator(ast);
+  }
+
+  var CODEGEN_TYPES = {
+    'Literal': function(n) {
+        return n.raw;
+      },
+    'Identifier': function(n) {
+        var id = n.name;
+        if (memberDepth > 0) {
+          return id;
+        }
+        if (constants.hasOwnProperty(id)) {
+          return constants[id];
+        }
+        if (idWhiteList) {
+          if (idWhiteList.hasOwnProperty(id)) {
+            return id;
+          } else {
+            globals[id] = 1;
+            return lookupGlobal(id);
+          }
+        }
+        if (idBlackList && idBlackList.hasOwnProperty(id)) {
+          throw new Error('Illegal identifier: ' + id);
+        }
+        return id;
+      },
+    'Program': function(n) {
+        return n.body.map(codegen).join('\n');
+      },
+    'MemberExpression': function(n) {
+        var d = !n.computed;
+        var o = codegen(n.object);
+        if (d) memberDepth += 1;
+        var p = codegen(n.property);
+        if (o === FIELD_VAR) { fields[p] = 1; } // HACKish...
+        if (d) memberDepth -= 1;
+        return o + (d ? '.'+p : '['+p+']');
+      },
+    'CallExpression': function(n) {
+        if (n.callee.type !== 'Identifier') {
+          throw new Error('Illegal callee type: ' + n.callee.type);
+        }
+        var callee = n.callee.name;
+        var args = n.arguments;
+        var fn = functions.hasOwnProperty(callee) && functions[callee];
+        if (!fn) throw new Error('Unrecognized function: ' + callee);
+        return fn instanceof Function ?
+          fn(args) :
+          fn + '(' + args.map(codegen).join(',') + ')';
+      },
+    'ArrayExpression': function(n) {
+        return '[' + n.elements.map(codegen).join(',') + ']';
+      },
+    'BinaryExpression': function(n) {
+        return '(' + codegen(n.left) + n.operator + codegen(n.right) + ')';
+      },
+    'UnaryExpression': function(n) {
+        return '(' + n.operator + codegen(n.argument) + ')';
+      },
+    'ConditionalExpression': function(n) {
+        return '(' + codegen(n.test) +
+          '?' + codegen(n.consequent) +
+          ':' + codegen(n.alternate) +
+          ')';
+      },
+    'LogicalExpression': function(n) {
+        return '(' + codegen(n.left) + n.operator + codegen(n.right) + ')';
+      },
+    'ObjectExpression': function(n) {
+        return '{' + n.properties.map(codegen).join(',') + '}';
+      },
+    'Property': function(n) {
+        memberDepth += 1;
+        var k = codegen(n.key);
+        memberDepth -= 1;
+        return k + ':' + codegen(n.value);
+      },
+    'ExpressionStatement': function(n) {
+        return codegen(n.expression);
+      }
+  };
+
+  codegen_wrap.functions = functions;
+  codegen_wrap.constants = constants;
+  return codegen_wrap;
+};
+
+},{"./constants":41,"./functions":42}],41:[function(require,module,exports){
+module.exports = {
+  'NaN':     'NaN',
+  'E':       'Math.E',
+  'LN2':     'Math.LN2',
+  'LN10':    'Math.LN10',
+  'LOG2E':   'Math.LOG2E',
+  'LOG10E':  'Math.LOG10E',
+  'PI':      'Math.PI',
+  'SQRT1_2': 'Math.SQRT1_2',
+  'SQRT2':   'Math.SQRT2'
+};
+},{}],42:[function(require,module,exports){
+module.exports = function(codegen) {
+
+  function fncall(name, args, cast, type) {
+    var obj = codegen(args[0]);
+    if (cast) {
+      obj = cast + '(' + obj + ')';
+      if (cast.lastIndexOf('new ', 0) === 0) obj = '(' + obj + ')';
+    }
+    return obj + '.' + name + (type < 0 ? '' : type === 0 ?
+      '()' :
+      '(' + args.slice(1).map(codegen).join(',') + ')');
+  }
+
+  function fn(name, cast, type) {
+    return function(args) {
+      return fncall(name, args, cast, type);
+    };
+  }
+
+  var DATE = 'new Date',
+      STRING = 'String',
+      REGEXP = 'RegExp';
+
+  return {
+    // MATH functions
+    'isNaN':    'isNaN',
+    'isFinite': 'isFinite',
+    'abs':      'Math.abs',
+    'acos':     'Math.acos',
+    'asin':     'Math.asin',
+    'atan':     'Math.atan',
+    'atan2':    'Math.atan2',
+    'ceil':     'Math.ceil',
+    'cos':      'Math.cos',
+    'exp':      'Math.exp',
+    'floor':    'Math.floor',
+    'log':      'Math.log',
+    'max':      'Math.max',
+    'min':      'Math.min',
+    'pow':      'Math.pow',
+    'random':   'Math.random',
+    'round':    'Math.round',
+    'sin':      'Math.sin',
+    'sqrt':     'Math.sqrt',
+    'tan':      'Math.tan',
+
+    'clamp': function(args) {
+      if (args.length < 3)
+        throw new Error('Missing arguments to clamp function.');
+      if (args.length > 3)
+      throw new Error('Too many arguments to clamp function.');
+      var a = args.map(codegen);
+      return 'Math.max('+a[1]+', Math.min('+a[2]+','+a[0]+'))';
+    },
+
+    // DATE functions
+    'now':             'Date.now',
+    'datetime':        DATE,
+    'date':            fn('getDate', DATE, 0),
+    'day':             fn('getDay', DATE, 0),
+    'year':            fn('getFullYear', DATE, 0),
+    'month':           fn('getMonth', DATE, 0),
+    'hours':           fn('getHours', DATE, 0),
+    'minutes':         fn('getMinutes', DATE, 0),
+    'seconds':         fn('getSeconds', DATE, 0),
+    'milliseconds':    fn('getMilliseconds', DATE, 0),
+    'time':            fn('getTime', DATE, 0),
+    'timezoneoffset':  fn('getTimezoneOffset', DATE, 0),
+    'utcdate':         fn('getUTCDate', DATE, 0),
+    'utcday':          fn('getUTCDay', DATE, 0),
+    'utcyear':         fn('getUTCFullYear', DATE, 0),
+    'utcmonth':        fn('getUTCMonth', DATE, 0),
+    'utchours':        fn('getUTCHours', DATE, 0),
+    'utcminutes':      fn('getUTCMinutes', DATE, 0),
+    'utcseconds':      fn('getUTCSeconds', DATE, 0),
+    'utcmilliseconds': fn('getUTCMilliseconds', DATE, 0),
+
+    // shared sequence functions
+    'length':      fn('length', null, -1),
+    'indexof':     fn('indexOf', null),
+    'lastindexof': fn('lastIndexOf', null),
+
+    // STRING functions
+    'parseFloat':  'parseFloat',
+    'parseInt':    'parseInt',
+    'upper':       fn('toUpperCase', STRING, 0),
+    'lower':       fn('toLowerCase', STRING, 0),
+    'slice':       fn('slice', STRING),
+    'substring':   fn('substring', STRING),
+
+    // REGEXP functions
+    'regexp':  REGEXP,
+    'test':    fn('test', REGEXP),
+
+    // Control Flow functions
+    'if': function(args) {
+        if (args.length < 3)
+          throw new Error('Missing arguments to if function.');
+        if (args.length > 3)
+        throw new Error('Too many arguments to if function.');
+        var a = args.map(codegen);
+        return a[0]+'?'+a[1]+':'+a[2];
+      }
+  };
+};
+},{}],43:[function(require,module,exports){
+var parser = require('./parser'),
+    codegen = require('./codegen');
+    
+var expr = module.exports = {
+  parse: function(input, opt) {
+      return parser.parse('('+input+')', opt);
+    },
+  code: function(opt) {
+      return codegen(opt);
+    },
+  compiler: function(args, opt) {
+      args = args.slice();
+      var generator = codegen(opt),
+          len = args.length,
+          compile = function(str) {
+            var value = generator(expr.parse(str));
+            args[len] = '"use strict"; return (' + value.code + ');';
+            value.fn = Function.apply(null, args);
+            return value;
+          };
+      compile.codegen = generator;
+      return compile;
+    },
+  functions: require('./functions'),
+  constants: require('./constants')
+};
+
+},{"./codegen":40,"./constants":41,"./functions":42,"./parser":44}],44:[function(require,module,exports){
+/*
+  The following expression parser is based on Esprima (http://esprima.org/).
+  Original header comment and license for Esprima is included here:
+
+  Copyright (C) 2013 Ariya Hidayat <[e-mail]>
+  Copyright (C) 2013 Thaddee Tyl <[e-mail]>
+  Copyright (C) 2013 Mathias Bynens <[e-mail]>
+  Copyright (C) 2012 Ariya Hidayat <[e-mail]>
+  Copyright (C) 2012 Mathias Bynens <[e-mail]>
+  Copyright (C) 2012 Joost-Wim Boekesteijn <[e-mail]>
+  Copyright (C) 2012 Kris Kowal <[e-mail]>
+  Copyright (C) 2012 Yusuke Suzuki <[e-mail]>
+  Copyright (C) 2012 Arpad Borsos <[e-mail]>
+  Copyright (C) 2011 Ariya Hidayat <[e-mail]>
+
+  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.
+
+  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 <COPYRIGHT HOLDER> 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.
+*/
+/* istanbul ignore next */
+module.exports = (function() {
+  'use strict';
+
+  var Token,
+      TokenName,
+      Syntax,
+      PropertyKind,
+      Messages,
+      Regex,
+      source,
+      strict,
+      index,
+      lineNumber,
+      lineStart,
+      length,
+      lookahead,
+      state,
+      extra;
+
+  Token = {
+      BooleanLiteral: 1,
+      EOF: 2,
+      Identifier: 3,
+      Keyword: 4,
+      NullLiteral: 5,
+      NumericLiteral: 6,
+      Punctuator: 7,
+      StringLiteral: 8,
+      RegularExpression: 9
+  };
+
+  TokenName = {};
+  TokenName[Token.BooleanLiteral] = 'Boolean';
+  TokenName[Token.EOF] = '<end>';
+  TokenName[Token.Identifier] = 'Identifier';
+  TokenName[Token.Keyword] = 'Keyword';
+  TokenName[Token.NullLiteral] = 'Null';
+  TokenName[Token.NumericLiteral] = 'Numeric';
+  TokenName[Token.Punctuator] = 'Punctuator';
+  TokenName[Token.StringLiteral] = 'String';
+  TokenName[Token.RegularExpression] = 'RegularExpression';
+
+  Syntax = {
+      AssignmentExpression: 'AssignmentExpression',
+      ArrayExpression: 'ArrayExpression',
+      BinaryExpression: 'BinaryExpression',
+      CallExpression: 'CallExpression',
+      ConditionalExpression: 'ConditionalExpression',
+      ExpressionStatement: 'ExpressionStatement',
+      Identifier: 'Identifier',
+      Literal: 'Literal',
+      LogicalExpression: 'LogicalExpression',
+      MemberExpression: 'MemberExpression',
+      ObjectExpression: 'ObjectExpression',
+      Program: 'Program',
+      Property: 'Property',
+      UnaryExpression: 'UnaryExpression'
+  };
+
+  PropertyKind = {
+      Data: 1,
+      Get: 2,
+      Set: 4
+  };
+
+  // Error messages should be identical to V8.
+  Messages = {
+      UnexpectedToken:  'Unexpected token %0',
+      UnexpectedNumber:  'Unexpected number',
+      UnexpectedString:  'Unexpected string',
+      UnexpectedIdentifier:  'Unexpected identifier',
+      UnexpectedReserved:  'Unexpected reserved word',
+      UnexpectedEOS:  'Unexpected end of input',
+      NewlineAfterThrow:  'Illegal newline after throw',
+      InvalidRegExp: 'Invalid regular expression',
+      UnterminatedRegExp:  'Invalid regular expression: missing /',
+      InvalidLHSInAssignment:  'Invalid left-hand side in assignment',
+      InvalidLHSInForIn:  'Invalid left-hand side in for-in',
+      MultipleDefaultsInSwitch: 'More than one default clause in switch statement',
+      NoCatchOrFinally:  'Missing catch or finally after try',
+      UnknownLabel: 'Undefined label \'%0\'',
+      Redeclaration: '%0 \'%1\' has already been declared',
+      IllegalContinue: 'Illegal continue statement',
+      IllegalBreak: 'Illegal break statement',
+      IllegalReturn: 'Illegal return statement',
+      StrictModeWith:  'Strict mode code may not include a with statement',
+      StrictCatchVariable:  'Catch variable may not be eval or arguments in strict mode',
+      StrictVarName:  'Variable name may not be eval or arguments in strict mode',
+      StrictParamName:  'Parameter name eval or arguments is not allowed in strict mode',
+      StrictParamDupe: 'Strict mode function may not have duplicate parameter names',
+      StrictFunctionName:  'Function name may not be eval or arguments in strict mode',
+      StrictOctalLiteral:  'Octal literals are not allowed in strict mode.',
+      StrictDelete:  'Delete of an unqualified identifier in strict mode.',
+      StrictDuplicateProperty:  'Duplicate data property in object literal not allowed in strict mode',
+      AccessorDataProperty:  'Object literal may not have data and accessor property with the same name',
+      AccessorGetSet:  'Object literal may not have multiple get/set accessors with the same name',
+      StrictLHSAssignment:  'Assignment to eval or arguments is not allowed in strict mode',
+      StrictLHSPostfix:  'Postfix increment/decrement may not have eval or arguments operand in strict mode',
+      StrictLHSPrefix:  'Prefix increment/decrement may not have eval or arguments operand in strict mode',
+      StrictReservedWord:  'Use of future reserved word in strict mode'
+  };
+
+  // See also tools/generate-unicode-regex.py.
+  Regex = {
+      NonAsciiIdentifierStart: new RegExp('[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0-\u08B2\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58\u0C59\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D60\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19C1-\u19C7\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA7AD\uA7B0\uA7B1\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB5F\uAB64\uAB65\uABC0-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]'),
+      NonAsciiIdentifierPart: new RegExp('[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0300-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u0483-\u0487\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u05D0-\u05EA\u05F0-\u05F2\u0610-\u061A\u0620-\u0669\u066E-\u06D3\u06D5-\u06DC\u06DF-\u06E8\u06EA-\u06FC\u06FF\u0710-\u074A\u074D-\u07B1\u07C0-\u07F5\u07FA\u0800-\u082D\u0840-\u085B\u08A0-\u08B2\u08E4-\u0963\u0966-\u096F\u0971-\u0983\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BC-\u09C4\u09C7\u09C8\u09CB-\u09CE\u09D7\u09DC\u09DD\u09DF-\u09E3\u09E6-\u09F1\u0A01-\u0A03\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A59-\u0A5C\u0A5E\u0A66-\u0A75\u0A81-\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABC-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AD0\u0AE0-\u0AE3\u0AE6-\u0AEF\u0B01-\u0B03\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3C-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B5C\u0B5D\u0B5F-\u0B63\u0B66-\u0B6F\u0B71\u0B82\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD0\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C58\u0C59\u0C60-\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBC-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CDE\u0CE0-\u0CE3\u0CE6-\u0CEF\u0CF1\u0CF2\u0D01-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D-\u0D44\u0D46-\u0D48\u0D4A-\u0D4E\u0D57\u0D60-\u0D63\u0D66-\u0D6F\u0D7A-\u0D7F\u0D82\u0D83\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E01-\u0E3A\u0E40-\u0E4E\u0E50-\u0E59\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB9\u0EBB-\u0EBD\u0EC0-\u0EC4\u0EC6\u0EC8-\u0ECD\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E-\u0F47\u0F49-\u0F6C\u0F71-\u0F84\u0F86-\u0F97\u0F99-\u0FBC\u0FC6\u1000-\u1049\u1050-\u109D\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u135D-\u135F\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1714\u1720-\u1734\u1740-\u1753\u1760-\u176C\u176E-\u1770\u1772\u1773\u1780-\u17D3\u17D7\u17DC\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u1820-\u1877\u1880-\u18AA\u18B0-\u18F5\u1900-\u191E\u1920-\u192B\u1930-\u193B\u1946-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u19D0-\u19D9\u1A00-\u1A1B\u1A20-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AA7\u1AB0-\u1ABD\u1B00-\u1B4B\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1BF3\u1C00-\u1C37\u1C40-\u1C49\u1C4D-\u1C7D\u1CD0-\u1CD2\u1CD4-\u1CF6\u1CF8\u1CF9\u1D00-\u1DF5\u1DFC-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200C\u200D\u203F\u2040\u2054\u2071\u207F\u2090-\u209C\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D7F-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2DE0-\u2DFF\u2E2F\u3005-\u3007\u3021-\u302F\u3031-\u3035\u3038-\u303C\u3041-\u3096\u3099\u309A\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA62B\uA640-\uA66F\uA674-\uA67D\uA67F-\uA69D\uA69F-\uA6F1\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA7AD\uA7B0\uA7B1\uA7F7-\uA827\uA840-\uA873\uA880-\uA8C4\uA8D0-\uA8D9\uA8E0-\uA8F7\uA8FB\uA900-\uA92D\uA930-\uA953\uA960-\uA97C\uA980-\uA9C0\uA9CF-\uA9D9\uA9E0-\uA9FE\uAA00-\uAA36\uAA40-\uAA4D\uAA50-\uAA59\uAA60-\uAA76\uAA7A-\uAAC2\uAADB-\uAADD\uAAE0-\uAAEF\uAAF2-\uAAF6\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB5F\uAB64\uAB65\uABC0-\uABEA\uABEC\uABED\uABF0-\uABF9\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE00-\uFE0F\uFE20-\uFE2D\uFE33\uFE34\uFE4D-\uFE4F\uFE70-\uFE74\uFE76-\uFEFC\uFF10-\uFF19\uFF21-\uFF3A\uFF3F\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]')
+  };
+
+  // Ensure the condition is true, otherwise throw an error.
+  // This is only to have a better contract semantic, i.e. another safety net
+  // to catch a logic error. The condition shall be fulfilled in normal case.
+  // Do NOT use this to enforce a certain condition on any user input.
+
+  function assert(condition, message) {
+      if (!condition) {
+          throw new Error('ASSERT: ' + message);
+      }
+  }
+
+  function isDecimalDigit(ch) {
+      return (ch >= 0x30 && ch <= 0x39);   // 0..9
+  }
+
+  function isHexDigit(ch) {
+      return '0123456789abcdefABCDEF'.indexOf(ch) >= 0;
+  }
+
+  function isOctalDigit(ch) {
+      return '01234567'.indexOf(ch) >= 0;
+  }
+
+  // 7.2 White Space
+
+  function isWhiteSpace(ch) {
+      return (ch === 0x20) || (ch === 0x09) || (ch === 0x0B) || (ch === 0x0C) || (ch === 0xA0) ||
+          (ch >= 0x1680 && [0x1680, 0x180E, 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006, 0x2007, 0x2008, 0x2009, 0x200A, 0x202F, 0x205F, 0x3000, 0xFEFF].indexOf(ch) >= 0);
+  }
+
+  // 7.3 Line Terminators
+
+  function isLineTerminator(ch) {
+      return (ch === 0x0A) || (ch === 0x0D) || (ch === 0x2028) || (ch === 0x2029);
+  }
+
+  // 7.6 Identifier Names and Identifiers
+
+  function isIdentifierStart(ch) {
+      return (ch === 0x24) || (ch === 0x5F) ||  // $ (dollar) and _ (underscore)
+          (ch >= 0x41 && ch <= 0x5A) ||         // A..Z
+          (ch >= 0x61 && ch <= 0x7A) ||         // a..z
+          (ch === 0x5C) ||                      // \ (backslash)
+          ((ch >= 0x80) && Regex.NonAsciiIdentifierStart.test(String.fromCharCode(ch)));
+  }
+
+  function isIdentifierPart(ch) {
+      return (ch === 0x24) || (ch === 0x5F) ||  // $ (dollar) and _ (underscore)
+          (ch >= 0x41 && ch <= 0x5A) ||         // A..Z
+          (ch >= 0x61 && ch <= 0x7A) ||         // a..z
+          (ch >= 0x30 && ch <= 0x39) ||         // 0..9
+          (ch === 0x5C) ||                      // \ (backslash)
+          ((ch >= 0x80) && Regex.NonAsciiIdentifierPart.test(String.fromCharCode(ch)));
+  }
+
+  // 7.6.1.2 Future Reserved Words
+
+  function isFutureReservedWord(id) {
+      switch (id) {
+      case 'class':
+      case 'enum':
+      case 'export':
+      case 'extends':
+      case 'import':
+      case 'super':
+          return true;
+      default:
+          return false;
+      }
+  }
+
+  function isStrictModeReservedWord(id) {
+      switch (id) {
+      case 'implements':
+      case 'interface':
+      case 'package':
+      case 'private':
+      case 'protected':
+      case 'public':
+      case 'static':
+      case 'yield':
+      case 'let':
+          return true;
+      default:
+          return false;
+      }
+  }
+
+  // 7.6.1.1 Keywords
+
+  function isKeyword(id) {
+      if (strict && isStrictModeReservedWord(id)) {
+          return true;
+      }
+
+      // 'const' is specialized as Keyword in V8.
+      // 'yield' and 'let' are for compatiblity with SpiderMonkey and ES.next.
+      // Some others are from future reserved words.
+
+      switch (id.length) {
+      case 2:
+          return (id === 'if') || (id === 'in') || (id === 'do');
+      case 3:
+          return (id === 'var') || (id === 'for') || (id === 'new') ||
+              (id === 'try') || (id === 'let');
+      case 4:
+          return (id === 'this') || (id === 'else') || (id === 'case') ||
+              (id === 'void') || (id === 'with') || (id === 'enum');
+      case 5:
+          return (id === 'while') || (id === 'break') || (id === 'catch') ||
+              (id === 'throw') || (id === 'const') || (id === 'yield') ||
+              (id === 'class') || (id === 'super');
+      case 6:
+          return (id === 'return') || (id === 'typeof') || (id === 'delete') ||
+              (id === 'switch') || (id === 'export') || (id === 'import');
+      case 7:
+          return (id === 'default') || (id === 'finally') || (id === 'extends');
+      case 8:
+          return (id === 'function') || (id === 'continue') || (id === 'debugger');
+      case 10:
+          return (id === 'instanceof');
+      default:
+          return false;
+      }
+  }
+
+  function skipComment() {
+      var ch, start;
+
+      start = (index === 0);
+      while (index < length) {
+          ch = source.charCodeAt(index);
+
+          if (isWhiteSpace(ch)) {
+              ++index;
+          } else if (isLineTerminator(ch)) {
+              ++index;
+              if (ch === 0x0D && source.charCodeAt(index) === 0x0A) {
+                  ++index;
+              }
+              ++lineNumber;
+              lineStart = index;
+              start = true;
+          } else {
+              break;
+          }
+      }
+  }
+
+  function scanHexEscape(prefix) {
+      var i, len, ch, code = 0;
+
+      len = (prefix === 'u') ? 4 : 2;
+      for (i = 0; i < len; ++i) {
+          if (index < length && isHexDigit(source[index])) {
+              ch = source[index++];
+              code = code * 16 + '0123456789abcdef'.indexOf(ch.toLowerCase());
+          } else {
+              return '';
+          }
+      }
+      return String.fromCharCode(code);
+  }
+
+  function scanUnicodeCodePointEscape() {
+      var ch, code, cu1, cu2;
+
+      ch = source[index];
+      code = 0;
+
+      // At least, one hex digit is required.
+      if (ch === '}') {
+          throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+      }
+
+      while (index < length) {
+          ch = source[index++];
+          if (!isHexDigit(ch)) {
+              break;
+          }
+          code = code * 16 + '0123456789abcdef'.indexOf(ch.toLowerCase());
+      }
+
+      if (code > 0x10FFFF || ch !== '}') {
+          throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+      }
+
+      // UTF-16 Encoding
+      if (code <= 0xFFFF) {
+          return String.fromCharCode(code);
+      }
+      cu1 = ((code - 0x10000) >> 10) + 0xD800;
+      cu2 = ((code - 0x10000) & 1023) + 0xDC00;
+      return String.fromCharCode(cu1, cu2);
+  }
+
+  function getEscapedIdentifier() {
+      var ch, id;
+
+      ch = source.charCodeAt(index++);
+      id = String.fromCharCode(ch);
+
+      // '\u' (U+005C, U+0075) denotes an escaped character.
+      if (ch === 0x5C) {
+          if (source.charCodeAt(index) !== 0x75) {
+              throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+          }
+          ++index;
+          ch = scanHexEscape('u');
+          if (!ch || ch === '\\' || !isIdentifierStart(ch.charCodeAt(0))) {
+              throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+          }
+          id = ch;
+      }
+
+      while (index < length) {
+          ch = source.charCodeAt(index);
+          if (!isIdentifierPart(ch)) {
+              break;
+          }
+          ++index;
+          id += String.fromCharCode(ch);
+
+          // '\u' (U+005C, U+0075) denotes an escaped character.
+          if (ch === 0x5C) {
+              id = id.substr(0, id.length - 1);
+              if (source.charCodeAt(index) !== 0x75) {
+                  throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+              }
+              ++index;
+              ch = scanHexEscape('u');
+              if (!ch || ch === '\\' || !isIdentifierPart(ch.charCodeAt(0))) {
+                  throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+              }
+              id += ch;
+          }
+      }
+
+      return id;
+  }
+
+  function getIdentifier() {
+      var start, ch;
+
+      start = index++;
+      while (index < length) {
+          ch = source.charCodeAt(index);
+          if (ch === 0x5C) {
+              // Blackslash (U+005C) marks Unicode escape sequence.
+              index = start;
+              return getEscapedIdentifier();
+          }
+          if (isIdentifierPart(ch)) {
+              ++index;
+          } else {
+              break;
+          }
+      }
+
+      return source.slice(start, index);
+  }
+
+  function scanIdentifier() {
+      var start, id, type;
+
+      start = index;
+
+      // Backslash (U+005C) starts an escaped character.
+      id = (source.charCodeAt(index) === 0x5C) ? getEscapedIdentifier() : getIdentifier();
+
+      // There is no keyword or literal with only one character.
+      // Thus, it must be an identifier.
+      if (id.length === 1) {
+          type = Token.Identifier;
+      } else if (isKeyword(id)) {
+          type = Token.Keyword;
+      } else if (id === 'null') {
+          type = Token.NullLiteral;
+      } else if (id === 'true' || id === 'false') {
+          type = Token.BooleanLiteral;
+      } else {
+          type = Token.Identifier;
+      }
+
+      return {
+          type: type,
+          value: id,
+          lineNumber: lineNumber,
+          lineStart: lineStart,
+          start: start,
+          end: index
+      };
+  }
+
+  // 7.7 Punctuators
+
+  function scanPunctuator() {
+      var start = index,
+          code = source.charCodeAt(index),
+          code2,
+          ch1 = source[index],
+          ch2,
+          ch3,
+          ch4;
+
+      switch (code) {
+
+      // Check for most common single-character punctuators.
+      case 0x2E:  // . dot
+      case 0x28:  // ( open bracket
+      case 0x29:  // ) close bracket
+      case 0x3B:  // ; semicolon
+      case 0x2C:  // , comma
+      case 0x7B:  // { open curly brace
+      case 0x7D:  // } close curly brace
+      case 0x5B:  // [
+      case 0x5D:  // ]
+      case 0x3A:  // :
+      case 0x3F:  // ?
+      case 0x7E:  // ~
+          ++index;
+          if (extra.tokenize) {
+              if (code === 0x28) {
+                  extra.openParenToken = extra.tokens.length;
+              } else if (code === 0x7B) {
+                  extra.openCurlyToken = extra.tokens.length;
+              }
+          }
+          return {
+              type: Token.Punctuator,
+              value: String.fromCharCode(code),
+              lineNumber: lineNumber,
+              lineStart: lineStart,
+              start: start,
+              end: index
+          };
+
+      default:
+          code2 = source.charCodeAt(index + 1);
+
+          // '=' (U+003D) marks an assignment or comparison operator.
+          if (code2 === 0x3D) {
+              switch (code) {
+              case 0x2B:  // +
+              case 0x2D:  // -
+              case 0x2F:  // /
+              case 0x3C:  // <
+              case 0x3E:  // >
+              case 0x5E:  // ^
+              case 0x7C:  // |
+              case 0x25:  // %
+              case 0x26:  // &
+              case 0x2A:  // *
+                  index += 2;
+                  return {
+                      type: Token.Punctuator,
+                      value: String.fromCharCode(code) + String.fromCharCode(code2),
+                      lineNumber: lineNumber,
+                      lineStart: lineStart,
+                      start: start,
+                      end: index
+                  };
+
+              case 0x21: // !
+              case 0x3D: // =
+                  index += 2;
+
+                  // !== and ===
+                  if (source.charCodeAt(index) === 0x3D) {
+                      ++index;
+                  }
+                  return {
+                      type: Token.Punctuator,
+                      value: source.slice(start, index),
+                      lineNumber: lineNumber,
+                      lineStart: lineStart,
+                      start: start,
+                      end: index
+                  };
+              }
+          }
+      }
+
+      // 4-character punctuator: >>>=
+
+      ch4 = source.substr(index, 4);
+
+      if (ch4 === '>>>=') {
+          index += 4;
+          return {
+              type: Token.Punctuator,
+              value: ch4,
+              lineNumber: lineNumber,
+              lineStart: lineStart,
+              start: start,
+              end: index
+          };
+      }
+
+      // 3-character punctuators: === !== >>> <<= >>=
+
+      ch3 = ch4.substr(0, 3);
+
+      if (ch3 === '>>>' || ch3 === '<<=' || ch3 === '>>=') {
+          index += 3;
+          return {
+              type: Token.Punctuator,
+              value: ch3,
+              lineNumber: lineNumber,
+              lineStart: lineStart,
+              start: start,
+              end: index
+          };
+      }
+
+      // Other 2-character punctuators: ++ -- << >> && ||
+      ch2 = ch3.substr(0, 2);
+
+      if ((ch1 === ch2[1] && ('+-<>&|'.indexOf(ch1) >= 0)) || ch2 === '=>') {
+          index += 2;
+          return {
+              type: Token.Punctuator,
+              value: ch2,
+              lineNumber: lineNumber,
+              lineStart: lineStart,
+              start: start,
+              end: index
+          };
+      }
+
+      // 1-character punctuators: < > = ! + - * % & | ^ /
+
+      if ('<>=!+-*%&|^/'.indexOf(ch1) >= 0) {
+          ++index;
+          return {
+              type: Token.Punctuator,
+              value: ch1,
+              lineNumber: lineNumber,
+              lineStart: lineStart,
+              start: start,
+              end: index
+          };
+      }
+
+      throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+  }
+
+  // 7.8.3 Numeric Literals
+
+  function scanHexLiteral(start) {
+      var number = '';
+
+      while (index < length) {
+          if (!isHexDigit(source[index])) {
+              break;
+          }
+          number += source[index++];
+      }
+
+      if (number.length === 0) {
+          throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+      }
+
+      if (isIdentifierStart(source.charCodeAt(index))) {
+          throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+      }
+
+      return {
+          type: Token.NumericLiteral,
+          value: parseInt('0x' + number, 16),
+          lineNumber: lineNumber,
+          lineStart: lineStart,
+          start: start,
+          end: index
+      };
+  }
+
+  function scanOctalLiteral(start) {
+      var number = '0' + source[index++];
+      while (index < length) {
+          if (!isOctalDigit(source[index])) {
+              break;
+          }
+          number += source[index++];
+      }
+
+      if (isIdentifierStart(source.charCodeAt(index)) || isDecimalDigit(source.charCodeAt(index))) {
+          throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+      }
+
+      return {
+          type: Token.NumericLiteral,
+          value: parseInt(number, 8),
+          octal: true,
+          lineNumber: lineNumber,
+          lineStart: lineStart,
+          start: start,
+          end: index
+      };
+  }
+
+  function scanNumericLiteral() {
+      var number, start, ch;
+
+      ch = source[index];
+      assert(isDecimalDigit(ch.charCodeAt(0)) || (ch === '.'),
+          'Numeric literal must start with a decimal digit or a decimal point');
+
+      start = index;
+      number = '';
+      if (ch !== '.') {
+          number = source[index++];
+          ch = source[index];
+
+          // Hex number starts with '0x'.
+          // Octal number starts with '0'.
+          if (number === '0') {
+              if (ch === 'x' || ch === 'X') {
+                  ++index;
+                  return scanHexLiteral(start);
+              }
+              if (isOctalDigit(ch)) {
+                  return scanOctalLiteral(start);
+              }
+
+              // decimal number starts with '0' such as '09' is illegal.
+              if (ch && isDecimalDigit(ch.charCodeAt(0))) {
+                  throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+              }
+          }
+
+          while (isDecimalDigit(source.charCodeAt(index))) {
+              number += source[index++];
+          }
+          ch = source[index];
+      }
+
+      if (ch === '.') {
+          number += source[index++];
+          while (isDecimalDigit(source.charCodeAt(index))) {
+              number += source[index++];
+          }
+          ch = source[index];
+      }
+
+      if (ch === 'e' || ch === 'E') {
+          number += source[index++];
+
+          ch = source[index];
+          if (ch === '+' || ch === '-') {
+              number += source[index++];
+          }
+          if (isDecimalDigit(source.charCodeAt(index))) {
+              while (isDecimalDigit(source.charCodeAt(index))) {
+                  number += source[index++];
+              }
+          } else {
+              throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+          }
+      }
+
+      if (isIdentifierStart(source.charCodeAt(index))) {
+          throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+      }
+
+      return {
+          type: Token.NumericLiteral,
+          value: parseFloat(number),
+          lineNumber: lineNumber,
+          lineStart: lineStart,
+          start: start,
+          end: index
+      };
+  }
+
+  // 7.8.4 String Literals
+
+  function scanStringLiteral() {
+      var str = '', quote, start, ch, code, unescaped, restore, octal = false, startLineNumber, startLineStart;
+      startLineNumber = lineNumber;
+      startLineStart = lineStart;
+
+      quote = source[index];
+      assert((quote === '\'' || quote === '"'),
+          'String literal must starts with a quote');
+
+      start = index;
+      ++index;
+
+      while (index < length) {
+          ch = source[index++];
+
+          if (ch === quote) {
+              quote = '';
+              break;
+          } else if (ch === '\\') {
+              ch = source[index++];
+              if (!ch || !isLineTerminator(ch.charCodeAt(0))) {
+                  switch (ch) {
+                  case 'u':
+                  case 'x':
+                      if (source[index] === '{') {
+                          ++index;
+                          str += scanUnicodeCodePointEscape();
+                      } else {
+                          restore = index;
+                          unescaped = scanHexEscape(ch);
+                          if (unescaped) {
+                              str += unescaped;
+                          } else {
+                              index = restore;
+                              str += ch;
+                          }
+                      }
+                      break;
+                  case 'n':
+                      str += '\n';
+                      break;
+                  case 'r':
+                      str += '\r';
+                      break;
+                  case 't':
+                      str += '\t';
+                      break;
+                  case 'b':
+                      str += '\b';
+                      break;
+                  case 'f':
+                      str += '\f';
+                      break;
+                  case 'v':
+                      str += '\x0B';
+                      break;
+
+                  default:
+                      if (isOctalDigit(ch)) {
+                          code = '01234567'.indexOf(ch);
+
+                          // \0 is not octal escape sequence
+                          if (code !== 0) {
+                              octal = true;
+                          }
+
+                          if (index < length && isOctalDigit(source[index])) {
+                              octal = true;
+                              code = code * 8 + '01234567'.indexOf(source[index++]);
+
+                              // 3 digits are only allowed when string starts
+                              // with 0, 1, 2, 3
+                              if ('0123'.indexOf(ch) >= 0 &&
+                                      index < length &&
+                                      isOctalDigit(source[index])) {
+                                  code = code * 8 + '01234567'.indexOf(source[index++]);
+                              }
+                          }
+                          str += String.fromCharCode(code);
+                      } else {
+                          str += ch;
+                      }
+                      break;
+                  }
+              } else {
+                  ++lineNumber;
+                  if (ch ===  '\r' && source[index] === '\n') {
+                      ++index;
+                  }
+                  lineStart = index;
+              }
+          } else if (isLineTerminator(ch.charCodeAt(0))) {
+              break;
+          } else {
+              str += ch;
+          }
+      }
+
+      if (quote !== '') {
+          throwError({}, Messages.UnexpectedToken, 'ILLEGAL');
+      }
+
+      return {
+          type: Token.StringLiteral,
+          value: str,
+          octal: octal,
+          startLineNumber: startLineNumber,
+          startLineStart: startLineStart,
+          lineNumber: lineNumber,
+          lineStart: lineStart,
+          start: start,
+          end: index
+      };
+  }
+
+  function testRegExp(pattern, flags) {
+      var tmp = pattern,
+          value;
+
+      if (flags.indexOf('u') >= 0) {
+          // Replace each astral symbol and every Unicode code point
+          // escape sequence with a single ASCII symbol to avoid throwing on
+          // regular expressions that are only valid in combination with the
+          // `/u` flag.
+          // Note: replacing with the ASCII symbol `x` might cause false
+          // negatives in unlikely scenarios. For example, `[\u{61}-b]` is a
+          // perfectly valid pattern that is equivalent to `[a-b]`, but it
+          // would be replaced by `[x-b]` which throws an error.
+          tmp = tmp
+              .replace(/\\u\{([0-9a-fA-F]+)\}/g, function ($0, $1) {
+                  if (parseInt($1, 16) <= 0x10FFFF) {
+                      return 'x';
+                  }
+                  throwError({}, Messages.InvalidRegExp);
+              })
+              .replace(/[\uD800-\uDBFF][\uDC00-\uDFFF]/g, 'x');
+      }
+
+      // First, detect invalid regular expressions.
+      try {
+          value = new RegExp(tmp);
+      } catch (e) {
+          throwError({}, Messages.InvalidRegExp);
+      }
+
+      // Return a regular expression object for this pattern-flag pair, or
+      // `null` in case the current environment doesn't support the flags it
+      // uses.
+      try {
+          return new RegExp(pattern, flags);
+      } catch (exception) {
+          return null;
+      }
+  }
+
+  function scanRegExpBody() {
+      var ch, str, classMarker, terminated, body;
+
+      ch = source[index];
+      assert(ch === '/', 'Regular expression literal must start with a slash');
+      str = source[index++];
+
+      classMarker = false;
+      terminated = false;
+      while (index < length) {
+          ch = source[index++];
+          str += ch;
+          if (ch === '\\') {
+              ch = source[index++];
+              // ECMA-262 7.8.5
+              if (isLineTerminator(ch.charCodeAt(0))) {
+                  throwError({}, Messages.UnterminatedRegExp);
+              }
+              str += ch;
+          } else if (isLineTerminator(ch.charCodeAt(0))) {
+              throwError({}, Messages.UnterminatedRegExp);
+          } else if (classMarker) {
+              if (ch === ']') {
+                  classMarker = false;
+              }
+          } else {
+              if (ch === '/') {
+                  terminated = true;
+                  break;
+              } else if (ch === '[') {
+                  classMarker = true;
+              }
+          }
+      }
+
+      if (!terminated) {
+          throwError({}, Messages.UnterminatedRegExp);
+      }
+
+      // Exclude leading and trailing slash.
+      body = str.substr(1, str.length - 2);
+      return {
+          value: body,
+          literal: str
+      };
+  }
+
+  function scanRegExpFlags() {
+      var ch, str, flags, restore;
+
+      str = '';
+      flags = '';
+      while (index < length) {
+          ch = source[index];
+          if (!isIdentifierPart(ch.charCodeAt(0))) {
+              break;
+          }
+
+          ++index;
+          if (ch === '\\' && index < length) {
+              ch = source[index];
+              if (ch === 'u') {
+                  ++index;
+                  restore = index;
+                  ch = scanHexEscape('u');
+                  if (ch) {
+                      flags += ch;
+                      for (str += '\\u'; restore < index; ++restore) {
+                          str += source[restore];
+                      }
+                  } else {
+                      index = restore;
+                      flags += 'u';
+                      str += '\\u';
+                  }
+                  throwErrorTolerant({}, Messages.UnexpectedToken, 'ILLEGAL');
+              } else {
+                  str += '\\';
+                  throwErrorTolerant({}, Messages.UnexpectedToken, 'ILLEGAL');
+              }
+          } else {
+              flags += ch;
+              str += ch;
+          }
+      }
+
+      return {
+          value: flags,
+          literal: str
+      };
+  }
+
+  function scanRegExp() {
+      var start, body, flags, value;
+
+      lookahead = null;
+      skipComment();
+      start = index;
+
+      body = scanRegExpBody();
+      flags = scanRegExpFlags();
+      value = testRegExp(body.value, flags.value);
+
+      if (extra.tokenize) {
+          return {
+              type: Token.RegularExpression,
+              value: value,
+              regex: {
+                  pattern: body.value,
+                  flags: flags.value
+              },
+              lineNumber: lineNumber,
+              lineStart: lineStart,
+              start: start,
+              end: index
+          };
+      }
+
+      return {
+          literal: body.literal + flags.literal,
+          value: value,
+          regex: {
+              pattern: body.value,
+              flags: flags.value
+          },
+          start: start,
+          end: index
+      };
+  }
+
+  function collectRegex() {
+      var pos, loc, regex, token;
+
+      skipComment();
+
+      pos = index;
+      loc = {
+          start: {
+              line: lineNumber,
+              column: index - lineStart
+          }
+      };
+
+      regex = scanRegExp();
+
+      loc.end = {
+          line: lineNumber,
+          column: index - lineStart
+      };
+
+      if (!extra.tokenize) {
+          // Pop the previous token, which is likely '/' or '/='
+          if (extra.tokens.length > 0) {
+              token = extra.tokens[extra.tokens.length - 1];
+              if (token.range[0] === pos && token.type === 'Punctuator') {
+                  if (token.value === '/' || token.value === '/=') {
+                      extra.tokens.pop();
+                  }
+              }
+          }
+
+          extra.tokens.push({
+              type: 'RegularExpression',
+              value: regex.literal,
+              regex: regex.regex,
+              range: [pos, index],
+              loc: loc
+          });
+      }
+
+      return regex;
+  }
+
+  function isIdentifierName(token) {
+      return token.type === Token.Identifier ||
+          token.type === Token.Keyword ||
+          token.type === Token.BooleanLiteral ||
+          token.type === Token.NullLiteral;
+  }
+
+  function advanceSlash() {
+      var prevToken,
+          checkToken;
+      // Using the following algorithm:
+      // https://github.com/mozilla/sweet.js/wiki/design
+      prevToken = extra.tokens[extra.tokens.length - 1];
+      if (!prevToken) {
+          // Nothing before that: it cannot be a division.
+          return collectRegex();
+      }
+      if (prevToken.type === 'Punctuator') {
+          if (prevToken.value === ']') {
+              return scanPunctuator();
+          }
+          if (prevToken.value === ')') {
+              checkToken = extra.tokens[extra.openParenToken - 1];
+              if (checkToken &&
+                      checkToken.type === 'Keyword' &&
+                      (checkToken.value === 'if' ||
+                       checkToken.value === 'while' ||
+                       checkToken.value === 'for' ||
+                       checkToken.value === 'with')) {
+                  return collectRegex();
+              }
+              return scanPunctuator();
+          }
+          if (prevToken.value === '}') {
+              // Dividing a function by anything makes little sense,
+              // but we have to check for that.
+              if (extra.tokens[extra.openCurlyToken - 3] &&
+                      extra.tokens[extra.openCurlyToken - 3].type === 'Keyword') {
+                  // Anonymous function.
+                  checkToken = extra.tokens[extra.openCurlyToken - 4];
+                  if (!checkToken) {
+                      return scanPunctuator();
+                  }
+              } else if (extra.tokens[extra.openCurlyToken - 4] &&
+                      extra.tokens[extra.openCurlyToken - 4].type === 'Keyword') {
+                  // Named function.
+                  checkToken = extra.tokens[extra.openCurlyToken - 5];
+                  if (!checkToken) {
+                      return collectRegex();
+                  }
+              } else {
+                  return scanPunctuator();
+              }
+              return scanPunctuator();
+          }
+          return collectRegex();
+      }
+      if (prevToken.type === 'Keyword' && prevToken.value !== 'this') {
+          return collectRegex();
+      }
+      return scanPunctuator();
+  }
+
+  function advance() {
+      var ch;
+
+      skipComment();
+
+      if (index >= length) {
+          return {
+              type: Token.EOF,
+              lineNumber: lineNumber,
+              lineStart: lineStart,
+              start: index,
+              end: index
+          };
+      }
+
+      ch = source.charCodeAt(index);
+
+      if (isIdentifierStart(ch)) {
+          return scanIdentifier();
+      }
+
+      // Very common: ( and ) and ;
+      if (ch === 0x28 || ch === 0x29 || ch === 0x3B) {
+          return scanPunctuator();
+      }
+
+      // String literal starts with single quote (U+0027) or double quote (U+0022).
+      if (ch === 0x27 || ch === 0x22) {
+          return scanStringLiteral();
+      }
+
+
+      // Dot (.) U+002E can also start a floating-point number, hence the need
+      // to check the next character.
+      if (ch === 0x2E) {
+          if (isDecimalDigit(source.charCodeAt(index + 1))) {
+              return scanNumericLiteral();
+          }
+          return scanPunctuator();
+      }
+
+      if (isDecimalDigit(ch)) {
+          return scanNumericLiteral();
+      }
+
+      // Slash (/) U+002F can also start a regex.
+      if (extra.tokenize && ch === 0x2F) {
+          return advanceSlash();
+      }
+
+      return scanPunctuator();
+  }
+
+  function collectToken() {
+      var loc, token, value, entry;
+
+      skipComment();
+      loc = {
+          start: {
+              line: lineNumber,
+              column: index - lineStart
+          }
+      };
+
+      token = advance();
+      loc.end = {
+          line: lineNumber,
+          column: index - lineStart
+      };
+
+      if (token.type !== Token.EOF) {
+          value = source.slice(token.start, token.end);
+          entry = {
+              type: TokenName[token.type],
+              value: value,
+              range: [token.start, token.end],
+              loc: loc
+          };
+          if (token.regex) {
+              entry.regex = {
+                  pattern: token.regex.pattern,
+                  flags: token.regex.flags
+              };
+          }
+          extra.tokens.push(entry);
+      }
+
+      return token;
+  }
+
+  function lex() {
+      var token;
+
+      token = lookahead;
+      index = token.end;
+      lineNumber = token.lineNumber;
+      lineStart = token.lineStart;
+
+      lookahead = (typeof extra.tokens !== 'undefined') ? collectToken() : advance();
+
+      index = token.end;
+      lineNumber = token.lineNumber;
+      lineStart = token.lineStart;
+
+      return token;
+  }
+
+  function peek() {
+      var pos, line, start;
+
+      pos = index;
+      line = lineNumber;
+      start = lineStart;
+      lookahead = (typeof extra.tokens !== 'undefined') ? collectToken() : advance();
+      index = pos;
+      lineNumber = line;
+      lineStart = start;
+  }
+
+  function Position() {
+      this.line = lineNumber;
+      this.column = index - lineStart;
+  }
+
+  function SourceLocation() {
+      this.start = new Position();
+      this.end = null;
+  }
+
+  function WrappingSourceLocation(startToken) {
+      if (startToken.type === Token.StringLiteral) {
+          this.start = {
+              line: startToken.startLineNumber,
+              column: startToken.start - startToken.startLineStart
+          };
+      } else {
+          this.start = {
+              line: startToken.lineNumber,
+              column: startToken.start - startToken.lineStart
+          };
+      }
+      this.end = null;
+  }
+
+  function Node() {
+      // Skip comment.
+      index = lookahead.start;
+      if (lookahead.type === Token.StringLiteral) {
+          lineNumber = lookahead.startLineNumber;
+          lineStart = lookahead.startLineStart;
+      } else {
+          lineNumber = lookahead.lineNumber;
+          lineStart = lookahead.lineStart;
+      }
+      if (extra.range) {
+          this.range = [index, 0];
+      }
+      if (extra.loc) {
+          this.loc = new SourceLocation();
+      }
+  }
+
+  function WrappingNode(startToken) {
+      if (extra.range) {
+          this.range = [startToken.start, 0];
+      }
+      if (extra.loc) {
+          this.loc = new WrappingSourceLocation(startToken);
+      }
+  }
+
+  WrappingNode.prototype = Node.prototype = {
+
+      finish: function () {
+          if (extra.range) {
+              this.range[1] = index;
+          }
+          if (extra.loc) {
+              this.loc.end = new Position();
+              if (extra.source) {
+                  this.loc.source = extra.source;
+              }
+          }
+      },
+
+      finishArrayExpression: function (elements) {
+          this.type = Syntax.ArrayExpression;
+          this.elements = elements;
+          this.finish();
+          return this;
+      },
+
+      finishAssignmentExpression: function (operator, left, right) {
+          this.type = Syntax.AssignmentExpression;
+          this.operator = operator;
+          this.left = left;
+          this.right = right;
+          this.finish();
+          return this;
+      },
+
+      finishBinaryExpression: function (operator, left, right) {
+          this.type = (operator === '||' || operator === '&&') ? Syntax.LogicalExpression : Syntax.BinaryExpression;
+          this.operator = operator;
+          this.left = left;
+          this.right = right;
+          this.finish();
+          return this;
+      },
+
+      finishCallExpression: function (callee, args) {
+          this.type = Syntax.CallExpression;
+          this.callee = callee;
+          this.arguments = args;
+          this.finish();
+          return this;
+      },
+
+      finishConditionalExpression: function (test, consequent, alternate) {
+          this.type = Syntax.ConditionalExpression;
+          this.test = test;
+          this.consequent = consequent;
+          this.alternate = alternate;
+          this.finish();
+          return this;
+      },
+
+      finishExpressionStatement: function (expression) {
+          this.type = Syntax.ExpressionStatement;
+          this.expression = expression;
+          this.finish();
+          return this;
+      },
+
+      finishIdentifier: function (name) {
+          this.type = Syntax.Identifier;
+          this.name = name;
+          this.finish();
+          return this;
+      },
+
+      finishLiteral: function (token) {
+          this.type = Syntax.Literal;
+          this.value = token.value;
+          this.raw = source.slice(token.start, token.end);
+          if (token.regex) {
+              if (this.raw == '//') {
+                this.raw = '/(?:)/';
+              }
+              this.regex = token.regex;
+          }
+          this.finish();
+          return this;
+      },
+
+      finishMemberExpression: function (accessor, object, property) {
+          this.type = Syntax.MemberExpression;
+          this.computed = accessor === '[';
+          this.object = object;
+          this.property = property;
+          this.finish();
+          return this;
+      },
+
+      finishObjectExpression: function (properties) {
+          this.type = Syntax.ObjectExpression;
+          this.properties = properties;
+          this.finish();
+          return this;
+      },
+
+      finishProgram: function (body) {
+          this.type = Syntax.Program;
+          this.body = body;
+          this.finish();
+          return this;
+      },
+
+      finishProperty: function (kind, key, value) {
+          this.type = Syntax.Property;
+          this.key = key;
+          this.value = value;
+          this.kind = kind;
+          this.finish();
+          return this;
+      },
+
+      finishUnaryExpression: function (operator, argument) {
+          this.type = Syntax.UnaryExpression;
+          this.operator = operator;
+          this.argument = argument;
+          this.prefix = true;
+          this.finish();
+          return this;
+      }
+  };
+
+  // Return true if there is a line terminator before the next token.
+
+  function peekLineTerminator() {
+      var pos, line, start, found;
+
+      pos = index;
+      line = lineNumber;
+      start = lineStart;
+      skipComment();
+      found = lineNumber !== line;
+      index = pos;
+      lineNumber = line;
+      lineStart = start;
+
+      return found;
+  }
+
+  // Throw an exception
+
+  function throwError(token, messageFormat) {
+      var error,
+          args = Array.prototype.slice.call(arguments, 2),
+          msg = messageFormat.replace(
+              /%(\d)/g,
+              function (whole, index) {
+                  assert(index < args.length, 'Message reference must be in range');
+                  return args[index];
+              }
+          );
+
+      if (typeof token.lineNumber === 'number') {
+          error = new Error('Line ' + token.lineNumber + ': ' + msg);
+          error.index = token.start;
+          error.lineNumber = token.lineNumber;
+          error.column = token.start - lineStart + 1;
+      } else {
+          error = new Error('Line ' + lineNumber + ': ' + msg);
+          error.index = index;
+          error.lineNumber = lineNumber;
+          error.column = index - lineStart + 1;
+      }
+
+      error.description = msg;
+      throw error;
+  }
+
+  function throwErrorTolerant() {
+      try {
+          throwError.apply(null, arguments);
+      } catch (e) {
+          if (extra.errors) {
+              extra.errors.push(e);
+          } else {
+              throw e;
+          }
+      }
+  }
+
+
+  // Throw an exception because of the token.
+
+  function throwUnexpected(token) {
+      if (token.type === Token.EOF) {
+          throwError(token, Messages.UnexpectedEOS);
+      }
+
+      if (token.type === Token.NumericLiteral) {
+          throwError(token, Messages.UnexpectedNumber);
+      }
+
+      if (token.type === Token.StringLiteral) {
+          throwError(token, Messages.UnexpectedString);
+      }
+
+      if (token.type === Token.Identifier) {
+          throwError(token, Messages.UnexpectedIdentifier);
+      }
+
+      if (token.type === Token.Keyword) {
+          if (isFutureReservedWord(token.value)) {
+              throwError(token, Messages.UnexpectedReserved);
+          } else if (strict && isStrictModeReservedWord(token.value)) {
+              throwErrorTolerant(token, Messages.StrictReservedWord);
+              return;
+          }
+          throwError(token, Messages.UnexpectedToken, token.value);
+      }
+
+      // BooleanLiteral, NullLiteral, or Punctuator.
+      throwError(token, Messages.UnexpectedToken, token.value);
+  }
+
+  // Expect the next token to match the specified punctuator.
+  // If not, an exception will be thrown.
+
+  function expect(value) {
+      var token = lex();
+      if (token.type !== Token.Punctuator || token.value !== value) {
+          throwUnexpected(token);
+      }
+  }
+
+  /**
+   * @name expectTolerant
+   * @description Quietly expect the given token value when in tolerant mode, otherwise delegates
+   * to <code>expect(value)</code>
+   * @param {String} value The value we are expecting the lookahead token to have
+   * @since 2.0
+   */
+  function expectTolerant(value) {
+      if (extra.errors) {
+          var token = lookahead;
+          if (token.type !== Token.Punctuator && token.value !== value) {
+              throwErrorTolerant(token, Messages.UnexpectedToken, token.value);
+          } else {
+              lex();
+          }
+      } else {
+          expect(value);
+      }
+  }
+
+  // Return true if the next token matches the specified punctuator.
+
+  function match(value) {
+      return lookahead.type === Token.Punctuator && lookahead.value === value;
+  }
+
+  // Return true if the next token matches the specified keyword
+
+  function matchKeyword(keyword) {
+      return lookahead.type === Token.Keyword && lookahead.value === keyword;
+  }
+
+  function consumeSemicolon() {
+      var line;
+
+      // Catch the very common case first: immediately a semicolon (U+003B).
+      if (source.charCodeAt(index) === 0x3B || match(';')) {
+          lex();
+          return;
+      }
+
+      line = lineNumber;
+      skipComment();
+      if (lineNumber !== line) {
+          return;
+      }
+
+      if (lookahead.type !== Token.EOF && !match('}')) {
+          throwUnexpected(lookahead);
+      }
+  }
+
+  // 11.1.4 Array Initialiser
+
+  function parseArrayInitialiser() {
+      var elements = [], node = new Node();
+
+      expect('[');
+
+      while (!match(']')) {
+          if (match(',')) {
+              lex();
+              elements.push(null);
+          } else {
+              elements.push(parseAssignmentExpression());
+
+              if (!match(']')) {
+                  expect(',');
+              }
+          }
+      }
+
+      lex();
+
+      return node.finishArrayExpression(elements);
+  }
+
+  // 11.1.5 Object Initialiser
+
+  function parseObjectPropertyKey() {
+      var token, node = new Node();
+
+      token = lex();
+
+      // Note: This function is called only from parseObjectProperty(), where
+      // EOF and Punctuator tokens are already filtered out.
+
+      if (token.type === Token.StringLiteral || token.type === Token.NumericLiteral) {
+          if (strict && token.octal) {
+              throwErrorTolerant(token, Messages.StrictOctalLiteral);
+          }
+          return node.finishLiteral(token);
+      }
+
+      return node.finishIdentifier(token.value);
+  }
+
+  function parseObjectProperty() {
+      var token, key, id, value, node = new Node();
+
+      token = lookahead;
+
+      if (token.type === Token.Identifier) {
+          id = parseObjectPropertyKey();
+          expect(':');
+          value = parseAssignmentExpression();
+          return node.finishProperty('init', id, value);
+      }
+      if (token.type === Token.EOF || token.type === Token.Punctuator) {
+          throwUnexpected(token);
+      } else {
+          key = parseObjectPropertyKey();
+          expect(':');
+          value = parseAssignmentExpression();
+          return node.finishProperty('init', key, value);
+      }
+  }
+
+  function parseObjectInitialiser() {
+      var properties = [], property, name, key, kind, map = {}, toString = String, node = new Node();
+
+      expect('{');
+
+      while (!match('}')) {
+          property = parseObjectProperty();
+
+          if (property.key.type === Syntax.Identifier) {
+              name = property.key.name;
+          } else {
+              name = toString(property.key.value);
+          }
+          kind = (property.kind === 'init') ? PropertyKind.Data : (property.kind === 'get') ? PropertyKind.Get : PropertyKind.Set;
+
+          key = '$' + name;
+          if (Object.prototype.hasOwnProperty.call(map, key)) {
+              if (map[key] === PropertyKind.Data) {
+                  if (strict && kind === PropertyKind.Data) {
+                      throwErrorTolerant({}, Messages.StrictDuplicateProperty);
+                  } else if (kind !== PropertyKind.Data) {
+                      throwErrorTolerant({}, Messages.AccessorDataProperty);
+                  }
+              } else {
+                  if (kind === PropertyKind.Data) {
+                      throwErrorTolerant({}, Messages.AccessorDataProperty);
+                  } else if (map[key] & kind) {
+                      throwErrorTolerant({}, Messages.AccessorGetSet);
+                  }
+              }
+              map[key] |= kind;
+          } else {
+              map[key] = kind;
+          }
+
+          properties.push(property);
+
+          if (!match('}')) {
+              expectTolerant(',');
+          }
+      }
+
+      expect('}');
+
+      return node.finishObjectExpression(properties);
+  }
+
+  // 11.1.6 The Grouping Operator
+
+  function parseGroupExpression() {
+      var expr;
+
+      expect('(');
+
+      ++state.parenthesisCount;
+
+      expr = parseExpression();
+
+      expect(')');
+
+      return expr;
+  }
+
+
+  // 11.1 Primary Expressions
+
+  var legalKeywords = {"if":1, "this":1};
+
+  function parsePrimaryExpression() {
+      var type, token, expr, node;
+
+      if (match('(')) {
+          return parseGroupExpression();
+      }
+
+      if (match('[')) {
+          return parseArrayInitialiser();
+      }
+
+      if (match('{')) {
+          return parseObjectInitialiser();
+      }
+
+      type = lookahead.type;
+      node = new Node();
+
+      if (type === Token.Identifier || legalKeywords[lookahead.value]) {
+          expr = node.finishIdentifier(lex().value);
+      } else if (type === Token.StringLiteral || type === Token.NumericLiteral) {
+          if (strict && lookahead.octal) {
+              throwErrorTolerant(lookahead, Messages.StrictOctalLiteral);
+          }
+          expr = node.finishLiteral(lex());
+      } else if (type === Token.Keyword) {
+          throw new Error("Disabled.");
+      } else if (type === Token.BooleanLiteral) {
+          token = lex();
+          token.value = (token.value === 'true');
+          expr = node.finishLiteral(token);
+      } else if (type === Token.NullLiteral) {
+          token = lex();
+          token.value = null;
+          expr = node.finishLiteral(token);
+      } else if (match('/') || match('/=')) {
+          if (typeof extra.tokens !== 'undefined') {
+              expr = node.finishLiteral(collectRegex());
+          } else {
+              expr = node.finishLiteral(scanRegExp());
+          }
+          peek();
+      } else {
+          throwUnexpected(lex());
+      }
+
+      return expr;
+  }
+
+  // 11.2 Left-Hand-Side Expressions
+
+  function parseArguments() {
+      var args = [];
+
+      expect('(');
+
+      if (!match(')')) {
+          while (index < length) {
+              args.push(parseAssignmentExpression());
+              if (match(')')) {
+                  break;
+              }
+              expectTolerant(',');
+          }
+      }
+
+      expect(')');
+
+      return args;
+  }
+
+  function parseNonComputedProperty() {
+      var token, node = new Node();
+
+      token = lex();
+
+      if (!isIdentifierName(token)) {
+          throwUnexpected(token);
+      }
+
+      return node.finishIdentifier(token.value);
+  }
+
+  function parseNonComputedMember() {
+      expect('.');
+
+      return parseNonComputedProperty();
+  }
+
+  function parseComputedMember() {
+      var expr;
+
+      expect('[');
+
+      expr = parseExpression();
+
+      expect(']');
+
+      return expr;
+  }
+
+  function parseLeftHandSideExpressionAllowCall() {
+      var expr, args, property, startToken, previousAllowIn = state.allowIn;
+
+      startToken = lookahead;
+      state.allowIn = true;
+      expr = parsePrimaryExpression();
+
+      for (;;) {
+          if (match('.')) {
+              property = parseNonComputedMember();
+              expr = new WrappingNode(startToken).finishMemberExpression('.', expr, property);
+          } else if (match('(')) {
+              args = parseArguments();
+              expr = new WrappingNode(startToken).finishCallExpression(expr, args);
+          } else if (match('[')) {
+              property = parseComputedMember();
+              expr = new WrappingNode(startToken).finishMemberExpression('[', expr, property);
+          } else {
+              break;
+          }
+      }
+      state.allowIn = previousAllowIn;
+
+      return expr;
+  }
+
+  // 11.3 Postfix Expressions
+
+  function parsePostfixExpression() {
+      var expr = parseLeftHandSideExpressionAllowCall();
+
+      if (lookahead.type === Token.Punctuator) {
+          if ((match('++') || match('--')) && !peekLineTerminator()) {
+              throw new Error("Disabled.");
+          }
+      }
+
+      return expr;
+  }
+
+  // 11.4 Unary Operators
+
+  function parseUnaryExpression() {
+      var token, expr, startToken;
+
+      if (lookahead.type !== Token.Punctuator && lookahead.type !== Token.Keyword) {
+          expr = parsePostfixExpression();
+      } else if (match('++') || match('--')) {
+          throw new Error("Disabled.");
+      } else if (match('+') || match('-') || match('~') || match('!')) {
+          startToken = lookahead;
+          token = lex();
+          expr = parseUnaryExpression();
+          expr = new WrappingNode(startToken).finishUnaryExpression(token.value, expr);
+      } else if (matchKeyword('delete') || matchKeyword('void') || matchKeyword('typeof')) {
+          throw new Error("Disabled.");
+      } else {
+          expr = parsePostfixExpression();
+      }
+
+      return expr;
+  }
+
+  function binaryPrecedence(token, allowIn) {
+      var prec = 0;
+
+      if (token.type !== Token.Punctuator && token.type !== Token.Keyword) {
+          return 0;
+      }
+
+      switch (token.value) {
+      case '||':
+          prec = 1;
+          break;
+
+      case '&&':
+          prec = 2;
+          break;
+
+      case '|':
+          prec = 3;
+          break;
+
+      case '^':
+          prec = 4;
+          break;
+
+      case '&':
+          prec = 5;
+          break;
+
+      case '==':
+      case '!=':
+      case '===':
+      case '!==':
+          prec = 6;
+          break;
+
+      case '<':
+      case '>':
+      case '<=':
+      case '>=':
+      case 'instanceof':
+          prec = 7;
+          break;
+
+      case 'in':
+          prec = allowIn ? 7 : 0;
+          break;
+
+      case '<<':
+      case '>>':
+      case '>>>':
+          prec = 8;
+          break;
+
+      case '+':
+      case '-':
+          prec = 9;
+          break;
+
+      case '*':
+      case '/':
+      case '%':
+          prec = 11;
+          break;
+
+      default:
+          break;
+      }
+
+      return prec;
+  }
+
+  // 11.5 Multiplicative Operators
+  // 11.6 Additive Operators
+  // 11.7 Bitwise Shift Operators
+  // 11.8 Relational Operators
+  // 11.9 Equality Operators
+  // 11.10 Binary Bitwise Operators
+  // 11.11 Binary Logical Operators
+
+  function parseBinaryExpression() {
+      var marker, markers, expr, token, prec, stack, right, operator, left, i;
+
+      marker = lookahead;
+      left = parseUnaryExpression();
+
+      token = lookahead;
+      prec = binaryPrecedence(token, state.allowIn);
+      if (prec === 0) {
+          return left;
+      }
+      token.prec = prec;
+      lex();
+
+      markers = [marker, lookahead];
+      right = parseUnaryExpression();
+
+      stack = [left, token, right];
+
+      while ((prec = binaryPrecedence(lookahead, state.allowIn)) > 0) {
+
+          // Reduce: make a binary expression from the three topmost entries.
+          while ((stack.length > 2) && (prec <= stack[stack.length - 2].prec)) {
+              right = stack.pop();
+              operator = stack.pop().value;
+              left = stack.pop();
+              markers.pop();
+              expr = new WrappingNode(markers[markers.length - 1]).finishBinaryExpression(operator, left, right);
+              stack.push(expr);
+          }
+
+          // Shift.
+          token = lex();
+          token.prec = prec;
+          stack.push(token);
+          markers.push(lookahead);
+          expr = parseUnaryExpression();
+          stack.push(expr);
+      }
+
+      // Final reduce to clean-up the stack.
+      i = stack.length - 1;
+      expr = stack[i];
+      markers.pop();
+      while (i > 1) {
+          expr = new WrappingNode(markers.pop()).finishBinaryExpression(stack[i - 1].value, stack[i - 2], expr);
+          i -= 2;
+      }
+
+      return expr;
+  }
+
+  // 11.12 Conditional Operator
+
+  function parseConditionalExpression() {
+      var expr, previousAllowIn, consequent, alternate, startToken;
+
+      startToken = lookahead;
+
+      expr = parseBinaryExpression();
+
+      if (match('?')) {
+          lex();
+          previousAllowIn = state.allowIn;
+          state.allowIn = true;
+          consequent = parseAssignmentExpression();
+          state.allowIn = previousAllowIn;
+          expect(':');
+          alternate = parseAssignmentExpression();
+
+          expr = new WrappingNode(startToken).finishConditionalExpression(expr, consequent, alternate);
+      }
+
+      return expr;
+  }
+
+  // 11.13 Assignment Operators
+
+  function parseAssignmentExpression() {
+      var oldParenthesisCount, token, expr, startToken;
+
+      oldParenthesisCount = state.parenthesisCount;
+
+      startToken = lookahead;
+      token = lookahead;
+
+      expr = parseConditionalExpression();
+
+      return expr;
+  }
+
+  // 11.14 Comma Operator
+
+  function parseExpression() {
+      var expr = parseAssignmentExpression();
+
+      if (match(',')) {
+          throw new Error("Disabled."); // no sequence expressions
+      }
+
+      return expr;
+  }
+
+  // 12.4 Expression Statement
+
+  function parseExpressionStatement(node) {
+      var expr = parseExpression();
+      consumeSemicolon();
+      return node.finishExpressionStatement(expr);
+  }
+
+  // 12 Statements
+
+  function parseStatement() {
+      var type = lookahead.type,
+          expr,
+          node;
+
+      if (type === Token.EOF) {
+          throwUnexpected(lookahead);
+      }
+
+      if (type === Token.Punctuator && lookahead.value === '{') {
+          throw new Error("Disabled."); // block statement
+      }
+
+      node = new Node();
+
+      if (type === Token.Punctuator) {
+          switch (lookahead.value) {
+          case ';':
+              throw new Error("Disabled."); // empty statement
+          case '(':
+              return parseExpressionStatement(node);
+          default:
+              break;
+          }
+      } else if (type === Token.Keyword) {
+          throw new Error("Disabled."); // keyword
+      }
+
+      expr = parseExpression();
+      consumeSemicolon();
+      return node.finishExpressionStatement(expr);
+  }
+
+  // 14 Program
+
+  function parseSourceElement() {
+      if (lookahead.type === Token.Keyword) {
+          switch (lookahead.value) {
+          case 'const':
+          case 'let':
+              throw new Error("Disabled.");
+          case 'function':
+              throw new Error("Disabled.");
+          default:
+              return parseStatement();
+          }
+      }
+
+      if (lookahead.type !== Token.EOF) {
+          return parseStatement();
+      }
+  }
+
+  function parseSourceElements() {
+      var sourceElement, sourceElements = [], token, directive, firstRestricted;
+
+      while (index < length) {
+          token = lookahead;
+          if (token.type !== Token.StringLiteral) {
+              break;
+          }
+
+          sourceElement = parseSourceElement();
+          sourceElements.push(sourceElement);
+          if (sourceElement.expression.type !== Syntax.Literal) {
+              // this is not directive
+              break;
+          }
+          directive = source.slice(token.start + 1, token.end - 1);
+          if (directive === 'use strict') {
+              strict = true;
+              if (firstRestricted) {
+                  throwErrorTolerant(firstRestricted, Messages.StrictOctalLiteral);
+              }
+          } else {
+              if (!firstRestricted && token.octal) {
+                  firstRestricted = token;
+              }
+          }
+      }
+
+      while (index < length) {
+          sourceElement = parseSourceElement();
+          if (typeof sourceElement === 'undefined') {
+              break;
+          }
+          sourceElements.push(sourceElement);
+      }
+      return sourceElements;
+  }
+
+  function parseProgram() {
+      var body, node;
+
+      skipComment();
+      peek();
+      node = new Node();
+      strict = true; // assume strict
+
+      body = parseSourceElements();
+      return node.finishProgram(body);
+  }
+
+  function filterTokenLocation() {
+      var i, entry, token, tokens = [];
+
+      for (i = 0; i < extra.tokens.length; ++i) {
+          entry = extra.tokens[i];
+          token = {
+              type: entry.type,
+              value: entry.value
+          };
+          if (entry.regex) {
+              token.regex = {
+                  pattern: entry.regex.pattern,
+                  flags: entry.regex.flags
+              };
+          }
+          if (extra.range) {
+              token.range = entry.range;
+          }
+          if (extra.loc) {
+              token.loc = entry.loc;
+          }
+          tokens.push(token);
+      }
+
+      extra.tokens = tokens;
+  }
+
+  function tokenize(code, options) {
+      var toString,
+          tokens;
+
+      toString = String;
+      if (typeof code !== 'string' && !(code instanceof String)) {
+          code = toString(code);
+      }
+
+      source = code;
+      index = 0;
+      lineNumber = (source.length > 0) ? 1 : 0;
+      lineStart = 0;
+      length = source.length;
+      lookahead = null;
+      state = {
+          allowIn: true,
+          labelSet: {},
+          inFunctionBody: false,
+          inIteration: false,
+          inSwitch: false,
+          lastCommentStart: -1
+      };
+
+      extra = {};
+
+      // Options matching.
+      options = options || {};
+
+      // Of course we collect tokens here.
+      options.tokens = true;
+      extra.tokens = [];
+      extra.tokenize = true;
+      // The following two fields are necessary to compute the Regex tokens.
+      extra.openParenToken = -1;
+      extra.openCurlyToken = -1;
+
+      extra.range = (typeof options.range === 'boolean') && options.range;
+      extra.loc = (typeof options.loc === 'boolean') && options.loc;
+
+      if (typeof options.tolerant === 'boolean' && options.tolerant) {
+          extra.errors = [];
+      }
+
+      try {
+          peek();
+          if (lookahead.type === Token.EOF) {
+              return extra.tokens;
+          }
+
+          lex();
+          while (lookahead.type !== Token.EOF) {
+              try {
+                  lex();
+              } catch (lexError) {
+                  if (extra.errors) {
+                      extra.errors.push(lexError);
+                      // We have to break on the first error
+                      // to avoid infinite loops.
+                      break;
+                  } else {
+                      throw lexError;
+                  }
+              }
+          }
+
+          filterTokenLocation();
+          tokens = extra.tokens;
+          if (typeof extra.errors !== 'undefined') {
+              tokens.errors = extra.errors;
+          }
+      } catch (e) {
+          throw e;
+      } finally {
+          extra = {};
+      }
+      return tokens;
+  }
+
+  function parse(code, options) {
+      var program, toString;
+
+      toString = String;
+      if (typeof code !== 'string' && !(code instanceof String)) {
+          code = toString(code);
+      }
+
+      source = code;
+      index = 0;
+      lineNumber = (source.length > 0) ? 1 : 0;
+      lineStart = 0;
+      length = source.length;
+      lookahead = null;
+      state = {
+          allowIn: true,
+          labelSet: {},
+          parenthesisCount: 0,
+          inFunctionBody: false,
+          inIteration: false,
+          inSwitch: false,
+          lastCommentStart: -1
+      };
+
+      extra = {};
+      if (typeof options !== 'undefined') {
+          extra.range = (typeof options.range === 'boolean') && options.range;
+          extra.loc = (typeof options.loc === 'boolean') && options.loc;
+
+          if (extra.loc && options.source !== null && options.source !== undefined) {
+              extra.source = toString(options.source);
+          }
+
+          if (typeof options.tokens === 'boolean' && options.tokens) {
+              extra.tokens = [];
+          }
+          if (typeof options.tolerant === 'boolean' && options.tolerant) {
+              extra.errors = [];
+          }
+      }
+
+      try {
+          program = parseProgram();
+          if (typeof extra.tokens !== 'undefined') {
+              filterTokenLocation();
+              program.tokens = extra.tokens;
+          }
+          if (typeof extra.errors !== 'undefined') {
+              program.errors = extra.errors;
+          }
+      } catch (e) {
+          throw e;
+      } finally {
+          extra = {};
+      }
+
+      return program;
+  }
+
+  return {
+    tokenize: tokenize,
+    parse: parse
+  };
+
+})();
+},{}],45:[function(require,module,exports){
+var ts = Date.now();
+
+function write(msg) {
+  msg = '[Vega Log] ' + msg;
+  console.log(msg);
+}
+
+function error(msg) {
+  msg = '[Vega Err] ' + msg;
+  console.error(msg);
+}
+
+function debug(input, args) {
+  if (!debug.enable) return;
+  var log = Function.prototype.bind.call(console.log, console);
+  var state = {
+    prevTime:  Date.now() - ts,
+    stamp: input.stamp
+  };
+
+  if (input.add) {
+    state.add = input.add.length;
+    state.mod = input.mod.length;
+    state.rem = input.rem.length;
+    state.reflow = !!input.reflow;
+  }
+
+  log.apply(console, (args.push(JSON.stringify(state)), args));
+  ts = Date.now();
+}
+
+module.exports = {
+  log:   write,
+  error: error,
+  debug: (debug.enable = false, debug)
+};
+
+},{}],46:[function(require,module,exports){
+module.exports = {
+  path:       require('./path'),
+  render:     require('./render'),
+  Item:       require('./util/Item'),
+  bound:      require('./util/bound'),
+  Bounds:     require('./util/Bounds'),
+  Gradient:   require('./util/Gradient'),
+  toJSON:     require('./util/scene').toJSON,
+  fromJSON:   require('./util/scene').fromJSON
+};
+},{"./path":48,"./render":68,"./util/Bounds":74,"./util/Gradient":76,"./util/Item":78,"./util/bound":79,"./util/scene":82}],47:[function(require,module,exports){
+var segmentCache = {},
+    bezierCache = {},
+    join = [].join;
+
+// Copied from Inkscape svgtopdf, thanks!
+function segments(x, y, rx, ry, large, sweep, rotateX, ox, oy) {
+  var key = join.call(arguments);
+  if (segmentCache[key]) {
+    return segmentCache[key];
+  }
+
+  var th = rotateX * (Math.PI/180);
+  var sin_th = Math.sin(th);
+  var cos_th = Math.cos(th);
+  rx = Math.abs(rx);
+  ry = Math.abs(ry);
+  var px = cos_th * (ox - x) * 0.5 + sin_th * (oy - y) * 0.5;
+  var py = cos_th * (oy - y) * 0.5 - sin_th * (ox - x) * 0.5;
+  var pl = (px*px) / (rx*rx) + (py*py) / (ry*ry);
+  if (pl > 1) {
+    pl = Math.sqrt(pl);
+    rx *= pl;
+    ry *= pl;
+  }
+
+  var a00 = cos_th / rx;
+  var a01 = sin_th / rx;
+  var a10 = (-sin_th) / ry;
+  var a11 = (cos_th) / ry;
+  var x0 = a00 * ox + a01 * oy;
+  var y0 = a10 * ox + a11 * oy;
+  var x1 = a00 * x + a01 * y;
+  var y1 = a10 * x + a11 * y;
+
+  var d = (x1-x0) * (x1-x0) + (y1-y0) * (y1-y0);
+  var sfactor_sq = 1 / d - 0.25;
+  if (sfactor_sq < 0) sfactor_sq = 0;
+  var sfactor = Math.sqrt(sfactor_sq);
+  if (sweep == large) sfactor = -sfactor;
+  var xc = 0.5 * (x0 + x1) - sfactor * (y1-y0);
+  var yc = 0.5 * (y0 + y1) + sfactor * (x1-x0);
+
+  var th0 = Math.atan2(y0-yc, x0-xc);
+  var th1 = Math.atan2(y1-yc, x1-xc);
+
+  var th_arc = th1-th0;
+  if (th_arc < 0 && sweep === 1){
+    th_arc += 2 * Math.PI;
+  } else if (th_arc > 0 && sweep === 0) {
+    th_arc -= 2 * Math.PI;
+  }
+
+  var segs = Math.ceil(Math.abs(th_arc / (Math.PI * 0.5 + 0.001)));
+  var result = [];
+  for (var i=0; i<segs; ++i) {
+    var th2 = th0 + i * th_arc / segs;
+    var th3 = th0 + (i+1) * th_arc / segs;
+    result[i] = [xc, yc, th2, th3, rx, ry, sin_th, cos_th];
+  }
+
+  return (segmentCache[key] = result);
+}
+
+function bezier(params) {
+  var key = join.call(params);
+  if (bezierCache[key]) {
+    return bezierCache[key];
+  }
+  
+  var cx = params[0],
+      cy = params[1],
+      th0 = params[2],
+      th1 = params[3],
+      rx = params[4],
+      ry = params[5],
+      sin_th = params[6],
+      cos_th = params[7];
+
+  var a00 = cos_th * rx;
+  var a01 = -sin_th * ry;
+  var a10 = sin_th * rx;
+  var a11 = cos_th * ry;
+
+  var cos_th0 = Math.cos(th0);
+  var sin_th0 = Math.sin(th0);
+  var cos_th1 = Math.cos(th1);
+  var sin_th1 = Math.sin(th1);
+
+  var th_half = 0.5 * (th1 - th0);
+  var sin_th_h2 = Math.sin(th_half * 0.5);
+  var t = (8/3) * sin_th_h2 * sin_th_h2 / Math.sin(th_half);
+  var x1 = cx + cos_th0 - t * sin_th0;
+  var y1 = cy + sin_th0 + t * cos_th0;
+  var x3 = cx + cos_th1;
+  var y3 = cy + sin_th1;
+  var x2 = x3 + t * sin_th1;
+  var y2 = y3 - t * cos_th1;
+
+  return (bezierCache[key] = [
+    a00 * x1 + a01 * y1,  a10 * x1 + a11 * y1,
+    a00 * x2 + a01 * y2,  a10 * x2 + a11 * y2,
+    a00 * x3 + a01 * y3,  a10 * x3 + a11 * y3
+  ]);
+}
+
+module.exports = {
+  segments: segments,
+  bezier: bezier,
+  cache: {
+    segments: segmentCache,
+    bezier: bezierCache
+  }
+};
+
+},{}],48:[function(require,module,exports){
+module.exports = {
+  parse:  require('./parse'),
+  render: require('./render')
+};
+
+},{"./parse":49,"./render":50}],49:[function(require,module,exports){
+// Path parsing and rendering code adapted from fabric.js -- Thanks!
+var cmdlen = { m:2, l:2, h:1, v:1, c:6, s:4, q:4, t:2, a:7 },
+    regexp = [/([MLHVCSQTAZmlhvcsqtaz])/g, /###/, /(\d)([-+])/g, /\s|,|###/];
+
+module.exports = function(pathstr) {
+  var result = [],
+      path,
+      curr,
+      chunks,
+      parsed, param,
+      cmd, len, i, j, n, m;
+
+  // First, break path into command sequence
+  path = pathstr
+    .slice()
+    .replace(regexp[0], '###$1')
+    .split(regexp[1])
+    .slice(1);
+
+  // Next, parse each command in turn
+  for (i=0, n=path.length; i<n; ++i) {
+    curr = path[i];
+    chunks = curr
+      .slice(1)
+      .trim()
+      .replace(regexp[2],'$1###$2')
+      .split(regexp[3]);
+    cmd = curr.charAt(0);
+
+    parsed = [cmd];
+    for (j=0, m=chunks.length; j<m; ++j) {
+      if ((param = +chunks[j]) === param) { // not NaN
+        parsed.push(param);
+      }
+    }
+
+    len = cmdlen[cmd.toLowerCase()];
+    if (parsed.length-1 > len) {
+      for (j=1, m=parsed.length; j<m; j+=len) {
+        result.push([cmd].concat(parsed.slice(j, j+len)));
+      }
+    }
+    else {
+      result.push(parsed);
+    }
+  }
+
+  return result;
+};
+
+},{}],50:[function(require,module,exports){
+var arc = require('./arc');
+
+module.exports = function(g, path, l, t) {
+  var current, // current instruction
+      previous = null,
+      x = 0, // current x
+      y = 0, // current y
+      controlX = 0, // current control point x
+      controlY = 0, // current control point y
+      tempX,
+      tempY,
+      tempControlX,
+      tempControlY;
+
+  if (l == null) l = 0;
+  if (t == null) t = 0;
+
+  g.beginPath();
+
+  for (var i=0, len=path.length; i<len; ++i) {
+    current = path[i];
+
+    switch (current[0]) { // first letter
+
+      case 'l': // lineto, relative
+        x += current[1];
+        y += current[2];
+        g.lineTo(x + l, y + t);
+        break;
+
+      case 'L': // lineto, absolute
+        x = current[1];
+        y = current[2];
+        g.lineTo(x + l, y + t);
+        break;
+
+      case 'h': // horizontal lineto, relative
+        x += current[1];
+        g.lineTo(x + l, y + t);
+        break;
+
+      case 'H': // horizontal lineto, absolute
+        x = current[1];
+        g.lineTo(x + l, y + t);
+        break;
+
+      case 'v': // vertical lineto, relative
+        y += current[1];
+        g.lineTo(x + l, y + t);
+        break;
+
+      case 'V': // verical lineto, absolute
+        y = current[1];
+        g.lineTo(x + l, y + t);
+        break;
+
+      case 'm': // moveTo, relative
+        x += current[1];
+        y += current[2];
+        g.moveTo(x + l, y + t);
+        break;
+
+      case 'M': // moveTo, absolute
+        x = current[1];
+        y = current[2];
+        g.moveTo(x + l, y + t);
+        break;
+
+      case 'c': // bezierCurveTo, relative
+        tempX = x + current[5];
+        tempY = y + current[6];
+        controlX = x + current[3];
+        controlY = y + current[4];
+        g.bezierCurveTo(
+          x + current[1] + l, // x1
+          y + current[2] + t, // y1
+          controlX + l, // x2
+          controlY + t, // y2
+          tempX + l,
+          tempY + t
+        );
+        x = tempX;
+        y = tempY;
+        break;
+
+      case 'C': // bezierCurveTo, absolute
+        x = current[5];
+        y = current[6];
+        controlX = current[3];
+        controlY = current[4];
+        g.bezierCurveTo(
+          current[1] + l,
+          current[2] + t,
+          controlX + l,
+          controlY + t,
+          x + l,
+          y + t
+        );
+        break;
+
+      case 's': // shorthand cubic bezierCurveTo, relative
+        // transform to absolute x,y
+        tempX = x + current[3];
+        tempY = y + current[4];
+        // calculate reflection of previous control points
+        controlX = 2 * x - controlX;
+        controlY = 2 * y - controlY;
+        g.bezierCurveTo(
+          controlX + l,
+          controlY + t,
+          x + current[1] + l,
+          y + current[2] + t,
+          tempX + l,
+          tempY + t
+        );
+
+        // set control point to 2nd one of this command
+        // the first control point is assumed to be the reflection of
+        // the second control point on the previous command relative
+        // to the current point.
+        controlX = x + current[1];
+        controlY = y + current[2];
+
+        x = tempX;
+        y = tempY;
+        break;
+
+      case 'S': // shorthand cubic bezierCurveTo, absolute
+        tempX = current[3];
+        tempY = current[4];
+        // calculate reflection of previous control points
+        controlX = 2*x - controlX;
+        controlY = 2*y - controlY;
+        g.bezierCurveTo(
+          controlX + l,
+          controlY + t,
+          current[1] + l,
+          current[2] + t,
+          tempX + l,
+          tempY + t
+        );
+        x = tempX;
+        y = tempY;
+        // set control point to 2nd one of this command
+        // the first control point is assumed to be the reflection of
+        // the second control point on the previous command relative
+        // to the current point.
+        controlX = current[1];
+        controlY = current[2];
+
+        break;
+
+      case 'q': // quadraticCurveTo, relative
+        // transform to absolute x,y
+        tempX = x + current[3];
+        tempY = y + current[4];
+
+        controlX = x + current[1];
+        controlY = y + current[2];
+
+        g.quadraticCurveTo(
+          controlX + l,
+          controlY + t,
+          tempX + l,
+          tempY + t
+        );
+        x = tempX;
+        y = tempY;
+        break;
+
+      case 'Q': // quadraticCurveTo, absolute
+        tempX = current[3];
+        tempY = current[4];
+
+        g.quadraticCurveTo(
+          current[1] + l,
+          current[2] + t,
+          tempX + l,
+          tempY + t
+        );
+        x = tempX;
+        y = tempY;
+        controlX = current[1];
+        controlY = current[2];
+        break;
+
+      case 't': // shorthand quadraticCurveTo, relative
+
+        // transform to absolute x,y
+        tempX = x + current[1];
+        tempY = y + current[2];
+
+        if (previous[0].match(/[QqTt]/) === null) {
+          // If there is no previous command or if the previous command was not a Q, q, T or t,
+          // assume the control point is coincident with the current point
+          controlX = x;
+          controlY = y;
+        }
+        else if (previous[0] === 't') {
+          // calculate reflection of previous control points for t
+          controlX = 2 * x - tempControlX;
+          controlY = 2 * y - tempControlY;
+        }
+        else if (previous[0] === 'q') {
+          // calculate reflection of previous control points for q
+          controlX = 2 * x - controlX;
+          controlY = 2 * y - controlY;
+        }
+
+        tempControlX = controlX;
+        tempControlY = controlY;
+
+        g.quadraticCurveTo(
+          controlX + l,
+          controlY + t,
+          tempX + l,
+          tempY + t
+        );
+        x = tempX;
+        y = tempY;
+        controlX = x + current[1];
+        controlY = y + current[2];
+        break;
+
+      case 'T':
+        tempX = current[1];
+        tempY = current[2];
+
+        // calculate reflection of previous control points
+        controlX = 2 * x - controlX;
+        controlY = 2 * y - controlY;
+        g.quadraticCurveTo(
+          controlX + l,
+          controlY + t,
+          tempX + l,
+          tempY + t
+        );
+        x = tempX;
+        y = tempY;
+        break;
+
+      case 'a':
+        drawArc(g, x + l, y + t, [
+          current[1],
+          current[2],
+          current[3],
+          current[4],
+          current[5],
+          current[6] + x + l,
+          current[7] + y + t
+        ]);
+        x += current[6];
+        y += current[7];
+        break;
+
+      case 'A':
+        drawArc(g, x + l, y + t, [
+          current[1],
+          current[2],
+          current[3],
+          current[4],
+          current[5],
+          current[6] + l,
+          current[7] + t
+        ]);
+        x = current[6];
+        y = current[7];
+        break;
+
+      case 'z':
+      case 'Z':
+        g.closePath();
+        break;
+    }
+    previous = current;
+  }
+};
+
+function drawArc(g, x, y, coords) {
+  var seg = arc.segments(
+    coords[5], // end x
+    coords[6], // end y
+    coords[0], // radius x
+    coords[1], // radius y
+    coords[3], // large flag
+    coords[4], // sweep flag
+    coords[2], // rotation
+    x, y
+  );
+  for (var i=0; i<seg.length; ++i) {
+    var bez = arc.bezier(seg[i]);
+    g.bezierCurveTo.apply(g, bez);
+  }
+}
+
+},{"./arc":47}],51:[function(require,module,exports){
+function Handler() {
+  this._active = null;
+  this._handlers = {};
+}
+
+var prototype = Handler.prototype;
+
+prototype.initialize = function(el, pad, obj) {
+  this._el = el;
+  this._obj = obj || null;
+  return this.padding(pad);
+};
+
+prototype.element = function() {
+  return this._el;
+};
+
+prototype.padding = function(pad) {
+  this._padding = pad || {top:0, left:0, bottom:0, right:0};
+  return this;
+};
+
+prototype.scene = function(scene) {
+  if (!arguments.length) return this._scene;
+  this._scene = scene;
+  return this;
+};
+
+// add an event handler
+// subclasses should override
+prototype.on = function(/*type, handler*/) {};
+
+// remove an event handler
+// subclasses should override
+prototype.off = function(/*type, handler*/) {};
+
+// return an array with all registered event handlers
+prototype.handlers = function() {
+  var h = this._handlers, a = [], k;
+  for (k in h) { a.push.apply(a, h[k]); }
+  return a;
+};
+
+prototype.eventName = function(name) {
+  var i = name.indexOf('.');
+  return i < 0 ? name : name.slice(0,i);
+};
+
+module.exports = Handler;
+},{}],52:[function(require,module,exports){
+function Renderer() {
+  this._el = null;
+  this._bgcolor = null;
+}
+
+var prototype = Renderer.prototype;
+
+prototype.initialize = function(el, width, height, padding) {
+  this._el = el;
+  return this.resize(width, height, padding);
+};
+
+// Returns the parent container element for a visualization
+prototype.element = function() {
+  return this._el;
+};
+
+// Returns the scene element (e.g., canvas or SVG) of the visualization
+// Subclasses must override if the first child is not the scene element
+prototype.scene = function() {
+  return this._el && this._el.firstChild;
+};
+
+prototype.background = function(bgcolor) {
+  if (arguments.length === 0) return this._bgcolor;
+  this._bgcolor = bgcolor;
+  return this;
+};
+
+prototype.resize = function(width, height, padding) {
+  this._width = width;
+  this._height = height;
+  this._padding = padding || {top:0, left:0, bottom:0, right:0};
+  return this;
+};
+
+prototype.render = function(/*scene, items*/) {
+  return this;
+};
+
+module.exports = Renderer;
+},{}],53:[function(require,module,exports){
+var DOM = require('../../util/dom'),
+    Handler = require('../Handler'),
+    marks = require('./marks');
+
+function CanvasHandler() {
+  Handler.call(this);
+  this._down = null;
+  this._touch = null;
+  this._first = true;
+}
+
+var base = Handler.prototype;
+var prototype = (CanvasHandler.prototype = Object.create(base));
+prototype.constructor = CanvasHandler;
+
+prototype.initialize = function(el, pad, obj) {
+  // add event listeners
+  var canvas = this._canvas = DOM.find(el, 'canvas'),
+      that = this;
+  this.events.forEach(function(type) {
+    canvas.addEventListener(type, function(evt) {
+      if (prototype[type]) {
+        prototype[type].call(that, evt);
+      } else {
+        that.fire(type, evt);
+      }
+    });
+  });
+
+  return base.initialize.call(this, el, pad, obj);
+};
+
+prototype.canvas = function() {
+  return this._canvas;
+};
+
+// retrieve the current canvas context
+prototype.context = function() {
+  return this._canvas.getContext('2d');
+};
+
+// supported events
+prototype.events = [
+  'keydown',
+  'keypress',
+  'keyup',
+  'mousedown',
+  'mouseup',
+  'mousemove',
+  'mouseout',
+  'mouseover',
+  'click',
+  'dblclick',
+  'wheel',
+  'mousewheel',
+  'touchstart',
+  'touchmove',
+  'touchend'
+];
+
+// to keep firefox happy
+prototype.DOMMouseScroll = function(evt) {
+  this.fire('mousewheel', evt);
+};
+
+prototype.mousemove = function(evt) {
+  var a = this._active,
+      p = this.pickEvent(evt);
+
+  if (p === a) {
+    // active item and picked item are the same
+    this.fire('mousemove', evt); // fire move
+  } else {
+    // active item and picked item are different
+    this.fire('mouseout', evt);  // fire out for prior active item
+    this._active = p;            // set new active item
+    this.fire('mouseover', evt); // fire over for new active item
+    this.fire('mousemove', evt); // fire move for new active item
+  }
+};
+
+prototype.mouseout = function(evt) {
+  this.fire('mouseout', evt);
+  this._active = null;
+};
+
+prototype.mousedown = function(evt) {
+  this._down = this._active;
+  this.fire('mousedown', evt);
+};
+
+prototype.click = function(evt) {
+  if (this._down === this._active) {
+    this.fire('click', evt);
+    this._down = null;
+  }
+};
+
+prototype.touchstart = function(evt) {
+  this._touch = this.pickEvent(evt.changedTouches[0]);
+
+  if (this._first) {
+    this._active = this._touch;
+    this._first = false;
+  }
+
+  this.fire('touchstart', evt, true);
+};
+
+prototype.touchmove = function(evt) {
+  this.fire('touchmove', evt, true);
+};
+
+prototype.touchend = function(evt) {
+  this.fire('touchend', evt, true);
+  this._touch = null;
+};
+
+// fire an event
+prototype.fire = function(type, evt, touch) {
+  var a = touch ? this._touch : this._active,
+      h = this._handlers[type], i, len;
+  if (h) {
+    evt.vegaType = type;
+    for (i=0, len=h.length; i<len; ++i) {
+      h[i].handler.call(this._obj, evt, a);
+    }
+  }
+};
+
+// add an event handler
+prototype.on = function(type, handler) {
+  var name = this.eventName(type),
+      h = this._handlers;
+  (h[name] || (h[name] = [])).push({
+    type: type,
+    handler: handler
+  });
+  return this;
+};
+
+// remove an event handler
+prototype.off = function(type, handler) {
+  var name = this.eventName(type),
+      h = this._handlers[name], i;
+  if (!h) return;
+  for (i=h.length; --i>=0;) {
+    if (h[i].type !== type) continue;
+    if (!handler || h[i].handler === handler) h.splice(i, 1);
+  }
+  return this;
+};
+
+prototype.pickEvent = function(evt) {
+  var rect = this._canvas.getBoundingClientRect(),
+      pad = this._padding, x, y;
+  return this.pick(this._scene,
+    x = (evt.clientX - rect.left),
+    y = (evt.clientY - rect.top),
+    x - pad.left, y - pad.top);
+};
+
+// find the scenegraph item at the current mouse position
+// x, y -- the absolute x, y mouse coordinates on the canvas element
+// gx, gy -- the relative coordinates within the current group
+prototype.pick = function(scene, x, y, gx, gy) {
+  var g = this.context(),
+      mark = marks[scene.marktype];
+  return mark.pick.call(this, g, scene, x, y, gx, gy);
+};
+
+module.exports = CanvasHandler;
+
+},{"../../util/dom":81,"../Handler":51,"./marks":60}],54:[function(require,module,exports){
+var DOM = require('../../util/dom'),
+    Bounds = require('../../util/Bounds'),
+    ImageLoader = require('../../util/ImageLoader'),
+    Canvas = require('../../util/canvas'),
+    Renderer = require('../Renderer'),
+    marks = require('./marks');
+
+function CanvasRenderer(loadConfig) {
+  Renderer.call(this);
+  this._loader = new ImageLoader(loadConfig);
+}
+
+CanvasRenderer.RETINA = true;
+
+var base = Renderer.prototype;
+var prototype = (CanvasRenderer.prototype = Object.create(base));
+prototype.constructor = CanvasRenderer;
+
+prototype.initialize = function(el, width, height, padding) {
+  this._canvas = Canvas.instance(width, height);
+  if (el) {
+    DOM.clear(el, 0).appendChild(this._canvas);
+    this._canvas.setAttribute('class', 'marks');
+  }
+  return base.initialize.call(this, el, width, height, padding);
+};
+
+prototype.resize = function(width, height, padding) {
+  base.resize.call(this, width, height, padding);
+  Canvas.resize(this._canvas, this._width, this._height,
+    this._padding, CanvasRenderer.RETINA);
+  return this;
+};
+
+prototype.canvas = function() {
+  return this._canvas;
+};
+
+prototype.context = function() {
+  return this._canvas ? this._canvas.getContext('2d') : null;
+};
+
+prototype.pendingImages = function() {
+  return this._loader.pending();
+};
+
+function clipToBounds(g, items) {
+  if (!items) return null;
+
+  var b = new Bounds(), i, n, item, mark, group;
+  for (i=0, n=items.length; i<n; ++i) {
+    item = items[i];
+    mark = item.mark;
+    group = mark.group;
+    item = marks[mark.marktype].nested ? mark : item;
+    b.union(translate(item.bounds, group));
+    if (item['bounds:prev']) {
+      b.union(translate(item['bounds:prev'], group));
+    }
+  }
+  b.round();
+
+  g.beginPath();
+  g.rect(b.x1, b.y1, b.width(), b.height());
+  g.clip();
+
+  return b;
+}
+
+function translate(bounds, group) {
+  if (group == null) return bounds;
+  var b = bounds.clone();
+  for (; group != null; group = group.mark.group) {
+    b.translate(group.x || 0, group.y || 0);
+  }
+  return b;
+}
+
+prototype.render = function(scene, items) {
+  var g = this.context(),
+      p = this._padding,
+      w = this._width + p.left + p.right,
+      h = this._height + p.top + p.bottom,
+      b;
+
+  // setup
+  this._scene = scene; // cache scene for async redraw
+  g.save();
+  b = clipToBounds(g, items);
+  this.clear(-p.left, -p.top, w, h);
+
+  // render
+  this.draw(g, scene, b);
+  
+  // takedown
+  g.restore();
+  this._scene = null; // clear scene cache
+
+  return this;
+};
+
+prototype.draw = function(ctx, scene, bounds) {
+  var mark = marks[scene.marktype];
+  mark.draw.call(this, ctx, scene, bounds);
+};
+
+prototype.clear = function(x, y, w, h) {
+  var g = this.context();
+  g.clearRect(x, y, w, h);
+  if (this._bgcolor != null) {
+    g.fillStyle = this._bgcolor;
+    g.fillRect(x, y, w, h); 
+  }
+};
+
+prototype.loadImage = function(uri) {
+  var renderer = this,
+      scene = this._scene;
+  return this._loader.loadImage(uri, function() {
+    renderer.renderAsync(scene);
+  });
+};
+
+prototype.renderAsync = function(scene) {
+  // TODO make safe for multiple scene rendering?
+  var renderer = this;
+  if (renderer._async_id) {
+    clearTimeout(renderer._async_id);
+  }
+  renderer._async_id = setTimeout(function() {
+    renderer.render(scene);
+    delete renderer._async_id;
+  }, 10);
+};
+
+module.exports = CanvasRenderer;
+
+},{"../../util/Bounds":74,"../../util/ImageLoader":77,"../../util/canvas":80,"../../util/dom":81,"../Renderer":52,"./marks":60}],55:[function(require,module,exports){
+module.exports = {
+  Handler:  require('./CanvasHandler'),
+  Renderer: require('./CanvasRenderer')
+};
+},{"./CanvasHandler":53,"./CanvasRenderer":54}],56:[function(require,module,exports){
+var util = require('./util');
+var halfpi = Math.PI / 2;
+
+function path(g, o) {
+  var x = o.x || 0,
+      y = o.y || 0,
+      ir = o.innerRadius || 0,
+      or = o.outerRadius || 0,
+      sa = (o.startAngle || 0) - halfpi,
+      ea = (o.endAngle || 0) - halfpi;
+  g.beginPath();
+  if (ir === 0) g.moveTo(x, y);
+  else g.arc(x, y, ir, sa, ea, 0);
+  g.arc(x, y, or, ea, sa, 1);
+  g.closePath();
+}
+
+module.exports = {
+  draw: util.drawAll(path),
+  pick: util.pickPath(path)
+};
+},{"./util":67}],57:[function(require,module,exports){
+var util = require('./util'),
+    parse = require('../../../path/parse'),
+    render = require('../../../path/render'),
+    areaPath = require('../../../util/svg').path.area;
+
+function path(g, items) {
+  var o = items[0],
+      p = o.pathCache || (o.pathCache = parse(areaPath(items)));
+  render(g, p);
+}
+
+function pick(g, scene, x, y, gx, gy) {
+  var items = scene.items,
+      b = scene.bounds;
+
+  if (!items || !items.length || b && !b.contains(gx, gy)) {
+    return null;
+  }
+
+  if (g.pixelratio != null && g.pixelratio !== 1) {
+    x *= g.pixelratio;
+    y *= g.pixelratio;
+  }
+  return hit(g, items, x, y) ? items[0] : null;
+}
+
+var hit = util.testPath(path);
+
+module.exports = {
+  draw: util.drawOne(path),
+  pick: pick,
+  nested: true
+};
+
+},{"../../../path/parse":49,"../../../path/render":50,"../../../util/svg":83,"./util":67}],58:[function(require,module,exports){
+var util = require('./util'),
+    rect = require('./rect');
+
+function draw(g, scene, bounds) {
+  if (!scene.items || !scene.items.length) return;
+
+  var groups = scene.items,
+      renderer = this,
+      group, items, axes, legends, gx, gy, i, n, j, m;
+
+  rect.draw.call(renderer, g, scene, bounds);
+
+  for (i=0, n=groups.length; i<n; ++i) {
+    group = groups[i];
+    axes = group.axisItems || [];
+    items = group.items || [];
+    legends = group.legendItems || [];
+    gx = group.x || 0;
+    gy = group.y || 0;
+
+    // render group contents
+    g.save();
+    g.translate(gx, gy);
+    if (group.clip) {
+      g.beginPath();
+      g.rect(0, 0, group.width || 0, group.height || 0);
+      g.clip();
+    }
+
+    if (bounds) bounds.translate(-gx, -gy);
+
+    for (j=0, m=axes.length; j<m; ++j) {
+      if (axes[j].layer === 'back') {
+        renderer.draw(g, axes[j], bounds);
+      }
+    }
+    for (j=0, m=items.length; j<m; ++j) {
+      renderer.draw(g, items[j], bounds);
+    }
+    for (j=0, m=axes.length; j<m; ++j) {
+      if (axes[j].layer !== 'back') {
+        renderer.draw(g, axes[j], bounds);
+      }
+    }
+    for (j=0, m=legends.length; j<m; ++j) {
+      renderer.draw(g, legends[j], bounds);
+    }
+    
+    if (bounds) bounds.translate(gx, gy);
+    g.restore();
+  }    
+}
+
+function hit(g, o) {
+  return o.fill || o.stroke;
+}
+
+function pick(g, scene, x, y, gx, gy) {
+  if (scene.bounds && !scene.bounds.contains(gx, gy)) {
+    return null;
+  }
+  var items = scene.items || [],
+      subscene, group, hits, dx, dy, i, j;
+
+  for (i=items.length; --i>=0;) {
+    group = items[i];
+    dx = group.x || 0;
+    dy = group.y || 0;
+
+    g.save();
+    g.translate(dx, dy);
+    for (j=group.items.length; --j >= 0;) {
+      subscene = group.items[j];
+      if (subscene.interactive === false) continue;
+      hits = this.pick(subscene, x, y, gx-dx, gy-dy);
+      if (hits) {
+        g.restore();
+        return hits;
+      }
+    }
+    g.restore();
+  }
+
+  return scene.interactive !== false ? pickSelf(g, scene, x, y, gx, gy) : null;
+}
+
+var pickSelf = util.pick(hit);
+
+module.exports = {
+  draw: draw,
+  pick: pick
+};
+
+},{"./rect":63,"./util":67}],59:[function(require,module,exports){
+var util = require('./util');
+
+function draw(g, scene, bounds) {
+  if (!scene.items || !scene.items.length) return;
+
+  var renderer = this,
+      items = scene.items, o;
+
+  for (var i=0, len=items.length; i<len; ++i) {
+    o = items[i];
+    if (bounds && !bounds.intersects(o.bounds))
+      continue; // bounds check
+
+    if (!(o.image && o.image.url === o.url)) {
+      o.image = renderer.loadImage(o.url);
+      o.image.url = o.url;
+    }
+
+    var x = o.x || 0,
+        y = o.y || 0,
+        w = o.width || (o.image && o.image.width) || 0,
+        h = o.height || (o.image && o.image.height) || 0,
+        opac;
+    x = x - (o.align==='center' ? w/2 : o.align==='right' ? w : 0);
+    y = y - (o.baseline==='middle' ? h/2 : o.baseline==='bottom' ? h : 0);
+
+    if (o.image.loaded) {
+      g.globalAlpha = (opac = o.opacity) != null ? opac : 1;
+      g.drawImage(o.image, x, y, w, h);
+    }
+  }
+}
+
+module.exports = {
+  draw: draw,
+  pick: util.pick()
+};
+},{"./util":67}],60:[function(require,module,exports){
+module.exports = {
+  arc:    require('./arc'),
+  area:   require('./area'),
+  group:  require('./group'),
+  image:  require('./image'),
+  line:   require('./line'),
+  path:   require('./path'),
+  rect:   require('./rect'),
+  rule:   require('./rule'),
+  symbol: require('./symbol'),
+  text:   require('./text')
+};
+
+},{"./arc":56,"./area":57,"./group":58,"./image":59,"./line":61,"./path":62,"./rect":63,"./rule":64,"./symbol":65,"./text":66}],61:[function(require,module,exports){
+var util = require('./util'),
+    parse = require('../../../path/parse'),
+    render = require('../../../path/render'),
+    linePath = require('../../../util/svg').path.line;
+    
+function path(g, items) {
+  var o = items[0],
+      p = o.pathCache || (o.pathCache = parse(linePath(items)));
+  render(g, p);
+}
+
+function pick(g, scene, x, y, gx, gy) {
+  var items = scene.items,
+      b = scene.bounds;
+
+  if (!items || !items.length || b && !b.contains(gx, gy)) {
+    return null;
+  }
+
+  if (g.pixelratio != null && g.pixelratio !== 1) {
+    x *= g.pixelratio;
+    y *= g.pixelratio;
+  }
+  return hit(g, items, x, y) ? items[0] : null;
+}
+
+var hit = util.testPath(path, false);
+
+module.exports = {
+  draw: util.drawOne(path),
+  pick: pick,
+  nested: true
+};
+
+},{"../../../path/parse":49,"../../../path/render":50,"../../../util/svg":83,"./util":67}],62:[function(require,module,exports){
+var util = require('./util'),
+    parse = require('../../../path/parse'),
+    render = require('../../../path/render');
+
+function path(g, o) {
+  if (o.path == null) return true;
+  var p = o.pathCache || (o.pathCache = parse(o.path));
+  render(g, p, o.x, o.y);
+}
+
+module.exports = {
+  draw: util.drawAll(path),
+  pick: util.pickPath(path)
+};
+
+},{"../../../path/parse":49,"../../../path/render":50,"./util":67}],63:[function(require,module,exports){
+var util = require('./util');
+
+function draw(g, scene, bounds) {
+  if (!scene.items || !scene.items.length) return;
+
+  var items = scene.items,
+      o, opac, x, y, w, h;
+
+  for (var i=0, len=items.length; i<len; ++i) {
+    o = items[i];
+    if (bounds && !bounds.intersects(o.bounds))
+      continue; // bounds check
+
+    opac = o.opacity == null ? 1 : o.opacity;
+    if (opac === 0) continue;
+
+    x = o.x || 0;
+    y = o.y || 0;
+    w = o.width || 0;
+    h = o.height || 0;
+
+    if (o.fill && util.fill(g, o, opac)) {
+      g.fillRect(x, y, w, h);
+    }
+    if (o.stroke && util.stroke(g, o, opac)) {
+      g.strokeRect(x, y, w, h);
+    }
+  }
+}
+
+module.exports = {
+  draw: draw,
+  pick: util.pick()
+};
+},{"./util":67}],64:[function(require,module,exports){
+var util = require('./util');
+
+function draw(g, scene, bounds) {
+  if (!scene.items || !scene.items.length) return;
+
+  var items = scene.items,
+      o, opac, x1, y1, x2, y2;
+
+  for (var i=0, len=items.length; i<len; ++i) {
+    o = items[i];
+    if (bounds && !bounds.intersects(o.bounds))
+      continue; // bounds check
+
+    opac = o.opacity == null ? 1 : o.opacity;
+    if (opac === 0) continue;
+      
+    x1 = o.x || 0;
+    y1 = o.y || 0;
+    x2 = o.x2 != null ? o.x2 : x1;
+    y2 = o.y2 != null ? o.y2 : y1;
+
+    if (o.stroke && util.stroke(g, o, opac)) {
+      g.beginPath();
+      g.moveTo(x1, y1);
+      g.lineTo(x2, y2);
+      g.stroke();
+    }
+  }
+}
+
+function stroke(g, o) {
+  var x1 = o.x || 0,
+      y1 = o.y || 0,
+      x2 = o.x2 != null ? o.x2 : x1,
+      y2 = o.y2 != null ? o.y2 : y1,
+      lw = o.strokeWidth,
+      lc = o.strokeCap;
+
+  g.lineWidth = lw != null ? lw : 1;
+  g.lineCap   = lc != null ? lc : 'butt';
+  g.beginPath();
+  g.moveTo(x1, y1);
+  g.lineTo(x2, y2);
+}
+
+function hit(g, o, x, y) {
+  if (!g.isPointInStroke) return false;
+  stroke(g, o);
+  return g.isPointInStroke(x, y);
+}
+
+module.exports = {
+  draw: draw,
+  pick: util.pick(hit)
+};
+
+},{"./util":67}],65:[function(require,module,exports){
+var util = require('./util');
+
+var sqrt3 = Math.sqrt(3),
+    tan30 = Math.tan(30 * Math.PI / 180);
+
+function path(g, o) {
+  var size = o.size != null ? o.size : 100,
+      x = o.x, y = o.y, r, t, rx, ry;
+
+  g.beginPath();
+
+  if (o.shape == null || o.shape === 'circle') {
+    r = Math.sqrt(size / Math.PI);
+    g.arc(x, y, r, 0, 2*Math.PI, 0);
+    g.closePath();
+    return;
+  }
+
+  switch (o.shape) {
+    case 'cross':
+      r = Math.sqrt(size / 5) / 2;
+      t = 3*r;
+      g.moveTo(x-t, y-r);
+      g.lineTo(x-r, y-r);
+      g.lineTo(x-r, y-t);
+      g.lineTo(x+r, y-t);
+      g.lineTo(x+r, y-r);
+      g.lineTo(x+t, y-r);
+      g.lineTo(x+t, y+r);
+      g.lineTo(x+r, y+r);
+      g.lineTo(x+r, y+t);
+      g.lineTo(x-r, y+t);
+      g.lineTo(x-r, y+r);
+      g.lineTo(x-t, y+r);
+      break;
+
+    case 'diamond':
+      ry = Math.sqrt(size / (2 * tan30));
+      rx = ry * tan30;
+      g.moveTo(x, y-ry);
+      g.lineTo(x+rx, y);
+      g.lineTo(x, y+ry);
+      g.lineTo(x-rx, y);
+      break;
+
+    case 'square':
+      t = Math.sqrt(size);
+      r = t / 2;
+      g.rect(x-r, y-r, t, t);
+      break;
+
+    case 'triangle-down':
+      rx = Math.sqrt(size / sqrt3);
+      ry = rx * sqrt3 / 2;
+      g.moveTo(x, y+ry);
+      g.lineTo(x+rx, y-ry);
+      g.lineTo(x-rx, y-ry);
+      break;
+
+    case 'triangle-up':
+      rx = Math.sqrt(size / sqrt3);
+      ry = rx * sqrt3 / 2;
+      g.moveTo(x, y-ry);
+      g.lineTo(x+rx, y+ry);
+      g.lineTo(x-rx, y+ry);
+  }
+  g.closePath();
+}
+
+module.exports = {
+  draw: util.drawAll(path),
+  pick: util.pickPath(path)
+};
+},{"./util":67}],66:[function(require,module,exports){
+var Bounds = require('../../../util/Bounds'),
+    textBounds = require('../../../util/bound').text,
+    text = require('../../../util/text'),
+    util = require('./util'),
+    tempBounds = new Bounds();
+
+function draw(g, scene, bounds) {
+  if (!scene.items || !scene.items.length) return;
+
+  var items = scene.items,
+      o, opac, x, y, r, t, str;
+
+  for (var i=0, len=items.length; i<len; ++i) {
+    o = items[i];
+    if (bounds && !bounds.intersects(o.bounds))
+      continue; // bounds check
+
+    str = text.value(o.text);
+    if (!str) continue;
+    opac = o.opacity == null ? 1 : o.opacity;
+    if (opac === 0) continue;
+
+    g.font = text.font(o);
+    g.textAlign = o.align || 'left';
+
+    x = (o.x || 0);
+    y = (o.y || 0);
+    if ((r = o.radius)) {
+      t = (o.theta || 0) - Math.PI/2;
+      x += r * Math.cos(t);
+      y += r * Math.sin(t);
+    }
+
+    if (o.angle) {
+      g.save();
+      g.translate(x, y);
+      g.rotate(o.angle * Math.PI/180);
+      x = y = 0; // reset x, y
+    }
+    x += (o.dx || 0);
+    y += (o.dy || 0) + text.offset(o);
+
+    if (o.fill && util.fill(g, o, opac)) {
+      g.fillText(str, x, y);
+    }
+    if (o.stroke && util.stroke(g, o, opac)) {
+      g.strokeText(str, x, y);
+    }
+    if (o.angle) g.restore();
+  }
+}
+
+function hit(g, o, x, y, gx, gy) {
+  if (o.fontSize <= 0) return false;
+  if (!o.angle) return true; // bounds sufficient if no rotation
+
+  // project point into space of unrotated bounds
+  var b = textBounds(o, tempBounds, true),
+      a = -o.angle * Math.PI / 180,
+      cos = Math.cos(a),
+      sin = Math.sin(a),
+      ox = o.x,
+      oy = o.y,
+      px = cos*gx - sin*gy + (ox - ox*cos + oy*sin),
+      py = sin*gx + cos*gy + (oy - ox*sin - oy*cos);
+
+  return b.contains(px, py);
+}
+
+module.exports = {
+  draw: draw,
+  pick: util.pick(hit)
+};
+
+},{"../../../util/Bounds":74,"../../../util/bound":79,"../../../util/text":84,"./util":67}],67:[function(require,module,exports){
+function drawPathOne(path, g, o, items) {
+  if (path(g, items)) return;
+
+  var opac = o.opacity == null ? 1 : o.opacity;
+  if (opac===0) return;
+
+  if (o.fill && fill(g, o, opac)) { g.fill(); }
+  if (o.stroke && stroke(g, o, opac)) { g.stroke(); }
+}
+
+function drawPathAll(path, g, scene, bounds) {
+  var i, len, item;
+  for (i=0, len=scene.items.length; i<len; ++i) {
+    item = scene.items[i];
+    if (!bounds || bounds.intersects(item.bounds)) {
+      drawPathOne(path, g, item, item);
+    }
+  }
+}
+
+function drawAll(pathFunc) {
+  return function(g, scene, bounds) {
+    drawPathAll(pathFunc, g, scene, bounds);
+  };
+}
+
+function drawOne(pathFunc) {
+  return function(g, scene, bounds) {
+    if (!scene.items.length) return;
+    if (!bounds || bounds.intersects(scene.bounds)) {
+      drawPathOne(pathFunc, g, scene.items[0], scene.items);
+    }
+  };
+}
+
+var trueFunc = function() { return true; };
+
+function pick(test) {
+  if (!test) test = trueFunc;
+
+  return function(g, scene, x, y, gx, gy) {
+    if (!scene.items.length) return null;
+
+    var o, b, i;
+
+    if (g.pixelratio != null && g.pixelratio !== 1) {
+      x *= g.pixelratio;
+      y *= g.pixelratio;
+    }
+
+    for (i=scene.items.length; --i >= 0;) {
+      o = scene.items[i]; b = o.bounds;
+      // first hit test against bounding box
+      if ((b && !b.contains(gx, gy)) || !b) continue;
+      // if in bounding box, perform more careful test
+      if (test(g, o, x, y, gx, gy)) return o;
+    }
+    return null;
+  };
+}
+
+function testPath(path, filled) {
+  return function(g, o, x, y) {
+    var item = Array.isArray(o) ? o[0] : o,
+        fill = (filled == null) ? item.fill : filled,
+        stroke = item.stroke && g.isPointInStroke, lw, lc;
+
+    if (stroke) {
+      lw = item.strokeWidth;
+      lc = item.strokeCap;
+      g.lineWidth = lw != null ? lw : 1;
+      g.lineCap   = lc != null ? lc : 'butt';
+    }
+
+    return path(g, o) ? false :
+      (fill && g.isPointInPath(x, y)) ||
+      (stroke && g.isPointInStroke(x, y));
+  };
+}
+
+function pickPath(path) {
+  return pick(testPath(path));
+}
+
+function fill(g, o, opacity) {
+  opacity *= (o.fillOpacity==null ? 1 : o.fillOpacity);
+  if (opacity > 0) {
+    g.globalAlpha = opacity;
+    g.fillStyle = color(g, o, o.fill);
+    return true;
+  } else {
+    return false;
+  }
+}
+
+function stroke(g, o, opacity) {
+  var lw = (lw = o.strokeWidth) != null ? lw : 1, lc;
+  if (lw <= 0) return false;
+
+  opacity *= (o.strokeOpacity==null ? 1 : o.strokeOpacity);
+  if (opacity > 0) {
+    g.globalAlpha = opacity;
+    g.strokeStyle = color(g, o, o.stroke);
+    g.lineWidth = lw;
+    g.lineCap = (lc = o.strokeCap) != null ? lc : 'butt';
+    g.vgLineDash(o.strokeDash || null);
+    g.vgLineDashOffset(o.strokeDashOffset || 0);
+    return true;
+  } else {
+    return false;
+  }
+}
+
+function color(g, o, value) {
+  return (value.id) ?
+    gradient(g, value, o.bounds) :
+    value;
+}
+
+function gradient(g, p, b) {
+  var w = b.width(),
+      h = b.height(),
+      x1 = b.x1 + p.x1 * w,
+      y1 = b.y1 + p.y1 * h,
+      x2 = b.x1 + p.x2 * w,
+      y2 = b.y1 + p.y2 * h,
+      grad = g.createLinearGradient(x1, y1, x2, y2),
+      stop = p.stops,
+      i, n;
+
+  for (i=0, n=stop.length; i<n; ++i) {
+    grad.addColorStop(stop[i].offset, stop[i].color);
+  }
+  return grad;
+}
+
+module.exports = {
+  drawOne:  drawOne,
+  drawAll:  drawAll,
+  pick:     pick,
+  pickPath: pickPath,
+  testPath: testPath,
+  stroke:   stroke,
+  fill:     fill,
+  color:    color,
+  gradient: gradient
+};
+
+},{}],68:[function(require,module,exports){
+module.exports = {
+  'canvas': require('./canvas'),
+  'svg':    require('./svg')
+};
+
+},{"./canvas":55,"./svg":72}],69:[function(require,module,exports){
+var DOM = require('../../util/dom'),
+    Handler = require('../Handler');
+
+function SVGHandler() {
+  Handler.call(this);
+}
+
+var base = Handler.prototype;
+var prototype = (SVGHandler.prototype = Object.create(base));
+prototype.constructor = SVGHandler;
+
+prototype.initialize = function(el, pad, obj) {
+  this._svg = DOM.find(el, 'svg');
+  return base.initialize.call(this, el, pad, obj);
+};
+
+prototype.svg = function() {
+  return this._svg;
+};
+
+// wrap an event listener for the SVG DOM
+prototype.listener = function(handler) {
+  var that = this;
+  return function(evt) {
+    var target = evt.target,
+        item = target.__data__;
+    evt.vegaType = evt.type;
+    item = Array.isArray(item) ? item[0] : item;
+    handler.call(that._obj, evt, item);
+  };
+};
+
+// add an event handler
+prototype.on = function(type, handler) {
+  var name = this.eventName(type),
+      svg = this._svg,
+      h = this._handlers,
+      x = {
+        type:     type,
+        handler:  handler,
+        listener: this.listener(handler)
+      };
+
+  (h[name] || (h[name] = [])).push(x);
+  svg.addEventListener(name, x.listener);
+  return this;
+};
+
+// remove an event handler
+prototype.off = function(type, handler) {
+  var name = this.eventName(type),
+      svg = this._svg,
+      h = this._handlers[name], i;
+  if (!h) return;
+  for (i=h.length; --i>=0;) {
+    if (h[i].type === type && !handler || h[i].handler === handler) {
+      svg.removeEventListener(name, h[i].listener);
+      h.splice(i, 1);
+    }
+  }
+  return this;
+};
+
+module.exports = SVGHandler;
+
+},{"../../util/dom":81,"../Handler":51}],70:[function(require,module,exports){
+var ImageLoader = require('../../util/ImageLoader'),
+    Renderer = require('../Renderer'),
+    text = require('../../util/text'),
+    DOM = require('../../util/dom'),
+    SVG = require('../../util/svg'),
+    ns = SVG.metadata.xmlns,
+    marks = require('./marks');
+
+function SVGRenderer(loadConfig) {
+  Renderer.call(this);
+  this._loader = new ImageLoader(loadConfig);
+  this._dirtyID = 0;
+}
+
+var base = Renderer.prototype;
+var prototype = (SVGRenderer.prototype = Object.create(base));
+prototype.constructor = SVGRenderer;
+
+prototype.initialize = function(el, width, height, padding) {
+  if (el) {
+    this._svg = DOM.child(el, 0, 'svg', ns, 'marks');
+    DOM.clear(el, 1);
+    // set the svg root group
+    this._root = DOM.child(this._svg, 0, 'g', ns);
+    DOM.clear(this._svg, 1);
+  }
+
+  // create the svg definitions cache
+  this._defs = {
+    clip_id:  1,
+    gradient: {},
+    clipping: {}
+  };
+
+  // set background color if defined
+  this.background(this._bgcolor);
+
+  return base.initialize.call(this, el, width, height, padding);
+};
+
+prototype.background = function(bgcolor) {
+  if (arguments.length && this._svg) {
+    this._svg.style.setProperty('background-color', bgcolor);
+  }
+  return base.background.apply(this, arguments);
+};
+
+prototype.resize = function(width, height, padding) {
+  base.resize.call(this, width, height, padding);
+  
+  if (this._svg) {
+    var w = this._width,
+        h = this._height,
+        p = this._padding;
+  
+    this._svg.setAttribute('width', w + p.left + p.right);
+    this._svg.setAttribute('height', h + p.top + p.bottom);
+    
+    this._root.setAttribute('transform', 'translate('+p.left+','+p.top+')');
+  }
+
+  return this;
+};
+
+prototype.svg = function() {
+  if (!this._svg) return null;
+
+  var attr = {
+    'class':  'marks',
+    'width':  this._width + this._padding.left + this._padding.right,
+    'height': this._height + this._padding.top + this._padding.bottom,
+  };
+  for (var key in SVG.metadata) {
+    attr[key] = SVG.metadata[key];
+  }
+
+  return DOM.openTag('svg', attr) + this._svg.innerHTML + DOM.closeTag('svg');
+};
+
+prototype.imageURL = function(url) {
+  return this._loader.imageURL(url);
+};
+
+
+// -- Render entry point --
+
+prototype.render = function(scene, items) {
+  if (this._dirtyCheck(items)) {
+    if (this._dirtyAll) this._resetDefs();
+    this.draw(this._root, scene, -1);
+    DOM.clear(this._root, 1);
+  }
+  this.updateDefs();
+  return this;
+};
+
+prototype.draw = function(el, scene, index) {
+  this.drawMark(el, scene, index, marks[scene.marktype]);
+};
+
+
+// -- Manage SVG definitions ('defs') block --
+
+prototype.updateDefs = function() {
+  var svg = this._svg,
+      defs = this._defs,
+      el = defs.el,
+      index = 0, id;
+
+  for (id in defs.gradient) {
+    if (!el) el = (defs.el = DOM.child(svg, 0, 'defs', ns));
+    updateGradient(el, defs.gradient[id], index++);
+  }
+
+  for (id in defs.clipping) {
+    if (!el) el = (defs.el = DOM.child(svg, 0, 'defs', ns));
+    updateClipping(el, defs.clipping[id], index++);
+  }
+
+  // clean-up
+  if (el) {
+    if (index === 0) {
+      svg.removeChild(el);
+      defs.el = null;
+    } else {
+      DOM.clear(el, index);      
+    }
+  }
+};
+
+function updateGradient(el, grad, index) {
+  var i, n, stop;
+
+  el = DOM.child(el, index, 'linearGradient', ns);
+  el.setAttribute('id', grad.id);
+  el.setAttribute('x1', grad.x1);
+  el.setAttribute('x2', grad.x2);
+  el.setAttribute('y1', grad.y1);
+  el.setAttribute('y2', grad.y2);
+  
+  for (i=0, n=grad.stops.length; i<n; ++i) {
+    stop = DOM.child(el, i, 'stop', ns);
+    stop.setAttribute('offset', grad.stops[i].offset);
+    stop.setAttribute('stop-color', grad.stops[i].color);
+  }
+  DOM.clear(el, i);
+}
+
+function updateClipping(el, clip, index) {
+  var rect;
+
+  el = DOM.child(el, index, 'clipPath', ns);
+  el.setAttribute('id', clip.id);
+  rect = DOM.child(el, 0, 'rect', ns);
+  rect.setAttribute('x', 0);
+  rect.setAttribute('y', 0);
+  rect.setAttribute('width', clip.width);
+  rect.setAttribute('height', clip.height);
+}
+
+prototype._resetDefs = function() {
+  var def = this._defs;
+  def.clip_id = 1;
+  def.gradient = {};
+  def.clipping = {};
+};
+
+
+// -- Manage rendering of items marked as dirty --
+
+prototype.isDirty = function(item) {
+  return this._dirtyAll || item.dirty === this._dirtyID;
+};
+
+prototype._dirtyCheck = function(items) {
+  this._dirtyAll = true;
+  if (!items) return true;
+
+  var id = ++this._dirtyID,
+      item, mark, type, mdef, i, n, o;
+
+  for (i=0, n=items.length; i<n; ++i) {
+    item = items[i];
+    mark = item.mark;
+    if (mark.marktype !== type) {
+      // memoize mark instance lookup
+      type = mark.marktype;
+      mdef = marks[type];
+    }
+
+    if (item.status === 'exit') { // EXIT
+      if (item._svg) {
+        if (mdef.nest && item.mark.items.length) {
+          // if nested mark with remaining points, update instead
+          this._update(mdef, item._svg, item.mark.items[0]);
+          o = item.mark.items[0];
+          o._svg = item._svg;
+          o._update = id;
+        } else {
+          // otherwise remove from DOM
+          DOM.remove(item._svg);
+        }
+        item._svg = null;
+      }
+      continue;
+    }
+
+    item = (mdef.nest ? mark.items[0] : item);
+    if (item._update === id) { // Already processed
+      continue;
+    } else if (item._svg) { // UPDATE
+      this._update(mdef, item._svg, item);
+    } else { // ENTER
+      this._dirtyAll = false;
+      dirtyParents(item, id);
+    }
+    item._update = id;
+  }
+  return !this._dirtyAll;
+};
+
+function dirtyParents(item, id) {
+  for (; item && item.dirty !== id; item=item.mark.group) {
+    item.dirty = id;
+    if (item.mark && item.mark.dirty !== id) {
+      item.mark.dirty = id;
+    } else return;
+  }
+}
+
+
+// -- Construct & maintain scenegraph to SVG mapping ---
+
+// Draw a mark container.
+prototype.drawMark = function(el, scene, index, mdef) {
+  if (!this.isDirty(scene)) return;
+
+  var items = mdef.nest ?
+        (scene.items && scene.items.length ? [scene.items[0]] : []) :
+        scene.items || [],
+      events = scene.interactive === false ? 'none' : null,
+      isGroup = (mdef.tag === 'g'),
+      className = DOM.cssClass(scene),
+      p, i, n, c, d, insert;
+
+  p = DOM.child(el, index+1, 'g', ns, className);
+  p.setAttribute('class', className);
+  scene._svg = p;
+  if (!isGroup && events) {
+    p.style.setProperty('pointer-events', events);
+  }
+
+  for (i=0, n=items.length; i<n; ++i) {
+    if (this.isDirty(d = items[i])) {
+      insert = !(this._dirtyAll || d._svg);
+      c = insert ? bind(p, mdef, d, i, true)
+        : (p.childNodes[i] || bind(p, mdef, d, i));
+      this._update(mdef, c, d);
+      if (isGroup) {
+        if (insert) this._dirtyAll = true;
+        this._recurse(c, d);
+        if (insert) this._dirtyAll = false;
+      }
+    }
+  }
+  DOM.clear(p, i);
+  return p;
+};
+
+// Recursively process group contents.
+prototype._recurse = function(el, group) {
+  var items = group.items || [],
+      legends = group.legendItems || [],
+      axes = group.axisItems || [],
+      idx = 0, j, m;
+
+  for (j=0, m=axes.length; j<m; ++j) {
+    if (axes[j].layer === 'back') {
+      this.drawMark(el, axes[j], idx++, marks.group);
+    }
+  }
+  for (j=0, m=items.length; j<m; ++j) {
+    this.draw(el, items[j], idx++);
+  }
+  for (j=0, m=axes.length; j<m; ++j) {
+    if (axes[j].layer !== 'back') {
+      this.drawMark(el, axes[j], idx++, marks.group);
+    }
+  }
+  for (j=0, m=legends.length; j<m; ++j) {
+    this.drawMark(el, legends[j], idx++, marks.group);
+  }
+
+  // remove any extraneous DOM elements
+  DOM.clear(el, 1 + idx);
+};
+
+// Bind a scenegraph item to an SVG DOM element.
+// Create new SVG elements as needed.
+function bind(el, mdef, item, index, insert) {
+  // create svg element, bind item data for D3 compatibility
+  var node = DOM.child(el, index, mdef.tag, ns, null, insert);
+  node.__data__ = item;
+  node.__values__ = {fill: 'default'};
+
+  // create background rect
+  if (mdef.tag === 'g') {
+    var bg = DOM.child(node, 0, 'rect', ns, 'background');
+    bg.__data__ = item;
+  }
+
+  // add pointer from scenegraph item to svg element
+  return (item._svg = node);
+}
+
+
+// -- Set attributes & styles on SVG elements ---
+
+var href = (typeof window !== 'undefined' ? window.location.href : ''),
+    element = null, // temp var for current SVG element
+    values = null;  // temp var for current values hash
+
+// Extra configuration for certain mark types
+var mark_extras = {
+  group: function(mdef, el, item) {
+    element = el.childNodes[0];
+    values = el.__values__; // use parent's values hash
+    mdef.background(emit, item, this);
+
+    var value = item.mark.interactive === false ? 'none' : null;
+    if (value !== values.events) {
+      element.style.setProperty('pointer-events', value);
+      values.events = value;
+    }
+  },
+  text: function(mdef, el, item) {
+    var str = text.value(item.text);
+    if (str !== values.text) {
+      el.textContent = str;
+      values.text = str;
+    }
+    str = text.font(item);
+    if (str !== values.font) {
+      el.style.setProperty('font', str);
+      values.font = str;
+    }
+  }
+};
+
+prototype._update = function(mdef, el, item) {
+  // set dom element and values cache
+  // provides access to emit method
+  element = el;
+  values = el.__values__;
+
+  // apply svg attributes
+  mdef.attr(emit, item, this);
+
+  // some marks need special treatment
+  var extra = mark_extras[mdef.type];
+  if (extra) extra(mdef, el, item);
+
+  // apply svg css styles
+  // note: element may be modified by 'extra' method
+  this.style(element, item);
+};
+
+function emit(name, value, ns) {
+  // early exit if value is unchanged
+  if (value === values[name]) return;
+
+  if (value != null) {
+    // if value is provided, update DOM attribute
+    if (ns) {
+      element.setAttributeNS(ns, name, value);
+    } else {
+      element.setAttribute(name, value);
+    }
+  } else {
+    // else remove DOM attribute
+    if (ns) {
+      element.removeAttributeNS(ns, name);
+    } else {
+      element.removeAttribute(name);
+    }
+  }
+
+  // note current value for future comparison
+  values[name] = value;
+}
+
+prototype.style = function(el, o) {
+  if (o == null) return;
+  var i, n, prop, name, value;
+
+  for (i=0, n=SVG.styleProperties.length; i<n; ++i) {
+    prop = SVG.styleProperties[i];
+    value = o[prop];
+    if (value === values[prop]) continue;
+
+    name = SVG.styles[prop];
+    if (value == null) {
+      if (name === 'fill') {
+        el.style.setProperty(name, 'none');
+      } else {
+        el.style.removeProperty(name);
+      }
+    } else {
+      if (value.id) {
+        // ensure definition is included
+        this._defs.gradient[value.id] = value;
+        value = 'url(' + href + '#' + value.id + ')';
+      }
+      el.style.setProperty(name, value+'');
+    }
+
+    values[prop] = value;
+  }
+};
+
+module.exports = SVGRenderer;
+
+},{"../../util/ImageLoader":77,"../../util/dom":81,"../../util/svg":83,"../../util/text":84,"../Renderer":52,"./marks":73}],71:[function(require,module,exports){
+var Renderer = require('../Renderer'),
+    ImageLoader = require('../../util/ImageLoader'),
+    SVG = require('../../util/svg'),
+    text = require('../../util/text'),
+    DOM = require('../../util/dom'),
+    openTag = DOM.openTag,
+    closeTag = DOM.closeTag,
+    MARKS = require('./marks');
+
+function SVGStringRenderer(loadConfig) {
+  Renderer.call(this);
+
+  this._loader = new ImageLoader(loadConfig);
+
+  this._text = {
+    head: '',
+    root: '',
+    foot: '',
+    defs: '',
+    body: ''
+  };
+
+  this._defs = {
+    clip_id:  1,
+    gradient: {},
+    clipping: {}
+  };
+}
+
+var base = Renderer.prototype;
+var prototype = (SVGStringRenderer.prototype = Object.create(base));
+prototype.constructor = SVGStringRenderer;
+
+prototype.resize = function(width, height, padding) {
+  base.resize.call(this, width, height, padding);
+  var p = this._padding,
+      t = this._text;
+
+  var attr = {
+    'class':  'marks',
+    'width':  this._width + p.left + p.right,
+    'height': this._height + p.top + p.bottom,
+  };
+  for (var key in SVG.metadata) {
+    attr[key] = SVG.metadata[key];
+  }
+
+  t.head = openTag('svg', attr);
+  t.root = openTag('g', {
+    transform: 'translate(' + p.left + ',' + p.top + ')'
+  });
+  t.foot = closeTag('g') + closeTag('svg');
+
+  return this;
+};
+
+prototype.svg = function() {
+  var t = this._text;
+  return t.head + t.defs + t.root + t.body + t.foot;
+};
+
+prototype.render = function(scene) {
+  this._text.body = this.mark(scene);
+  this._text.defs = this.buildDefs();
+  return this;
+};
+
+prototype.reset = function() {
+  this._defs.clip_id = 0;
+  return this;
+};
+
+prototype.buildDefs = function() {
+  var all = this._defs,
+      defs = '',
+      i, id, def, stops;
+
+  for (id in all.gradient) {
+    def = all.gradient[id];
+    stops = def.stops;
+
+    defs += openTag('linearGradient', {
+      id: id,
+      x1: def.x1,
+      x2: def.x2,
+      y1: def.y1,
+      y2: def.y2
+    });
+    
+    for (i=0; i<stops.length; ++i) {
+      defs += openTag('stop', {
+        offset: stops[i].offset,
+        'stop-color': stops[i].color
+      }) + closeTag('stop');
+    }
+    
+    defs += closeTag('linearGradient');
+  }
+  
+  for (id in all.clipping) {
+    def = all.clipping[id];
+
+    defs += openTag('clipPath', {id: id});
+
+    defs += openTag('rect', {
+      x: 0,
+      y: 0,
+      width: def.width,
+      height: def.height
+    }) + closeTag('rect');
+
+    defs += closeTag('clipPath');
+  }
+  
+  return (defs.length > 0) ? openTag('defs') + defs + closeTag('defs') : '';
+};
+
+prototype.imageURL = function(url) {
+  return this._loader.imageURL(url);
+};
+
+var object;
+
+function emit(name, value, ns, prefixed) {
+  object[prefixed || name] = value;
+}
+
+prototype.attributes = function(attr, item) {
+  object = {};
+  attr(emit, item, this);
+  return object;
+};
+
+prototype.mark = function(scene) {
+  var mdef = MARKS[scene.marktype],
+      tag  = mdef.tag,
+      attr = mdef.attr,
+      nest = mdef.nest || false,
+      data = nest ?
+          (scene.items && scene.items.length ? [scene.items[0]] : []) :
+          (scene.items || []),
+      defs = this._defs,
+      str = '',
+      style, i, item;
+
+  if (tag !== 'g' && scene.interactive === false) {
+    style = 'style="pointer-events: none;"';
+  }
+
+  // render opening group tag
+  str += openTag('g', {
+    'class': DOM.cssClass(scene)
+  }, style);
+
+  // render contained elements
+  for (i=0; i<data.length; ++i) {
+    item = data[i];
+    style = (tag !== 'g') ? styles(item, scene, tag, defs) : null;
+    str += openTag(tag, this.attributes(attr, item), style);
+    if (tag === 'text') {
+      str += escape_text(text.value(item.text));
+    } else if (tag === 'g') {
+      str += openTag('rect',
+        this.attributes(mdef.background, item),
+        styles(item, scene, 'bgrect', defs)) + closeTag('rect');
+      str += this.markGroup(item);
+    }
+    str += closeTag(tag);
+  }
+
+  // render closing group tag
+  return str + closeTag('g');
+};
+
+prototype.markGroup = function(scene) {
+  var str = '',
+      axes = scene.axisItems || [],
+      items = scene.items || [],
+      legends = scene.legendItems || [],
+      j, m;
+
+  for (j=0, m=axes.length; j<m; ++j) {
+    if (axes[j].layer === 'back') {
+      str += this.mark(axes[j]);
+    }
+  }
+  for (j=0, m=items.length; j<m; ++j) {
+    str += this.mark(items[j]);
+  }
+  for (j=0, m=axes.length; j<m; ++j) {
+    if (axes[j].layer !== 'back') {
+      str += this.mark(axes[j]);
+    }
+  }
+  for (j=0, m=legends.length; j<m; ++j) {
+    str += this.mark(legends[j]);
+  }
+
+  return str;
+};
+
+function styles(o, mark, tag, defs) {
+  if (o == null) return '';
+  var i, n, prop, name, value, s = '';
+
+  if (tag === 'bgrect' && mark.interactive === false) {
+    s += 'pointer-events: none;';
+  }
+
+  if (tag === 'text') {
+    s += 'font: ' + text.font(o) + ';';
+  }
+
+  for (i=0, n=SVG.styleProperties.length; i<n; ++i) {
+    prop = SVG.styleProperties[i];
+    name = SVG.styles[prop];
+    value = o[prop];
+
+    if (value == null) {
+      if (name === 'fill') {
+        s += (s.length ? ' ' : '') + 'fill: none;';
+      }
+    } else {
+      if (value.id) {
+        // ensure definition is included
+        defs.gradient[value.id] = value;
+        value = 'url(#' + value.id + ')';
+      }
+      s += (s.length ? ' ' : '') + name + ': ' + value + ';';
+    }
+  }
+
+  return s ? 'style="' + s + '"' : null;
+}
+
+function escape_text(s) {
+  return s.replace(/&/g, '&amp;')
+          .replace(/</g, '&lt;')
+          .replace(/>/g, '&gt;');
+}
+
+module.exports = SVGStringRenderer;
+
+},{"../../util/ImageLoader":77,"../../util/dom":81,"../../util/svg":83,"../../util/text":84,"../Renderer":52,"./marks":73}],72:[function(require,module,exports){
+module.exports = {
+  Handler:  require('./SVGHandler'),
+  Renderer: require('./SVGRenderer'),
+  string: {
+    Renderer : require('./SVGStringRenderer')
+  }
+};
+},{"./SVGHandler":69,"./SVGRenderer":70,"./SVGStringRenderer":71}],73:[function(require,module,exports){
+var text = require('../../util/text'),
+    SVG = require('../../util/svg'),
+    textAlign = SVG.textAlign,
+    path = SVG.path;
+
+function translateItem(o) {
+  return translate(o.x || 0, o.y || 0);
+}
+
+function translate(x, y) {
+  return 'translate(' + x + ',' + y + ')';
+}
+
+module.exports = {
+  arc: {
+    tag:  'path',
+    type: 'arc',
+    attr: function(emit, o) {
+      emit('transform', translateItem(o));
+      emit('d', path.arc(o));
+    }
+  },
+  area: {
+    tag:  'path',
+    type: 'area',
+    nest: true,
+    attr: function(emit, o) {
+      var items = o.mark.items;
+      if (items.length) emit('d', path.area(items));
+    }
+  },
+  group: {
+    tag:  'g',
+    type: 'group',
+    attr: function(emit, o, renderer) {
+      var id = null, defs, c;
+      emit('transform', translateItem(o));
+      if (o.clip) {
+        defs = renderer._defs;
+        id = o.clip_id || (o.clip_id = 'clip' + defs.clip_id++);
+        c = defs.clipping[id] || (defs.clipping[id] = {id: id});
+        c.width = o.width || 0;
+        c.height = o.height || 0;
+      }
+      emit('clip-path', id ? ('url(#' + id + ')') : null);
+    },
+    background: function(emit, o) {
+      emit('class', 'background');
+      emit('width', o.width || 0);
+      emit('height', o.height || 0);
+    }
+  },
+  image: {
+    tag:  'image',
+    type: 'image',
+    attr: function(emit, o, renderer) {
+      var x = o.x || 0,
+          y = o.y || 0,
+          w = o.width || 0,
+          h = o.height || 0,
+          url = renderer.imageURL(o.url);
+
+      x = x - (o.align === 'center' ? w/2 : o.align === 'right' ? w : 0);
+      y = y - (o.baseline === 'middle' ? h/2 : o.baseline === 'bottom' ? h : 0);
+
+      emit('href', url, 'http://www.w3.org/1999/xlink', 'xlink:href');
+      emit('transform', translate(x, y));
+      emit('width', w);
+      emit('height', h);
+    }
+  },
+  line: {
+    tag:  'path',
+    type: 'line',
+    nest: true,
+    attr: function(emit, o) {
+      var items = o.mark.items;
+      if (items.length) emit('d', path.line(items));
+    }
+  },
+  path: {
+    tag:  'path',
+    type: 'path',
+    attr: function(emit, o) {
+      emit('transform', translateItem(o));
+      emit('d', o.path);
+    }
+  },
+  rect: {
+    tag:  'rect',
+    type: 'rect',
+    nest: false,
+    attr: function(emit, o) {
+      emit('transform', translateItem(o));
+      emit('width', o.width || 0);
+      emit('height', o.height || 0);
+    }
+  },
+  rule: {
+    tag:  'line',
+    type: 'rule',
+    attr: function(emit, o) {
+      emit('transform', translateItem(o));
+      emit('x2', o.x2 != null ? o.x2 - (o.x||0) : 0);
+      emit('y2', o.y2 != null ? o.y2 - (o.y||0) : 0);
+    }
+  },
+  symbol: {
+    tag:  'path',
+    type: 'symbol',
+    attr: function(emit, o) {
+      emit('transform', translateItem(o));
+      emit('d', path.symbol(o));
+    }
+  },
+  text: {
+    tag:  'text',
+    type: 'text',
+    nest: false,
+    attr: function(emit, o) {
+      var dx = (o.dx || 0),
+          dy = (o.dy || 0) + text.offset(o),
+          x = (o.x || 0),
+          y = (o.y || 0),
+          a = o.angle || 0,
+          r = o.radius || 0, t;
+
+      if (r) {
+        t = (o.theta || 0) - Math.PI/2;
+        x += r * Math.cos(t);
+        y += r * Math.sin(t);
+      }
+
+      emit('text-anchor', textAlign[o.align] || 'start');
+      
+      if (a) {
+        t = translate(x, y) + ' rotate('+a+')';
+        if (dx || dy) t += ' ' + translate(dx, dy);
+      } else {
+        t = translate(x+dx, y+dy);
+      }
+      emit('transform', t);
+    }
+  }
+};
+
+},{"../../util/svg":83,"../../util/text":84}],74:[function(require,module,exports){
+function Bounds(b) {
+  this.clear();
+  if (b) this.union(b);
+}
+
+var prototype = Bounds.prototype;
+
+prototype.clone = function() {
+  return new Bounds(this);
+};
+
+prototype.clear = function() {
+  this.x1 = +Number.MAX_VALUE;
+  this.y1 = +Number.MAX_VALUE;
+  this.x2 = -Number.MAX_VALUE;
+  this.y2 = -Number.MAX_VALUE;
+  return this;
+};
+
+prototype.set = function(x1, y1, x2, y2) {
+  this.x1 = x1;
+  this.y1 = y1;
+  this.x2 = x2;
+  this.y2 = y2;
+  return this;
+};
+
+prototype.add = function(x, y) {
+  if (x < this.x1) this.x1 = x;
+  if (y < this.y1) this.y1 = y;
+  if (x > this.x2) this.x2 = x;
+  if (y > this.y2) this.y2 = y;
+  return this;
+};
+
+prototype.expand = function(d) {
+  this.x1 -= d;
+  this.y1 -= d;
+  this.x2 += d;
+  this.y2 += d;
+  return this;
+};
+
+prototype.round = function() {
+  this.x1 = Math.floor(this.x1);
+  this.y1 = Math.floor(this.y1);
+  this.x2 = Math.ceil(this.x2);
+  this.y2 = Math.ceil(this.y2);
+  return this;
+};
+
+prototype.translate = function(dx, dy) {
+  this.x1 += dx;
+  this.x2 += dx;
+  this.y1 += dy;
+  this.y2 += dy;
+  return this;
+};
+
+prototype.rotate = function(angle, x, y) {
+  var cos = Math.cos(angle),
+      sin = Math.sin(angle),
+      cx = x - x*cos + y*sin,
+      cy = y - x*sin - y*cos,
+      x1 = this.x1, x2 = this.x2,
+      y1 = this.y1, y2 = this.y2;
+
+  return this.clear()
+    .add(cos*x1 - sin*y1 + cx,  sin*x1 + cos*y1 + cy)
+    .add(cos*x1 - sin*y2 + cx,  sin*x1 + cos*y2 + cy)
+    .add(cos*x2 - sin*y1 + cx,  sin*x2 + cos*y1 + cy)
+    .add(cos*x2 - sin*y2 + cx,  sin*x2 + cos*y2 + cy);
+};
+
+prototype.union = function(b) {
+  if (b.x1 < this.x1) this.x1 = b.x1;
+  if (b.y1 < this.y1) this.y1 = b.y1;
+  if (b.x2 > this.x2) this.x2 = b.x2;
+  if (b.y2 > this.y2) this.y2 = b.y2;
+  return this;
+};
+
+prototype.encloses = function(b) {
+  return b && (
+    this.x1 <= b.x1 &&
+    this.x2 >= b.x2 &&
+    this.y1 <= b.y1 &&
+    this.y2 >= b.y2
+  );
+};
+
+prototype.intersects = function(b) {
+  return b && !(
+    this.x2 < b.x1 ||
+    this.x1 > b.x2 ||
+    this.y2 < b.y1 ||
+    this.y1 > b.y2
+  );
+};
+
+prototype.contains = function(x, y) {
+  return !(
+    x < this.x1 ||
+    x > this.x2 ||
+    y < this.y1 ||
+    y > this.y2
+  );
+};
+
+prototype.width = function() {
+  return this.x2 - this.x1;
+};
+
+prototype.height = function() {
+  return this.y2 - this.y1;
+};
+
+module.exports = Bounds;
+
+},{}],75:[function(require,module,exports){
+module.exports = function(b) {
+  function noop() { }
+  function add(x,y) { b.add(x, y); }
+
+  return {
+    bounds: function(_) {
+      if (!arguments.length) return b;
+      return (b = _, this);
+    },
+    beginPath: noop,
+    closePath: noop,
+    moveTo: add,
+    lineTo: add,
+    quadraticCurveTo: function(x1, y1, x2, y2) {
+      b.add(x1, y1);
+      b.add(x2, y2);
+    },
+    bezierCurveTo: function(x1, y1, x2, y2, x3, y3) {
+      b.add(x1, y1);
+      b.add(x2, y2);
+      b.add(x3, y3);
+    }
+  };
+};
+
+},{}],76:[function(require,module,exports){
+var gradient_id = 0;
+
+function Gradient(type) {
+  this.id = 'gradient_' + (gradient_id++);
+  this.type = type || 'linear';
+  this.stops = [];
+  this.x1 = 0;
+  this.x2 = 1;
+  this.y1 = 0;
+  this.y2 = 0;
+}
+
+var prototype = Gradient.prototype;
+
+prototype.stop = function(offset, color) {
+  this.stops.push({
+    offset: offset,
+    color: color
+  });
+  return this;
+};
+
+module.exports = Gradient;
+},{}],77:[function(require,module,exports){
+(function (global){
+var load = require('datalib/src/import/load');
+
+function ImageLoader(loadConfig) {
+  this._pending = 0;
+  this._config = loadConfig || ImageLoader.Config; 
+}
+
+// Overridable global default load configuration
+ImageLoader.Config = null;
+
+var prototype = ImageLoader.prototype;
+
+prototype.pending = function() {
+  return this._pending;
+};
+
+prototype.params = function(uri) {
+  var p = {url: uri}, k;
+  for (k in this._config) { p[k] = this._config[k]; }
+  return p;
+};
+
+prototype.imageURL = function(uri) {
+  return load.sanitizeUrl(this.params(uri));
+};
+
+function browser(uri, callback) {
+  var url = load.sanitizeUrl(this.params(uri));
+  if (!url) { // error
+    if (callback) callback(uri, null);
+    return null;
+  }
+
+  var loader = this,
+      image = new Image();
+
+  loader._pending += 1;
+
+  image.onload = function() {
+    loader._pending -= 1;
+    image.loaded = true;
+    if (callback) callback(null, image);
+  };
+  image.src = url;
+
+  return image;
+}
+
+function server(uri, callback) {
+  var loader = this,
+      image = new ((typeof window !== "undefined" ? window['canvas'] : typeof global !== "undefined" ? global['canvas'] : null).Image)();
+
+  loader._pending += 1;
+
+  load(this.params(uri), function(err, data) {
+    loader._pending -= 1;
+    if (err) {
+      if (callback) callback(err, null);
+      return null;
+    }
+    image.src = data;
+    image.loaded = true;
+    if (callback) callback(null, image);
+  });
+
+  return image;
+}
+
+prototype.loadImage = function(uri, callback) {
+  return load.useXHR ?
+    browser.call(this, uri, callback) :
+    server.call(this, uri, callback);
+};
+
+module.exports = ImageLoader;
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{"datalib/src/import/load":20}],78:[function(require,module,exports){
+function Item(mark) {
+  this.mark = mark;
+}
+
+var prototype = Item.prototype;
+
+prototype.hasPropertySet = function(name) {
+  var props = this.mark.def.properties;
+  return props && props[name] != null;
+};
+
+prototype.cousin = function(offset, index) {
+  if (offset === 0) return this;
+  offset = offset || -1;
+  var mark = this.mark,
+      group = mark.group,
+      iidx = index==null ? mark.items.indexOf(this) : index,
+      midx = group.items.indexOf(mark) + offset;
+  return group.items[midx].items[iidx];
+};
+
+prototype.sibling = function(offset) {
+  if (offset === 0) return this;
+  offset = offset || -1;
+  var mark = this.mark,
+      iidx = mark.items.indexOf(this) + offset;
+  return mark.items[iidx];
+};
+
+prototype.remove = function() {
+  var item = this,
+      list = item.mark.items,
+      i = list.indexOf(item);
+  if (i >= 0) {
+    if (i===list.length-1) {
+      list.pop();
+    } else {
+      list.splice(i, 1);
+    }
+  }
+  return item;
+};
+
+prototype.touch = function() {
+  if (this.pathCache) this.pathCache = null;
+};
+
+module.exports = Item;
+},{}],79:[function(require,module,exports){
+var BoundsContext = require('./BoundsContext'),
+    Bounds = require('./Bounds'),
+    canvas = require('./canvas'),
+    svg = require('./svg'),
+    text = require('./text'),
+    paths = require('../path'),
+    parse = paths.parse,
+    drawPath = paths.render,
+    areaPath = svg.path.area,
+    linePath = svg.path.line,
+    halfpi = Math.PI / 2,
+    sqrt3 = Math.sqrt(3),
+    tan30 = Math.tan(30 * Math.PI / 180),
+    g2D = null,
+    bc = BoundsContext();
+
+function context() {
+  return g2D || (g2D = canvas.instance(1,1).getContext('2d'));
+}
+
+function strokeBounds(o, bounds) {
+  if (o.stroke && o.opacity !== 0 && o.stokeOpacity !== 0) {
+    bounds.expand(o.strokeWidth != null ? o.strokeWidth : 1);
+  }
+  return bounds;
+}
+
+function pathBounds(o, path, bounds, x, y) {
+  if (path == null) {
+    bounds.set(0, 0, 0, 0);
+  } else {
+    drawPath(bc.bounds(bounds), path, x, y);
+    strokeBounds(o, bounds);
+  }
+  return bounds;
+}
+
+function path(o, bounds) {
+  var p = o.path ? o.pathCache || (o.pathCache = parse(o.path)) : null;
+  return pathBounds(o, p, bounds, o.x, o.y);
+}
+
+function area(mark, bounds) {
+  if (mark.items.length === 0) return bounds;
+  var items = mark.items,
+      item = items[0],
+      p = item.pathCache || (item.pathCache = parse(areaPath(items)));
+  return pathBounds(item, p, bounds);
+}
+
+function line(mark, bounds) {
+  if (mark.items.length === 0) return bounds;
+  var items = mark.items,
+      item = items[0],
+      p = item.pathCache || (item.pathCache = parse(linePath(items)));
+  return pathBounds(item, p, bounds);
+}
+
+function rect(o, bounds) {
+  var x, y;
+  return strokeBounds(o, bounds.set(
+    x = o.x || 0,
+    y = o.y || 0,
+    (x + o.width) || 0,
+    (y + o.height) || 0
+  ));
+}
+
+function image(o, bounds) {
+  var x = o.x || 0,
+      y = o.y || 0,
+      w = o.width || 0,
+      h = o.height || 0;
+  x = x - (o.align === 'center' ? w/2 : (o.align === 'right' ? w : 0));
+  y = y - (o.baseline === 'middle' ? h/2 : (o.baseline === 'bottom' ? h : 0));
+  return bounds.set(x, y, x+w, y+h);
+}
+
+function rule(o, bounds) {
+  var x1, y1;
+  return strokeBounds(o, bounds.set(
+    x1 = o.x || 0,
+    y1 = o.y || 0,
+    o.x2 != null ? o.x2 : x1,
+    o.y2 != null ? o.y2 : y1
+  ));
+}
+
+function arc(o, bounds) {
+  var cx = o.x || 0,
+      cy = o.y || 0,
+      ir = o.innerRadius || 0,
+      or = o.outerRadius || 0,
+      sa = (o.startAngle || 0) - halfpi,
+      ea = (o.endAngle || 0) - halfpi,
+      xmin = Infinity, xmax = -Infinity,
+      ymin = Infinity, ymax = -Infinity,
+      a, i, n, x, y, ix, iy, ox, oy;
+
+  var angles = [sa, ea],
+      s = sa - (sa % halfpi);
+  for (i=0; i<4 && s<ea; ++i, s+=halfpi) {
+    angles.push(s);
+  }
+
+  for (i=0, n=angles.length; i<n; ++i) {
+    a = angles[i];
+    x = Math.cos(a); ix = ir*x; ox = or*x;
+    y = Math.sin(a); iy = ir*y; oy = or*y;
+    xmin = Math.min(xmin, ix, ox);
+    xmax = Math.max(xmax, ix, ox);
+    ymin = Math.min(ymin, iy, oy);
+    ymax = Math.max(ymax, iy, oy);
+  }
+
+  return strokeBounds(o, bounds.set(
+    cx + xmin,
+    cy + ymin,
+    cx + xmax,
+    cy + ymax
+  ));
+}
+
+function symbol(o, bounds) {
+  var size = o.size != null ? o.size : 100,
+      x = o.x || 0,
+      y = o.y || 0,
+      r, t, rx, ry;
+
+  switch (o.shape) {
+    case 'cross':
+      t = 3 * Math.sqrt(size / 5) / 2;
+      bounds.set(x-t, y-t, x+t, y+t);
+      break;
+
+    case 'diamond':
+      ry = Math.sqrt(size / (2 * tan30));
+      rx = ry * tan30;
+      bounds.set(x-rx, y-ry, x+rx, y+ry);
+      break;
+
+    case 'square':
+      t = Math.sqrt(size);
+      r = t / 2;
+      bounds.set(x-r, y-r, x+r, y+r);
+      break;
+
+    case 'triangle-down':
+      rx = Math.sqrt(size / sqrt3);
+      ry = rx * sqrt3 / 2;
+      bounds.set(x-rx, y-ry, x+rx, y+ry);
+      break;
+
+    case 'triangle-up':
+      rx = Math.sqrt(size / sqrt3);
+      ry = rx * sqrt3 / 2;
+      bounds.set(x-rx, y-ry, x+rx, y+ry);
+      break;
+
+    default:
+      r = Math.sqrt(size/Math.PI);
+      bounds.set(x-r, y-r, x+r, y+r);
+  }
+
+  return strokeBounds(o, bounds);
+}
+
+function textMark(o, bounds, noRotate) {
+  var g = context(),
+      h = text.size(o),
+      a = o.align,
+      r = o.radius || 0,
+      x = (o.x || 0),
+      y = (o.y || 0),
+      dx = (o.dx || 0),
+      dy = (o.dy || 0) + text.offset(o) - Math.round(0.8*h), // use 4/5 offset
+      w, t;
+
+  if (r) {
+    t = (o.theta || 0) - Math.PI/2;
+    x += r * Math.cos(t);
+    y += r * Math.sin(t);
+  }
+
+  // horizontal alignment
+  g.font = text.font(o);
+  w = g.measureText(text.value(o.text)).width;
+  if (a === 'center') {
+    dx -= (w / 2);
+  } else if (a === 'right') {
+    dx -= w;
+  } else {
+    // left by default, do nothing
+  }
+
+  bounds.set(dx+=x, dy+=y, dx+w, dy+h);
+  if (o.angle && !noRotate) {
+    bounds.rotate(o.angle*Math.PI/180, x, y);
+  }
+  return bounds.expand(noRotate ? 0 : 1);
+}
+
+function group(g, bounds, includeLegends) {
+  var axes = g.axisItems || [],
+      items = g.items || [],
+      legends = g.legendItems || [],
+      j, m;
+
+  for (j=0, m=axes.length; j<m; ++j) {
+    bounds.union(axes[j].bounds);
+  }
+  for (j=0, m=items.length; j<m; ++j) {
+    bounds.union(items[j].bounds);
+  }
+  if (includeLegends) {
+    for (j=0, m=legends.length; j<m; ++j) {
+      bounds.union(legends[j].bounds);
+    }
+  }
+  if (g.width || g.height) {
+    strokeBounds(g, bounds
+      .add(0, 0)
+      .add(g.width || 0, g.height || 0));
+  }
+  return bounds.translate(g.x || 0, g.y || 0);
+}
+
+var methods = {
+  group:  group,
+  symbol: symbol,
+  image:  image,
+  rect:   rect,
+  rule:   rule,
+  arc:    arc,
+  text:   textMark,
+  path:   path,
+  area:   area,
+  line:   line
+};
+methods.area.nest = true;
+methods.line.nest = true;
+
+function itemBounds(item, func, opt) {
+  var type = item.mark.marktype;
+  func = func || methods[type];
+  if (func.nest) item = item.mark;
+
+  var curr = item.bounds,
+      prev = item['bounds:prev'] || (item['bounds:prev'] = new Bounds());
+
+  if (curr) {
+    prev.clear().union(curr);
+    curr.clear();
+  } else {
+    item.bounds = new Bounds();
+  }
+  func(item, item.bounds, opt);
+  if (!curr) prev.clear().union(item.bounds);
+  return item.bounds;
+}
+
+var DUMMY_ITEM = {mark: null};
+
+function markBounds(mark, bounds, opt) {
+  var type  = mark.marktype,
+      func  = methods[type],
+      items = mark.items,
+      hasi  = items && items.length,
+      i, n, o, b;
+
+  if (func.nest) {
+    o = hasi ? items[0]
+      : (DUMMY_ITEM.mark = mark, DUMMY_ITEM); // no items, so fake it
+    b = itemBounds(o, func, opt);
+    bounds = bounds && bounds.union(b) || b;
+    return bounds;
+  }
+
+  bounds = bounds || mark.bounds && mark.bounds.clear() || new Bounds();
+  if (hasi) {  
+    for (i=0, n=items.length; i<n; ++i) {
+      bounds.union(itemBounds(items[i], func, opt));
+    }
+  }
+  return (mark.bounds = bounds);
+}
+
+module.exports = {
+  mark:  markBounds,
+  item:  itemBounds,
+  text:  textMark,
+  group: group
+};
+
+},{"../path":48,"./Bounds":74,"./BoundsContext":75,"./canvas":80,"./svg":83,"./text":84}],80:[function(require,module,exports){
+(function (global){
+function instance(w, h) {
+  w = w || 1;
+  h = h || 1;
+  var canvas;
+
+  if (typeof document !== 'undefined' && document.createElement) {
+    canvas = document.createElement('canvas');
+    canvas.width = w;
+    canvas.height = h;
+  } else {
+    var Canvas = (typeof window !== "undefined" ? window['canvas'] : typeof global !== "undefined" ? global['canvas'] : null);
+    if (!Canvas.prototype) return null;
+    canvas = new Canvas(w, h);
+  }
+  return lineDash(canvas);
+}
+
+function resize(canvas, w, h, p, retina) {
+  var g = this._ctx = canvas.getContext('2d'), 
+      s = 1;
+
+  canvas.width = w + p.left + p.right;
+  canvas.height = h + p.top + p.bottom;
+
+  // if browser canvas, attempt to modify for retina display
+  if (retina && typeof HTMLElement !== 'undefined' &&
+      canvas instanceof HTMLElement)
+  {
+    g.pixelratio = (s = pixelRatio(canvas) || 1);
+  }
+
+  g.setTransform(s, 0, 0, s, s*p.left, s*p.top);
+  return canvas;
+}
+
+function pixelRatio(canvas) {
+  var g = canvas.getContext('2d');
+
+  // get canvas pixel data
+  var devicePixelRatio = window && window.devicePixelRatio || 1,
+      backingStoreRatio = (
+        g.webkitBackingStorePixelRatio ||
+        g.mozBackingStorePixelRatio ||
+        g.msBackingStorePixelRatio ||
+        g.oBackingStorePixelRatio ||
+        g.backingStorePixelRatio) || 1,
+      ratio = devicePixelRatio / backingStoreRatio;
+
+  if (devicePixelRatio !== backingStoreRatio) {
+    // set actual and visible canvas size
+    var w = canvas.width,
+        h = canvas.height;
+    canvas.width = w * ratio;
+    canvas.height = h * ratio;
+    canvas.style.width = w + 'px';
+    canvas.style.height = h + 'px';
+  }
+
+  return ratio;
+}
+
+function lineDash(canvas) {
+  var g = canvas.getContext('2d');
+  if (g.vgLineDash) return; // already initialized!
+
+  var NOOP = function() {},
+      NODASH = [];
+  
+  if (g.setLineDash) {
+    g.vgLineDash = function(dash) { this.setLineDash(dash || NODASH); };
+    g.vgLineDashOffset = function(off) { this.lineDashOffset = off; };
+  } else if (g.webkitLineDash !== undefined) {
+  	g.vgLineDash = function(dash) { this.webkitLineDash = dash || NODASH; };
+    g.vgLineDashOffset = function(off) { this.webkitLineDashOffset = off; };
+  } else if (g.mozDash !== undefined) {
+    g.vgLineDash = function(dash) { this.mozDash = dash; };
+    g.vgLineDashOffset = NOOP;
+  } else {
+    g.vgLineDash = NOOP;
+    g.vgLineDashOffset = NOOP;
+  }
+  return canvas;
+}
+
+module.exports = {
+  instance:   instance,
+  resize:     resize,
+  lineDash:   lineDash
+};
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{}],81:[function(require,module,exports){
+// create a new DOM element
+function create(doc, tag, ns) {
+  return ns ? doc.createElementNS(ns, tag) : doc.createElement(tag);
+}
+
+// remove element from DOM
+// recursively remove parent elements if empty
+function remove(el) {
+  if (!el) return;
+  var p = el.parentNode;
+  if (p) {
+    p.removeChild(el);
+    if (!p.childNodes || !p.childNodes.length) remove(p);
+  }
+}
+
+module.exports = {
+  // find first child element with matching tag
+  find: function(el, tag) {
+    tag = tag.toLowerCase();
+    for (var i=0, n=el.childNodes.length; i<n; ++i) {
+      if (el.childNodes[i].tagName.toLowerCase() === tag) {
+        return el.childNodes[i];
+      }
+    }
+  },
+  // retrieve child element at given index
+  // create & insert if doesn't exist or if tag/className do not match
+  child: function(el, index, tag, ns, className, insert) {
+    var a, b;
+    a = b = el.childNodes[index];
+    if (!a || insert ||
+        a.tagName.toLowerCase() !== tag.toLowerCase() ||
+        className && a.getAttribute('class') != className) {
+      a = create(el.ownerDocument, tag, ns);
+      el.insertBefore(a, b);
+      if (className) a.setAttribute('class', className);
+    }
+    return a;
+  },
+  // remove all child elements at or above the given index
+  clear: function(el, index) {
+    var curr = el.childNodes.length;
+    while (curr > index) {
+      el.removeChild(el.childNodes[--curr]);
+    }
+    return el;
+  },
+  remove: remove,
+  // generate css class name for mark
+  cssClass: function(mark) {
+    return 'mark-' + mark.marktype + (mark.name ? ' '+mark.name : '');
+  },
+  // generate string for an opening xml tag
+  // tag: the name of the xml tag
+  // attr: hash of attribute name-value pairs to include
+  // raw: additional raw string to include in tag markup
+  openTag: function(tag, attr, raw) {
+    var s = '<' + tag, key, val;
+    if (attr) {
+      for (key in attr) {
+        val = attr[key];
+        if (val != null) {
+          s += ' ' + key + '="' + val + '"';
+        }
+      }
+    }
+    if (raw) s += ' ' + raw;
+    return s + '>';
+  },
+  // generate string for closing xml tag
+  // tag: the name of the xml tag
+  closeTag: function(tag) {
+    return '</' + tag + '>';
+  }
+};
+
+},{}],82:[function(require,module,exports){
+var bound = require('../util/bound');
+
+var sets = [
+  'items',
+  'axisItems',
+  'legendItems'
+];
+
+var keys = [
+  'marktype', 'name', 'interactive', 'clip',
+  'items', 'axisItems', 'legendItems', 'layer',
+  'x', 'y', 'width', 'height', 'align', 'baseline',             // layout
+  'fill', 'fillOpacity', 'opacity',                             // fill
+  'stroke', 'strokeOpacity', 'strokeWidth', 'strokeCap',        // stroke
+  'strokeDash', 'strokeDashOffset',                             // stroke dash
+  'startAngle', 'endAngle', 'innerRadius', 'outerRadius',       // arc
+  'interpolate', 'tension', 'orient',                           // area, line
+  'url',                                                        // image
+  'path',                                                       // path
+  'x2', 'y2',                                                   // rule
+  'size', 'shape',                                              // symbol
+  'text', 'angle', 'theta', 'radius', 'dx', 'dy',               // text
+  'font', 'fontSize', 'fontWeight', 'fontStyle', 'fontVariant'  // font
+];
+
+function toJSON(scene, indent) {
+  return JSON.stringify(scene, keys, indent);
+}
+
+function fromJSON(json) {
+  var scene = (typeof json === 'string' ? JSON.parse(json) : json);
+  return initialize(scene);
+}
+
+function initialize(scene) {
+  var type = scene.marktype,
+      i, n, s, m, items;
+
+  for (s=0, m=sets.length; s<m; ++s) {
+    if ((items = scene[sets[s]])) {
+      for (i=0, n=items.length; i<n; ++i) {
+        items[i][type ? 'mark' : 'group'] = scene;
+        if (!type || type === 'group') {
+          initialize(items[i]);
+        }
+      }
+    }
+  }
+
+  if (type) bound.mark(scene);
+  return scene;
+}
+
+module.exports = {
+  toJSON:   toJSON,
+  fromJSON: fromJSON
+};
+},{"../util/bound":79}],83:[function(require,module,exports){
+(function (global){
+var d3_svg = (typeof window !== "undefined" ? window['d3'] : typeof global !== "undefined" ? global['d3'] : null).svg;
+
+function x(o)     { return o.x || 0; }
+function y(o)     { return o.y || 0; }
+function xw(o)    { return (o.x || 0) + (o.width || 0); }
+function yh(o)    { return (o.y || 0) + (o.height || 0); }
+function size(o)  { return o.size == null ? 100 : o.size; }
+function shape(o) { return o.shape || 'circle'; }
+
+var areav = d3_svg.area().x(x).y1(y).y0(yh),
+    areah = d3_svg.area().y(y).x1(x).x0(xw),
+    line  = d3_svg.line().x(x).y(y);
+
+module.exports = {
+  metadata: {
+    'version': '1.1',
+    'xmlns': 'http://www.w3.org/2000/svg',
+    'xmlns:xlink': 'http://www.w3.org/1999/xlink'
+  },
+  path: {
+    arc: d3_svg.arc(),
+    symbol: d3_svg.symbol().type(shape).size(size),
+    area: function(items) {
+      var o = items[0];
+      return (o.orient === 'horizontal' ? areah : areav)
+        .interpolate(o.interpolate || 'linear')
+        .tension(o.tension || 0.7)
+        (items);
+    },
+    line: function(items) {
+      var o = items[0];
+      return line
+        .interpolate(o.interpolate || 'linear')
+        .tension(o.tension || 0.7)
+        (items);
+    }
+  },
+  textAlign: {
+    'left':   'start',
+    'center': 'middle',
+    'right':  'end'
+  },
+  textBaseline: {
+    'top':    'before-edge',
+    'bottom': 'after-edge',
+    'middle': 'central'
+  },
+  styles: {
+    'fill':             'fill',
+    'fillOpacity':      'fill-opacity',
+    'stroke':           'stroke',
+    'strokeWidth':      'stroke-width',
+    'strokeOpacity':    'stroke-opacity',
+    'strokeCap':        'stroke-linecap',
+    'strokeDash':       'stroke-dasharray',
+    'strokeDashOffset': 'stroke-dashoffset',
+    'opacity':          'opacity'
+  },
+  styleProperties: [
+    'fill',
+    'fillOpacity',
+    'stroke',
+    'strokeWidth',
+    'strokeOpacity',
+    'strokeCap',
+    'strokeDash',
+    'strokeDashOffset',
+    'opacity'
+  ]
+};
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{}],84:[function(require,module,exports){
+function size(item) {
+  return item.fontSize != null ? item.fontSize : 11;
+}
+
+module.exports = {
+  size: size,
+  value: function(s) {
+    return s != null ? String(s) : '';
+  },
+  font: function(item, quote) {
+    var font = item.font;
+    if (quote && font) {
+      font = String(font).replace(/\"/g, '\'');
+    }
+    return '' +
+      (item.fontStyle ? item.fontStyle + ' ' : '') +
+      (item.fontVariant ? item.fontVariant + ' ' : '') +
+      (item.fontWeight ? item.fontWeight + ' ' : '') +
+      size(item) + 'px ' +
+      (font || 'sans-serif');
+  },
+  offset: function(item) {
+    // perform our own font baseline calculation
+    // why? not all browsers support SVG 1.1 'alignment-baseline' :(
+    var baseline = item.baseline,
+        h = size(item);
+    return Math.round(
+      baseline === 'top'    ?  0.93*h :
+      baseline === 'middle' ?  0.30*h :
+      baseline === 'bottom' ? -0.21*h : 0
+    );
+  }
+};
+
+},{}],85:[function(require,module,exports){
+var sg = require('vega-scenegraph').render,
+    canvas = sg.canvas,
+    svg = sg.svg.string,
+    View = require('./View');
+
+function HeadlessView(width, height, model) {
+  View.call(null, width, height, model);
+  this._type = 'canvas';
+  this._renderers = {canvas: canvas, svg: svg};
+}
+
+var prototype = (HeadlessView.prototype = new View());
+
+prototype.renderer = function(type) {
+  if(type) this._type = type;
+  return View.prototype.renderer.apply(this, arguments);
+};
+
+prototype.canvas = function() {
+  return (this._type === 'canvas') ? this._renderer.canvas() : null;
+};
+
+prototype.canvasAsync = function(callback) {
+  var r = this._renderer, view = this;
+  
+  function wait() {
+    if (r.pendingImages() === 0) {
+      view.render(); // re-render with all images
+      callback(view.canvas());
+    } else {
+      setTimeout(wait, 10);
+    }
+  }
+
+  // if images loading, poll until ready
+  if (this._type !== 'canvas') return null;
+  if (r.pendingImages() > 0) { wait(); } else { callback(this.canvas()); }
+};
+
+prototype.svg = function() {
+  return (this._type === 'svg') ? this._renderer.svg() : null;
+};
+
+prototype.initialize = function() {    
+  var w = this._width,
+      h = this._height,
+      bg  = this._bgcolor,
+      pad = this._padding,
+      config = this.model().config();
+
+  if (this._viewport) {
+    w = this._viewport[0] - (pad ? pad.left + pad.right : 0);
+    h = this._viewport[1] - (pad ? pad.top + pad.bottom : 0);
+  }
+
+  this._renderer = (this._renderer || new this._io.Renderer(config.load))
+    .initialize(null, w, h, pad)
+    .background(bg);
+  
+  return this;
+};
+
+module.exports = HeadlessView;
+},{"./View":87,"vega-scenegraph":46}],86:[function(require,module,exports){
+var dl = require('datalib'),
+    df = require('vega-dataflow'),
+    ChangeSet = df.ChangeSet,
+    Base = df.Graph.prototype,
+    Node  = df.Node, // jshint ignore:line
+    GroupBuilder = require('../scene/GroupBuilder'),
+    visit = require('../scene/visit'),
+    config = require('./config');
+
+function Model(cfg) {
+  this._defs = {};
+  this._predicates = {};
+  this._scene = null;
+
+  this._node = null;
+  this._builder = null; // Top-level scenegraph builder
+
+  this._reset = {axes: false, legends: false};
+
+  this.config(cfg);
+  Base.init.call(this);
+}
+
+var prototype = (Model.prototype = Object.create(Base));
+prototype.constructor = Model;
+
+prototype.defs = function(defs) {
+  if (!arguments.length) return this._defs;
+  this._defs = defs;
+  return this;
+};
+
+prototype.config = function(cfg) {
+  if (!arguments.length) return this._config;
+  this._config = Object.create(config);
+  for (var name in cfg) {
+    var x = cfg[name], y = this._config[name];
+    if (dl.isObject(x) && dl.isObject(y)) {
+      dl.extend(y, x);
+    } else {
+      this._config[name] = x;
+    }
+  }
+
+  return this;
+};
+
+prototype.width = function(width) {
+  if (this._defs) this._defs.width = width;
+  if (this._defs && this._defs.marks) this._defs.marks.width = width;
+  if (this._scene) {
+    this._scene.items[0].width = width;
+    this._scene.items[0]._dirty = true;
+  }
+  this._reset.axes = true;
+  return this;
+};
+
+prototype.height = function(height) {
+  if (this._defs) this._defs.height = height;
+  if (this._defs && this._defs.marks) this._defs.marks.height = height;
+  if (this._scene) {
+    this._scene.items[0].height = height;
+    this._scene.items[0]._dirty = true;
+  }
+  this._reset.axes = true;
+  return this;
+};
+
+prototype.node = function() {
+  return this._node || (this._node = new Node(this));
+};
+
+prototype.data = function() {
+  var data = Base.data.apply(this, arguments);
+  if (arguments.length > 1) {  // new Datasource
+    this.node().addListener(data.pipeline()[0]);
+  }
+  return data;
+};
+
+function predicates(name) {
+  var m = this, pred = {};
+  if (!dl.isArray(name)) return this._predicates[name];
+  name.forEach(function(n) { pred[n] = m._predicates[n]; });
+  return pred;
+}
+
+prototype.predicate = function(name, predicate) {
+  if (arguments.length === 1) return predicates.call(this, name);
+  return (this._predicates[name] = predicate);
+};
+
+prototype.predicates = function() { return this._predicates; };
+
+prototype.scene = function(renderer) {
+  if (!arguments.length) return this._scene;
+  if (this._builder) this.node().removeListener(this._builder.disconnect());
+  this._builder = new GroupBuilder(this, this._defs.marks, this._scene={});
+  this.node().addListener(this._builder.connect());
+  var p = this._builder.pipeline();
+  p[p.length-1].addListener(renderer);
+  return this;
+};
+
+prototype.reset = function() {
+  if (this._scene && this._reset.axes) {
+    visit(this._scene, function(item) {
+      if (item.axes) item.axes.forEach(function(axis) { axis.reset(); });
+    });
+    this._reset.axes = false;
+  }
+  if (this._scene && this._reset.legends) {
+    visit(this._scene, function(item) {
+      if (item.legends) item.legends.forEach(function(l) { l.reset(); });
+    });
+    this._reset.legends = false;
+  }
+  return this;
+};
+
+prototype.addListener = function(l) {
+  this.node().addListener(l);
+};
+
+prototype.removeListener = function(l) {
+  this.node().removeListener(l); 
+};
+
+prototype.fire = function(cs) {
+  if (!cs) cs = ChangeSet.create();
+  this.propagate(cs, this.node());
+};
+
+module.exports = Model;
+},{"../scene/GroupBuilder":110,"../scene/visit":115,"./config":88,"datalib":24,"vega-dataflow":39}],87:[function(require,module,exports){
+(function (global){
+var d3 = (typeof window !== "undefined" ? window['d3'] : typeof global !== "undefined" ? global['d3'] : null),
+    dl = require('datalib'),
+    df = require('vega-dataflow'),
+    sg = require('vega-scenegraph').render,
+    log = require('vega-logging'),
+    Deps = df.Dependencies,
+    parseStreams = require('../parse/streams'),
+    Encoder = require('../scene/Encoder'),
+    Transition = require('../scene/Transition');
+
+function View(el, width, height) {
+  this._el    = null;
+  this._model = null;
+  this._width = this.__width = width || 500;
+  this._height  = this.__height = height || 300;
+  this._bgcolor = null;
+  this._autopad = 1;
+  this._padding = {top:0, left:0, bottom:0, right:0};
+  this._viewport = null;
+  this._renderer = null;
+  this._handler  = null;
+  this._streamer = null; // Targeted update for streaming changes
+  this._changeset = null;
+  this._repaint = true; // Full re-render on every re-init
+  this._renderers = sg;
+  this._io  = null;
+  this._api = {}; // Stash streaming data API sandboxes.
+}
+
+var prototype = View.prototype;
+
+prototype.model = function(model) {
+  if (!arguments.length) return this._model;
+  if (this._model !== model) {
+    this._model = model;
+    this._streamer = new df.Node(model);
+    this._streamer._rank = -1;  // HACK: To reduce re-ranking churn.
+    this._changeset = df.ChangeSet.create();
+    if (this._handler) this._handler.model(model);
+  }
+  return this;
+};
+
+// Sandboxed streaming data API
+function streaming(src) {
+  var view = this,
+      ds = this._model.data(src),
+      name = ds.name(),
+      listener = ds.pipeline()[0],
+      streamer = this._streamer,
+      api = {};
+
+  // If we have it stashed, don't create a new closure. 
+  if (this._api[src]) return this._api[src];
+
+  api.insert = function(vals) {
+    ds.insert(dl.duplicate(vals));  // Don't pollute the environment
+    streamer.addListener(listener);
+    view._changeset.data[name] = 1;
+    return api;
+  };
+
+  api.update = function() {
+    streamer.addListener(listener);
+    view._changeset.data[name] = 1;
+    return (ds.update.apply(ds, arguments), api);
+  };
+
+  api.remove = function() {
+    streamer.addListener(listener);
+    view._changeset.data[name] = 1;
+    return (ds.remove.apply(ds, arguments), api);
+  };
+
+  api.values = function() { return ds.values(); };    
+
+  return (this._api[src] = api);
+}
+
+prototype.data = function(data) {
+  var v = this;
+  if (!arguments.length) return v._model.values();
+  else if (dl.isString(data)) return streaming.call(v, data);
+  else if (dl.isObject(data)) {
+    dl.keys(data).forEach(function(k) {
+      var api = streaming.call(v, k);
+      data[k](api);
+    });
+  }
+  return this;
+};
+
+prototype.signal = function(name, value) {
+  var m  = this._model,
+      cs = this._changeset,
+      streamer = this._streamer,
+      setter = name; 
+
+  if (!arguments.length) {
+    return m.values(Deps.SIGNALS);
+  } else if (arguments.length == 1 && dl.isString(name)) {
+    return m.values(Deps.SIGNALS, name);
+  }
+
+  if (arguments.length == 2) {
+    setter = {};
+    setter[name] = value;
+  }
+
+  dl.keys(setter).forEach(function(k) {
+    streamer.addListener(m.signal(k).value(setter[k]));
+    cs.signals[k] = 1;
+    cs.reflow = true;
+  });
+
+  return this;
+};
+
+prototype.width = function(width) {
+  if (!arguments.length) return this.__width;
+  if (this.__width !== width) {
+    this._width = this.__width = width;
+    this.model().width(width);
+    this.initialize();
+    if (this._strict) this._autopad = 1;
+  }
+  return this;
+};
+
+prototype.height = function(height) {
+  if (!arguments.length) return this.__height;
+  if (this.__height !== height) {
+    this._height = this.__height = height;
+    this.model().height(height);
+    this.initialize();
+    if (this._strict) this._autopad = 1;
+  }
+  return this;
+};
+
+prototype.background = function(bgcolor) {
+  if (!arguments.length) return this._bgcolor;
+  if (this._bgcolor !== bgcolor) {
+    this._bgcolor = bgcolor;
+    this.initialize();
+  }
+  return this;
+};
+
+prototype.padding = function(pad) {
+  if (!arguments.length) return this._padding;
+  if (this._padding !== pad) {
+    if (dl.isString(pad)) {
+      this._autopad = 1;
+      this._padding = {top:0, left:0, bottom:0, right:0};
+      this._strict = (pad === 'strict');
+    } else {
+      this._autopad = 0;
+      this._padding = pad;
+      this._strict = false;
+    }
+    if (this._renderer) this._renderer.resize(this._width, this._height, pad);
+    if (this._handler)  this._handler.padding(pad);
+  }
+  return (this._repaint = true, this);
+};
+
+prototype.autopad = function(opt) {
+  if (this._autopad < 1) return this;
+  else this._autopad = 0;
+
+  var b = this.model().scene().bounds,
+      pad = this._padding,
+      config = this.model().config(),
+      inset = config.autopadInset,
+      l = b.x1 < 0 ? Math.ceil(-b.x1) + inset : 0,
+      t = b.y1 < 0 ? Math.ceil(-b.y1) + inset : 0,
+      r = b.x2 > this._width  ? Math.ceil(+b.x2 - this._width) + inset : 0;
+  b = b.y2 > this._height ? Math.ceil(+b.y2 - this._height) + inset : 0;
+  pad = {left:l, top:t, right:r, bottom:b};
+
+  if (this._strict) {
+    this._autopad = 0;
+    this._padding = pad;
+    this._width = Math.max(0, this.__width - (l+r));
+    this._height = Math.max(0, this.__height - (t+b));
+
+    this._model.width(this._width)
+      .height(this._height).reset();
+
+    this.initialize()
+      .update({props:'enter'}).update({props:'update'});
+  } else {
+    this.padding(pad).update(opt);
+  }
+  return this;
+};
+
+prototype.viewport = function(size) {
+  if (!arguments.length) return this._viewport;
+  if (this._viewport !== size) {
+    this._viewport = size;
+    this.initialize();
+  }
+  return this;
+};
+
+prototype.renderer = function(type) {
+  if (!arguments.length) return this._renderer;
+  if (this._renderers[type]) type = this._renderers[type];
+  else if (dl.isString(type)) throw new Error('Unknown renderer: ' + type);
+  else if (!type) throw new Error('No renderer specified');
+
+  if (this._io !== type) {
+    this._io = type;
+    this._renderer = null;
+    this.initialize();
+    if (this._build) this.render();
+  }
+  return this;
+};
+
+prototype.initialize = function(el) {
+  var v = this, prevHandler,
+      w = v._width, h = v._height, pad = v._padding, bg = v._bgcolor,
+      config = this.model().config();
+
+  if (!arguments.length || el === null) {
+    el = this._el ? this._el.parentNode : null;
+    if (!el) return this;  // This View cannot init w/o an
+  }
+
+  // clear pre-existing container
+  d3.select(el).select('div.vega').remove();
+  
+  // add div container
+  this._el = el = d3.select(el)
+    .append('div')
+    .attr('class', 'vega')
+    .style('position', 'relative')
+    .node();
+  if (v._viewport) {
+    d3.select(el)
+      .style('width',  (v._viewport[0] || w)+'px')
+      .style('height', (v._viewport[1] || h)+'px')
+      .style('overflow', 'auto');
+  }
+
+  // renderer
+  sg.canvas.Renderer.RETINA = config.render.retina;
+  v._renderer = (v._renderer || new this._io.Renderer(config.load))
+    .initialize(el, w, h, pad)
+    .background(bg);
+  
+  // input handler
+  prevHandler = v._handler;
+  v._handler = new this._io.Handler()
+    .initialize(el, pad, v);
+
+  if (prevHandler) {
+    prevHandler.handlers().forEach(function(h) {
+      v._handler.on(h.type, h.handler);
+    });
+  } else {
+    // Register event listeners for signal stream definitions.
+    v._detach = parseStreams(this);
+  }
+  
+  return (this._repaint = true, this);
+};
+
+prototype.destroy = function() {
+  if (this._detach) this._detach();
+};
+
+function build() {
+  var v = this;
+  v._renderNode = new df.Node(v._model)
+    .router(true);
+
+  v._renderNode.evaluate = function(input) {
+    log.debug(input, ['rendering']);
+
+    var s = v._model.scene(),
+        h = v._handler;
+
+    if (h && h.scene) h.scene(s);
+
+    if (input.trans) {
+      input.trans.start(function(items) { v._renderer.render(s, items); });
+    } else if (v._repaint) {
+      v._renderer.render(s);
+      v._repaint = false;
+    } else if (input.dirty.length) {
+      v._renderer.render(s, input.dirty);
+    }
+
+    if (input.dirty.length) {
+      input.dirty.forEach(function(i) { i._dirty = false; });
+      s.items[0]._dirty = false;
+    }
+
+    // For all updated datasources, clear their previous values.
+    for (var d in input.data) { v._model.data(d).synchronize(); }
+    return input;
+  };
+
+  return (v._model.scene(v._renderNode), true);  
+}
+
+prototype.update = function(opt) {
+  opt = opt || {};
+  var v = this,
+      trans = opt.duration ? new Transition(opt.duration, opt.ease) : null;
+
+  var cs = v._changeset;
+  if (trans) cs.trans = trans;
+  if (opt.props !== undefined) {
+    if (dl.keys(cs.data).length > 0) {
+      throw Error(
+        'New data values are not reflected in the visualization.' +
+        ' Please call view.update() before updating a specified property set.'
+      );
+    }
+
+    cs.reflow  = true;
+    cs.request = opt.props;
+  }
+
+  var built = v._build;
+  v._build = v._build || build.call(this);
+
+  // If specific items are specified, short-circuit dataflow graph.
+  // Else-If there are streaming updates, perform a targeted propagation.
+  // Otherwise, reevaluate the entire model (datasources + scene).
+  if (opt.items && built) { 
+    Encoder.update(this._model, opt.trans, opt.props, opt.items, cs.dirty);
+    v._renderNode.evaluate(cs);
+  } else if (v._streamer.listeners().length && built) {
+    v._model.propagate(cs, v._streamer);
+    v._streamer.disconnect();
+  } else {
+    v._model.fire(cs);
+  }
+
+  v._changeset = df.ChangeSet.create();
+
+  return v.autopad(opt);
+};
+
+prototype.toImageURL = function(type) {
+  var v = this, Renderer;
+
+  // lookup appropriate renderer
+  switch (type || 'png') {
+    case 'canvas':
+    case 'png':
+      Renderer = sg.canvas.Renderer; break;
+    case 'svg':
+      Renderer = sg.svg.string.Renderer; break;
+    default: throw Error('Unrecognized renderer type: ' + type);
+  }
+
+  var retina = sg.canvas.Renderer.RETINA;
+  sg.canvas.Renderer.RETINA = false; // ignore retina screen
+
+  // render the scenegraph
+  var ren = new Renderer(v._model.config.load)
+    .initialize(null, v._width, v._height, v._padding)
+    .render(v._model.scene());
+
+  sg.canvas.Renderer.RETINA = retina; // restore retina settings
+
+  // return data url
+  if (type === 'svg') {
+    var blob = new Blob([ren.svg()], {type: 'image/svg+xml'});
+    return window.URL.createObjectURL(blob);
+  } else {
+    return ren.canvas().toDataURL('image/png');
+  }
+};
+
+prototype.render = function(items) {
+  this._renderer.render(this._model.scene(), items);
+  return this;
+};
+
+prototype.on = function() {
+  this._handler.on.apply(this._handler, arguments);
+  return this;
+};
+
+prototype.onSignal = function(name, handler) {
+  this._model.signal(name).on(handler);
+  return this;
+};
+
+prototype.off = function() {
+  this._handler.off.apply(this._handler, arguments);
+  return this;
+};
+
+prototype.offSignal = function(name, handler) {
+  this._model.signal(name).off(handler);
+  return this;
+};
+
+View.factory = function(model) {
+  var HeadlessView = require('./HeadlessView');
+  return function(opt) {
+    opt = opt || {};
+    var defs = model.defs();
+    var v = (opt.el ? new View() : new HeadlessView())
+      .model(model)
+      .renderer(opt.renderer || 'canvas')
+      .width(defs.width)
+      .height(defs.height)
+      .background(defs.background)
+      .padding(defs.padding)
+      .viewport(defs.viewport)
+      .initialize(opt.el);
+
+    if (opt.data) v.data(opt.data);
+
+    if (opt.hover !== false && opt.el) {
+      v.on('mouseover', function(evt, item) {
+        if (item && item.hasPropertySet('hover')) {
+          this.update({props:'hover', items:item});
+        }
+      })
+      .on('mouseout', function(evt, item) {
+        if (item && item.hasPropertySet('hover')) {
+          this.update({props:'update', items:item});
+        }
+      });
+    }
+  
+    return v;
+  };    
+};
+
+module.exports = View;
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{"../parse/streams":105,"../scene/Encoder":109,"../scene/Transition":112,"./HeadlessView":85,"datalib":24,"vega-dataflow":39,"vega-logging":45,"vega-scenegraph":46}],88:[function(require,module,exports){
+(function (global){
+var d3 = (typeof window !== "undefined" ? window['d3'] : typeof global !== "undefined" ? global['d3'] : null),
+    config = {};
+
+config.load = {
+  // base url for loading external data files
+  // used only for server-side operation
+  baseURL: '',
+  // Allows domain restriction when using data loading via XHR.
+  // To enable, set it to a list of allowed domains
+  // e.g., ['wikipedia.org', 'eff.org']
+  domainWhiteList: false
+};
+
+// inset padding for automatic padding calculation
+config.autopadInset = 5;
+
+// extensible scale lookup table
+// all d3.scale.* instances also supported
+config.scale = {
+  time: d3.time.scale,
+  utc:  d3.time.scale.utc
+};
+
+// default rendering settings
+config.render = {
+  retina: true
+};
+
+// default axis properties
+config.axis = {
+  orient: 'bottom',
+  ticks: 10,
+  padding: 3,
+  axisColor: '#000',
+  gridColor: '#000',
+  gridOpacity: 0.15,
+  tickColor: '#000',
+  tickLabelColor: '#000',
+  axisWidth: 1,
+  tickWidth: 1,
+  tickSize: 6,
+  tickLabelFontSize: 11,
+  tickLabelFont: 'sans-serif',
+  titleColor: '#000',
+  titleFont: 'sans-serif',
+  titleFontSize: 11,
+  titleFontWeight: 'bold',
+  titleOffset: 35
+};
+
+// default legend properties
+config.legend = {
+  orient: 'right',
+  offset: 20,
+  padding: 3,
+  gradientStrokeColor: '#888',
+  gradientStrokeWidth: 1,
+  gradientHeight: 16,
+  gradientWidth: 100,
+  labelColor: '#000',
+  labelFontSize: 10,
+  labelFont: 'sans-serif',
+  labelAlign: 'left',
+  labelBaseline: 'middle',
+  labelOffset: 8,
+  symbolShape: 'circle',
+  symbolSize: 50,
+  symbolColor: '#888',
+  symbolStrokeWidth: 1,
+  titleColor: '#000',
+  titleFont: 'sans-serif',
+  titleFontSize: 11,
+  titleFontWeight: 'bold'
+};
+
+// default color values
+config.color = {
+  rgb: [128, 128, 128],
+  lab: [50, 0, 0],
+  hcl: [0, 0, 50],
+  hsl: [0, 0, 0.5]
+};
+
+// default scale ranges
+config.range = {
+  category10:  d3.scale.category10().range(),
+  category20:  d3.scale.category20().range(),
+  category20b: d3.scale.category20b().range(),
+  category20c: d3.scale.category20c().range(),
+  shapes: [
+    'circle',
+    'cross',
+    'diamond',
+    'square',
+    'triangle-down',
+    'triangle-up'
+  ]
+};
+
+module.exports = config;
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{}],89:[function(require,module,exports){
+var dl = require('datalib'),
+    parse = require('../parse'),
+    Scale = require('../scene/Scale'),
+    config = require('./config');
+
+function compile(module, opt, schema) {
+  var s = module.schema;
+  if (!s) return;
+  if (s.refs) dl.extend(schema.refs, s.refs);
+  if (s.defs) dl.extend(schema.defs, s.defs);
+}
+
+module.exports = function(opt) {
+  var schema = null;
+  opt = opt || {};
+
+  // Compile if we're not loading the schema from a URL. 
+  // Load from a URL to extend the existing base schema.
+  if (opt.url) {
+    schema = dl.json(dl.extend({url: opt.url}, config.load));
+  } else {
+    schema = {
+      "$schema": "http://json-schema.org/draft-04/schema#",
+      "title": "Vega Visualization Specification Language",
+      "defs": {}, 
+      "refs": {}, 
+      "$ref": "#/defs/spec"
+    };
+
+    dl.keys(parse).forEach(function(k) { compile(parse[k], opt, schema); });
+
+    // Scales aren't in the parser, add schema manually
+    compile(Scale, opt, schema);
+  }
+
+  // Extend schema to support custom mark properties or property sets.
+  if (opt.properties) dl.keys(opt.properties).forEach(function(k) {
+    schema.defs.propset.properties[k] = {"$ref": "#/refs/"+opt.properties[k]+"Value"};
+  });
+
+  if (opt.propertySets) dl.keys(opt.propertySets).forEach(function(k) {
+    schema.defs.mark.properties.properties.properties[k] = {"$ref": "#/defs/propset"};
+  });
+
+  return schema;
+};
+},{"../parse":95,"../scene/Scale":111,"./config":88,"datalib":24}],90:[function(require,module,exports){
+var dl = require('datalib'),
+    axs = require('../scene/axis');
+
+var ORIENT = {
+  "x":      "bottom",
+  "y":      "left",
+  "top":    "top",
+  "bottom": "bottom",
+  "left":   "left",
+  "right":  "right"
+};
+
+function parseAxes(model, spec, axes, group) {
+  var config = model.config();
+  (spec || []).forEach(function(def, index) {
+    axes[index] = axes[index] || axs(model);
+    parseAxis(config, def, index, axes[index], group);
+  });
+}
+
+function parseAxis(config, def, index, axis, group) {
+  // axis scale
+  if (def.scale !== undefined) {
+    axis.scale(group.scale(def.scale));
+  }
+
+  // axis orientation
+  axis.orient(def.orient || ORIENT[def.type]);
+  // axis offset
+  axis.offset(def.offset || 0);
+  // axis layer
+  axis.layer(def.layer || "front");
+  // axis grid lines
+  axis.grid(def.grid || false);
+  // axis title
+  axis.title(def.title || null);
+  // axis title offset
+  axis.titleOffset(def.titleOffset != null ?
+    def.titleOffset : config.axis.titleOffset);
+  // axis values
+  axis.tickValues(def.values || null);
+  // axis label formatting
+  axis.tickFormat(def.format || null);
+  axis.tickFormatType(def.formatType || null);
+  // axis tick subdivision
+  axis.tickSubdivide(def.subdivide || 0);
+  // axis tick padding
+  axis.tickPadding(def.tickPadding || config.axis.padding);
+
+  // axis tick size(s)
+  var size = [];
+  if (def.tickSize !== undefined) {
+    for (var i=0; i<3; ++i) size.push(def.tickSize);
+  } else {
+    var ts = config.axis.tickSize;
+    size = [ts, ts, ts];
+  }
+  if (def.tickSizeMajor != null) size[0] = def.tickSizeMajor;
+  if (def.tickSizeMinor != null) size[1] = def.tickSizeMinor;
+  if (def.tickSizeEnd   != null) size[2] = def.tickSizeEnd;
+  if (size.length) {
+    axis.tickSize.apply(axis, size);
+  }
+
+  // axis tick count
+  axis.tickCount(def.ticks || config.axis.ticks);
+
+  // style properties
+  var p = def.properties;
+  if (p && p.ticks) {
+    axis.majorTickProperties(p.majorTicks ?
+      dl.extend({}, p.ticks, p.majorTicks) : p.ticks);
+    axis.minorTickProperties(p.minorTicks ?
+      dl.extend({}, p.ticks, p.minorTicks) : p.ticks);
+  } else {
+    axis.majorTickProperties(p && p.majorTicks || {});
+    axis.minorTickProperties(p && p.minorTicks || {});
+  }
+  axis.tickLabelProperties(p && p.labels || {});
+  axis.titleProperties(p && p.title || {});
+  axis.gridLineProperties(p && p.grid || {});
+  axis.domainProperties(p && p.axis || {});
+}
+
+module.exports = parseAxes;
+},{"../scene/axis":113,"datalib":24}],91:[function(require,module,exports){
+(function (global){
+var d3 = (typeof window !== "undefined" ? window['d3'] : typeof global !== "undefined" ? global['d3'] : null);
+
+function parseBg(bg) {
+  // return null if input is null or undefined
+  if (bg == null) return null;
+  // run through d3 rgb to sanity check
+  return d3.rgb(bg) + "";  
+}
+
+module.exports = parseBg;
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{}],92:[function(require,module,exports){
+var dl = require('datalib'),
+    log = require('vega-logging'),
+    parseTransforms = require('./transforms'),
+    parseModify = require('./modify');
+
+function parseData(model, spec, callback) {
+  var config = model.config(),
+      count = 0;
+
+  function loaded(d) {
+    return function(error, data) {
+      if (error) {
+        log.error('LOADING FAILED: ' + d.url + ' ' + error);
+      } else {
+        model.data(d.name).values(dl.read(data, d.format));
+      }
+      if (--count === 0) callback();
+    };
+  }
+
+  // process each data set definition
+  (spec || []).forEach(function(d) {
+    if (d.url) {
+      count += 1;
+      dl.load(dl.extend({url: d.url}, config.load), loaded(d));
+    }
+    parseData.datasource(model, d);
+  });
+
+  if (count === 0) setTimeout(callback, 1);
+  return spec;
+}
+
+parseData.datasource = function(model, d) {
+  var transform = (d.transform || []).map(function(t) {
+        return parseTransforms(model, t); 
+      }),
+      mod = (d.modify || []).map(function(m) {
+        return parseModify(model, m, d);
+      }),
+      ds = model.data(d.name, mod.concat(transform));
+
+  if (d.values) {
+    ds.values(dl.read(d.values, d.format));
+  } else if (d.source) {
+    // Derived ds will be pulsed by its src rather than the model.
+    ds.source(d.source).addListener(ds);  
+    model.removeListener(ds.pipeline()[0]); 
+  }
+
+  return ds;    
+};
+
+module.exports = parseData;
+},{"./modify":99,"./transforms":106,"datalib":24,"vega-logging":45}],93:[function(require,module,exports){
+module.exports = (function() {
+  /*
+   * Generated by PEG.js 0.8.0.
+   *
+   * http://pegjs.majda.cz/
+   */
+
+  function peg$subclass(child, parent) {
+    function ctor() { this.constructor = child; }
+    ctor.prototype = parent.prototype;
+    child.prototype = new ctor();
+  }
+
+  function SyntaxError(message, expected, found, offset, line, column) {
+    this.message  = message;
+    this.expected = expected;
+    this.found    = found;
+    this.offset   = offset;
+    this.line     = line;
+    this.column   = column;
+
+    this.name     = "SyntaxError";
+  }
+
+  peg$subclass(SyntaxError, Error);
+
+  function parse(input) {
+    var options = arguments.length > 1 ? arguments[1] : {},
+
+        peg$FAILED = {},
+
+        peg$startRuleFunctions = { start: peg$parsestart },
+        peg$startRuleFunction  = peg$parsestart,
+
+        peg$c0 = peg$FAILED,
+        peg$c1 = ",",
+        peg$c2 = { type: "literal", value: ",", description: "\",\"" },
+        peg$c3 = function(o, m) { return [o].concat(m); },
+        peg$c4 = function(o) { return [o]; },
+        peg$c5 = "[",
+        peg$c6 = { type: "literal", value: "[", description: "\"[\"" },
+        peg$c7 = "]",
+        peg$c8 = { type: "literal", value: "]", description: "\"]\"" },
+        peg$c9 = ">",
+        peg$c10 = { type: "literal", value: ">", description: "\">\"" },
+        peg$c11 = function(f1, f2, o) { return {start: f1, end: f2, middle: o}; },
+        peg$c12 = [],
+        peg$c13 = function(s, f) { return (s.filters = f, s); },
+        peg$c14 = function(s) { return s; },
+        peg$c15 = "(",
+        peg$c16 = { type: "literal", value: "(", description: "\"(\"" },
+        peg$c17 = ")",
+        peg$c18 = { type: "literal", value: ")", description: "\")\"" },
+        peg$c19 = function(m) { return {stream: m}; },
+        peg$c20 = "@",
+        peg$c21 = { type: "literal", value: "@", description: "\"@\"" },
+        peg$c22 = ":",
+        peg$c23 = { type: "literal", value: ":", description: "\":\"" },
+        peg$c24 = function(n, e) { return {event: e, name: n}; },
+        peg$c25 = function(m, e) { return {event: e, mark: m}; },
+        peg$c26 = function(t, e) { return {event: e, target: t}; },
+        peg$c27 = function(e) { return {event: e}; },
+        peg$c28 = function(s) { return {signal: s}; },
+        peg$c29 = "rect",
+        peg$c30 = { type: "literal", value: "rect", description: "\"rect\"" },
+        peg$c31 = "symbol",
+        peg$c32 = { type: "literal", value: "symbol", description: "\"symbol\"" },
+        peg$c33 = "path",
+        peg$c34 = { type: "literal", value: "path", description: "\"path\"" },
+        peg$c35 = "arc",
+        peg$c36 = { type: "literal", value: "arc", description: "\"arc\"" },
+        peg$c37 = "area",
+        peg$c38 = { type: "literal", value: "area", description: "\"area\"" },
+        peg$c39 = "line",
+        peg$c40 = { type: "literal", value: "line", description: "\"line\"" },
+        peg$c41 = "rule",
+        peg$c42 = { type: "literal", value: "rule", description: "\"rule\"" },
+        peg$c43 = "image",
+        peg$c44 = { type: "literal", value: "image", description: "\"image\"" },
+        peg$c45 = "text",
+        peg$c46 = { type: "literal", value: "text", description: "\"text\"" },
+        peg$c47 = "group",
+        peg$c48 = { type: "literal", value: "group", description: "\"group\"" },
+        peg$c49 = "mousedown",
+        peg$c50 = { type: "literal", value: "mousedown", description: "\"mousedown\"" },
+        peg$c51 = "mouseup",
+        peg$c52 = { type: "literal", value: "mouseup", description: "\"mouseup\"" },
+        peg$c53 = "click",
+        peg$c54 = { type: "literal", value: "click", description: "\"click\"" },
+        peg$c55 = "dblclick",
+        peg$c56 = { type: "literal", value: "dblclick", description: "\"dblclick\"" },
+        peg$c57 = "wheel",
+        peg$c58 = { type: "literal", value: "wheel", description: "\"wheel\"" },
+        peg$c59 = "keydown",
+        peg$c60 = { type: "literal", value: "keydown", description: "\"keydown\"" },
+        peg$c61 = "keypress",
+        peg$c62 = { type: "literal", value: "keypress", description: "\"keypress\"" },
+        peg$c63 = "keyup",
+        peg$c64 = { type: "literal", value: "keyup", description: "\"keyup\"" },
+        peg$c65 = "mousewheel",
+        peg$c66 = { type: "literal", value: "mousewheel", description: "\"mousewheel\"" },
+        peg$c67 = "mousemove",
+        peg$c68 = { type: "literal", value: "mousemove", description: "\"mousemove\"" },
+        peg$c69 = "mouseout",
+        peg$c70 = { type: "literal", value: "mouseout", description: "\"mouseout\"" },
+        peg$c71 = "mouseover",
+        peg$c72 = { type: "literal", value: "mouseover", description: "\"mouseover\"" },
+        peg$c73 = "mouseenter",
+        peg$c74 = { type: "literal", value: "mouseenter", description: "\"mouseenter\"" },
+        peg$c75 = "touchstart",
+        peg$c76 = { type: "literal", value: "touchstart", description: "\"touchstart\"" },
+        peg$c77 = "touchmove",
+        peg$c78 = { type: "literal", value: "touchmove", description: "\"touchmove\"" },
+        peg$c79 = "touchend",
+        peg$c80 = { type: "literal", value: "touchend", description: "\"touchend\"" },
+        peg$c81 = function(e) { return e; },
+        peg$c82 = /^[a-zA-Z0-9_\-]/,
+        peg$c83 = { type: "class", value: "[a-zA-Z0-9_\\-]", description: "[a-zA-Z0-9_\\-]" },
+        peg$c84 = function(n) { return n.join(""); },
+        peg$c85 = /^[a-zA-Z0-9\-_  #.>+~[\]=|\^$*]/,
+        peg$c86 = { type: "class", value: "[a-zA-Z0-9\\-_  #.>+~[\\]=|\\^$*]", description: "[a-zA-Z0-9\\-_  #.>+~[\\]=|\\^$*]" },
+        peg$c87 = function(c) { return c.join(""); },
+        peg$c88 = /^['"a-zA-Z0-9_().><=! \t-&|~]/,
+        peg$c89 = { type: "class", value: "['\"a-zA-Z0-9_().><=! \\t-&|~]", description: "['\"a-zA-Z0-9_().><=! \\t-&|~]" },
+        peg$c90 = function(v) { return v.join(""); },
+        peg$c91 = /^[ \t\r\n]/,
+        peg$c92 = { type: "class", value: "[ \\t\\r\\n]", description: "[ \\t\\r\\n]" },
+
+        peg$currPos          = 0,
+        peg$reportedPos      = 0,
+        peg$cachedPos        = 0,
+        peg$cachedPosDetails = { line: 1, column: 1, seenCR: false },
+        peg$maxFailPos       = 0,
+        peg$maxFailExpected  = [],
+        peg$silentFails      = 0,
+
+        peg$result;
+
+    if ("startRule" in options) {
+      if (!(options.startRule in peg$startRuleFunctions)) {
+        throw new Error("Can't start parsing from rule \"" + options.startRule + "\".");
+      }
+
+      peg$startRuleFunction = peg$startRuleFunctions[options.startRule];
+    }
+
+    function text() {
+      return input.substring(peg$reportedPos, peg$currPos);
+    }
+
+    function offset() {
+      return peg$reportedPos;
+    }
+
+    function line() {
+      return peg$computePosDetails(peg$reportedPos).line;
+    }
+
+    function column() {
+      return peg$computePosDetails(peg$reportedPos).column;
+    }
+
+    function expected(description) {
+      throw peg$buildException(
+        null,
+        [{ type: "other", description: description }],
+        peg$reportedPos
+      );
+    }
+
+    function error(message) {
+      throw peg$buildException(message, null, peg$reportedPos);
+    }
+
+    function peg$computePosDetails(pos) {
+      function advance(details, startPos, endPos) {
+        var p, ch;
+
+        for (p = startPos; p < endPos; p++) {
+          ch = input.charAt(p);
+          if (ch === "\n") {
+            if (!details.seenCR) { details.line++; }
+            details.column = 1;
+            details.seenCR = false;
+          } else if (ch === "\r" || ch === "\u2028" || ch === "\u2029") {
+            details.line++;
+            details.column = 1;
+            details.seenCR = true;
+          } else {
+            details.column++;
+            details.seenCR = false;
+          }
+        }
+      }
+
+      if (peg$cachedPos !== pos) {
+        if (peg$cachedPos > pos) {
+          peg$cachedPos = 0;
+          peg$cachedPosDetails = { line: 1, column: 1, seenCR: false };
+        }
+        advance(peg$cachedPosDetails, peg$cachedPos, pos);
+        peg$cachedPos = pos;
+      }
+
+      return peg$cachedPosDetails;
+    }
+
+    function peg$fail(expected) {
+      if (peg$currPos < peg$maxFailPos) { return; }
+
+      if (peg$currPos > peg$maxFailPos) {
+        peg$maxFailPos = peg$currPos;
+        peg$maxFailExpected = [];
+      }
+
+      peg$maxFailExpected.push(expected);
+    }
+
+    function peg$buildException(message, expected, pos) {
+      function cleanupExpected(expected) {
+        var i = 1;
+
+        expected.sort(function(a, b) {
+          if (a.description < b.description) {
+            return -1;
+          } else if (a.description > b.description) {
+            return 1;
+          } else {
+            return 0;
+          }
+        });
+
+        while (i < expected.length) {
+          if (expected[i - 1] === expected[i]) {
+            expected.splice(i, 1);
+          } else {
+            i++;
+          }
+        }
+      }
+
+      function buildMessage(expected, found) {
+        function stringEscape(s) {
+          function hex(ch) { return ch.charCodeAt(0).toString(16).toUpperCase(); }
+
+          return s
+            .replace(/\\/g,   '\\\\')
+            .replace(/"/g,    '\\"')
+            .replace(/\x08/g, '\\b')
+            .replace(/\t/g,   '\\t')
+            .replace(/\n/g,   '\\n')
+            .replace(/\f/g,   '\\f')
+            .replace(/\r/g,   '\\r')
+            .replace(/[\x00-\x07\x0B\x0E\x0F]/g, function(ch) { return '\\x0' + hex(ch); })
+            .replace(/[\x10-\x1F\x80-\xFF]/g,    function(ch) { return '\\x'  + hex(ch); })
+            .replace(/[\u0180-\u0FFF]/g,         function(ch) { return '\\u0' + hex(ch); })
+            .replace(/[\u1080-\uFFFF]/g,         function(ch) { return '\\u'  + hex(ch); });
+        }
+
+        var expectedDescs = new Array(expected.length),
+            expectedDesc, foundDesc, i;
+
+        for (i = 0; i < expected.length; i++) {
+          expectedDescs[i] = expected[i].description;
+        }
+
+        expectedDesc = expected.length > 1
+          ? expectedDescs.slice(0, -1).join(", ")
+              + " or "
+              + expectedDescs[expected.length - 1]
+          : expectedDescs[0];
+
+        foundDesc = found ? "\"" + stringEscape(found) + "\"" : "end of input";
+
+        return "Expected " + expectedDesc + " but " + foundDesc + " found.";
+      }
+
+      var posDetails = peg$computePosDetails(pos),
+          found      = pos < input.length ? input.charAt(pos) : null;
+
+      if (expected !== null) {
+        cleanupExpected(expected);
+      }
+
+      return new SyntaxError(
+        message !== null ? message : buildMessage(expected, found),
+        expected,
+        found,
+        pos,
+        posDetails.line,
+        posDetails.column
+      );
+    }
+
+    function peg$parsestart() {
+      var s0;
+
+      s0 = peg$parsemerged();
+
+      return s0;
+    }
+
+    function peg$parsemerged() {
+      var s0, s1, s2, s3, s4, s5;
+
+      s0 = peg$currPos;
+      s1 = peg$parseordered();
+      if (s1 !== peg$FAILED) {
+        s2 = peg$parsesep();
+        if (s2 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 44) {
+            s3 = peg$c1;
+            peg$currPos++;
+          } else {
+            s3 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c2); }
+          }
+          if (s3 !== peg$FAILED) {
+            s4 = peg$parsesep();
+            if (s4 !== peg$FAILED) {
+              s5 = peg$parsemerged();
+              if (s5 !== peg$FAILED) {
+                peg$reportedPos = s0;
+                s1 = peg$c3(s1, s5);
+                s0 = s1;
+              } else {
+                peg$currPos = s0;
+                s0 = peg$c0;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$c0;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$c0;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c0;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$c0;
+      }
+      if (s0 === peg$FAILED) {
+        s0 = peg$currPos;
+        s1 = peg$parseordered();
+        if (s1 !== peg$FAILED) {
+          peg$reportedPos = s0;
+          s1 = peg$c4(s1);
+        }
+        s0 = s1;
+      }
+
+      return s0;
+    }
+
+    function peg$parseordered() {
+      var s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, s13;
+
+      s0 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 91) {
+        s1 = peg$c5;
+        peg$currPos++;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c6); }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = peg$parsesep();
+        if (s2 !== peg$FAILED) {
+          s3 = peg$parsefiltered();
+          if (s3 !== peg$FAILED) {
+            s4 = peg$parsesep();
+            if (s4 !== peg$FAILED) {
+              if (input.charCodeAt(peg$currPos) === 44) {
+                s5 = peg$c1;
+                peg$currPos++;
+              } else {
+                s5 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$c2); }
+              }
+              if (s5 !== peg$FAILED) {
+                s6 = peg$parsesep();
+                if (s6 !== peg$FAILED) {
+                  s7 = peg$parsefiltered();
+                  if (s7 !== peg$FAILED) {
+                    s8 = peg$parsesep();
+                    if (s8 !== peg$FAILED) {
+                      if (input.charCodeAt(peg$currPos) === 93) {
+                        s9 = peg$c7;
+                        peg$currPos++;
+                      } else {
+                        s9 = peg$FAILED;
+                        if (peg$silentFails === 0) { peg$fail(peg$c8); }
+                      }
+                      if (s9 !== peg$FAILED) {
+                        s10 = peg$parsesep();
+                        if (s10 !== peg$FAILED) {
+                          if (input.charCodeAt(peg$currPos) === 62) {
+                            s11 = peg$c9;
+                            peg$currPos++;
+                          } else {
+                            s11 = peg$FAILED;
+                            if (peg$silentFails === 0) { peg$fail(peg$c10); }
+                          }
+                          if (s11 !== peg$FAILED) {
+                            s12 = peg$parsesep();
+                            if (s12 !== peg$FAILED) {
+                              s13 = peg$parseordered();
+                              if (s13 !== peg$FAILED) {
+                                peg$reportedPos = s0;
+                                s1 = peg$c11(s3, s7, s13);
+                                s0 = s1;
+                              } else {
+                                peg$currPos = s0;
+                                s0 = peg$c0;
+                              }
+                            } else {
+                              peg$currPos = s0;
+                              s0 = peg$c0;
+                            }
+                          } else {
+                            peg$currPos = s0;
+                            s0 = peg$c0;
+                          }
+                        } else {
+                          peg$currPos = s0;
+                          s0 = peg$c0;
+                        }
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$c0;
+                      }
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$c0;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$c0;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$c0;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$c0;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$c0;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$c0;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c0;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$c0;
+      }
+      if (s0 === peg$FAILED) {
+        s0 = peg$parsefiltered();
+      }
+
+      return s0;
+    }
+
+    function peg$parsefiltered() {
+      var s0, s1, s2, s3;
+
+      s0 = peg$currPos;
+      s1 = peg$parsestream();
+      if (s1 !== peg$FAILED) {
+        s2 = [];
+        s3 = peg$parsefilter();
+        if (s3 !== peg$FAILED) {
+          while (s3 !== peg$FAILED) {
+            s2.push(s3);
+            s3 = peg$parsefilter();
+          }
+        } else {
+          s2 = peg$c0;
+        }
+        if (s2 !== peg$FAILED) {
+          peg$reportedPos = s0;
+          s1 = peg$c13(s1, s2);
+          s0 = s1;
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c0;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$c0;
+      }
+      if (s0 === peg$FAILED) {
+        s0 = peg$currPos;
+        s1 = peg$parsestream();
+        if (s1 !== peg$FAILED) {
+          peg$reportedPos = s0;
+          s1 = peg$c14(s1);
+        }
+        s0 = s1;
+      }
+
+      return s0;
+    }
+
+    function peg$parsestream() {
+      var s0, s1, s2, s3, s4;
+
+      s0 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 40) {
+        s1 = peg$c15;
+        peg$currPos++;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c16); }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = peg$parsemerged();
+        if (s2 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 41) {
+            s3 = peg$c17;
+            peg$currPos++;
+          } else {
+            s3 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c18); }
+          }
+          if (s3 !== peg$FAILED) {
+            peg$reportedPos = s0;
+            s1 = peg$c19(s2);
+            s0 = s1;
+          } else {
+            peg$currPos = s0;
+            s0 = peg$c0;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c0;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$c0;
+      }
+      if (s0 === peg$FAILED) {
+        s0 = peg$currPos;
+        if (input.charCodeAt(peg$currPos) === 64) {
+          s1 = peg$c20;
+          peg$currPos++;
+        } else {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$c21); }
+        }
+        if (s1 !== peg$FAILED) {
+          s2 = peg$parsename();
+          if (s2 !== peg$FAILED) {
+            if (input.charCodeAt(peg$currPos) === 58) {
+              s3 = peg$c22;
+              peg$currPos++;
+            } else {
+              s3 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$c23); }
+            }
+            if (s3 !== peg$FAILED) {
+              s4 = peg$parseeventType();
+              if (s4 !== peg$FAILED) {
+                peg$reportedPos = s0;
+                s1 = peg$c24(s2, s4);
+                s0 = s1;
+              } else {
+                peg$currPos = s0;
+                s0 = peg$c0;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$c0;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$c0;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c0;
+        }
+        if (s0 === peg$FAILED) {
+          s0 = peg$currPos;
+          s1 = peg$parsemarkType();
+          if (s1 !== peg$FAILED) {
+            if (input.charCodeAt(peg$currPos) === 58) {
+              s2 = peg$c22;
+              peg$currPos++;
+            } else {
+              s2 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$c23); }
+            }
+            if (s2 !== peg$FAILED) {
+              s3 = peg$parseeventType();
+              if (s3 !== peg$FAILED) {
+                peg$reportedPos = s0;
+                s1 = peg$c25(s1, s3);
+                s0 = s1;
+              } else {
+                peg$currPos = s0;
+                s0 = peg$c0;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$c0;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$c0;
+          }
+          if (s0 === peg$FAILED) {
+            s0 = peg$currPos;
+            s1 = peg$parsecss();
+            if (s1 !== peg$FAILED) {
+              if (input.charCodeAt(peg$currPos) === 58) {
+                s2 = peg$c22;
+                peg$currPos++;
+              } else {
+                s2 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$c23); }
+              }
+              if (s2 !== peg$FAILED) {
+                s3 = peg$parseeventType();
+                if (s3 !== peg$FAILED) {
+                  peg$reportedPos = s0;
+                  s1 = peg$c26(s1, s3);
+                  s0 = s1;
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$c0;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$c0;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$c0;
+            }
+            if (s0 === peg$FAILED) {
+              s0 = peg$currPos;
+              s1 = peg$parseeventType();
+              if (s1 !== peg$FAILED) {
+                peg$reportedPos = s0;
+                s1 = peg$c27(s1);
+              }
+              s0 = s1;
+              if (s0 === peg$FAILED) {
+                s0 = peg$currPos;
+                s1 = peg$parsename();
+                if (s1 !== peg$FAILED) {
+                  peg$reportedPos = s0;
+                  s1 = peg$c28(s1);
+                }
+                s0 = s1;
+              }
+            }
+          }
+        }
+      }
+
+      return s0;
+    }
+
+    function peg$parsemarkType() {
+      var s0;
+
+      if (input.substr(peg$currPos, 4) === peg$c29) {
+        s0 = peg$c29;
+        peg$currPos += 4;
+      } else {
+        s0 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c30); }
+      }
+      if (s0 === peg$FAILED) {
+        if (input.substr(peg$currPos, 6) === peg$c31) {
+          s0 = peg$c31;
+          peg$currPos += 6;
+        } else {
+          s0 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$c32); }
+        }
+        if (s0 === peg$FAILED) {
+          if (input.substr(peg$currPos, 4) === peg$c33) {
+            s0 = peg$c33;
+            peg$currPos += 4;
+          } else {
+            s0 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c34); }
+          }
+          if (s0 === peg$FAILED) {
+            if (input.substr(peg$currPos, 3) === peg$c35) {
+              s0 = peg$c35;
+              peg$currPos += 3;
+            } else {
+              s0 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$c36); }
+            }
+            if (s0 === peg$FAILED) {
+              if (input.substr(peg$currPos, 4) === peg$c37) {
+                s0 = peg$c37;
+                peg$currPos += 4;
+              } else {
+                s0 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$c38); }
+              }
+              if (s0 === peg$FAILED) {
+                if (input.substr(peg$currPos, 4) === peg$c39) {
+                  s0 = peg$c39;
+                  peg$currPos += 4;
+                } else {
+                  s0 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$c40); }
+                }
+                if (s0 === peg$FAILED) {
+                  if (input.substr(peg$currPos, 4) === peg$c41) {
+                    s0 = peg$c41;
+                    peg$currPos += 4;
+                  } else {
+                    s0 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c42); }
+                  }
+                  if (s0 === peg$FAILED) {
+                    if (input.substr(peg$currPos, 5) === peg$c43) {
+                      s0 = peg$c43;
+                      peg$currPos += 5;
+                    } else {
+                      s0 = peg$FAILED;
+                      if (peg$silentFails === 0) { peg$fail(peg$c44); }
+                    }
+                    if (s0 === peg$FAILED) {
+                      if (input.substr(peg$currPos, 4) === peg$c45) {
+                        s0 = peg$c45;
+                        peg$currPos += 4;
+                      } else {
+                        s0 = peg$FAILED;
+                        if (peg$silentFails === 0) { peg$fail(peg$c46); }
+                      }
+                      if (s0 === peg$FAILED) {
+                        if (input.substr(peg$currPos, 5) === peg$c47) {
+                          s0 = peg$c47;
+                          peg$currPos += 5;
+                        } else {
+                          s0 = peg$FAILED;
+                          if (peg$silentFails === 0) { peg$fail(peg$c48); }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+
+      return s0;
+    }
+
+    function peg$parseeventType() {
+      var s0;
+
+      if (input.substr(peg$currPos, 9) === peg$c49) {
+        s0 = peg$c49;
+        peg$currPos += 9;
+      } else {
+        s0 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c50); }
+      }
+      if (s0 === peg$FAILED) {
+        if (input.substr(peg$currPos, 7) === peg$c51) {
+          s0 = peg$c51;
+          peg$currPos += 7;
+        } else {
+          s0 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$c52); }
+        }
+        if (s0 === peg$FAILED) {
+          if (input.substr(peg$currPos, 5) === peg$c53) {
+            s0 = peg$c53;
+            peg$currPos += 5;
+          } else {
+            s0 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c54); }
+          }
+          if (s0 === peg$FAILED) {
+            if (input.substr(peg$currPos, 8) === peg$c55) {
+              s0 = peg$c55;
+              peg$currPos += 8;
+            } else {
+              s0 = peg$FAILED;
+              if (peg$silentFails === 0) { peg$fail(peg$c56); }
+            }
+            if (s0 === peg$FAILED) {
+              if (input.substr(peg$currPos, 5) === peg$c57) {
+                s0 = peg$c57;
+                peg$currPos += 5;
+              } else {
+                s0 = peg$FAILED;
+                if (peg$silentFails === 0) { peg$fail(peg$c58); }
+              }
+              if (s0 === peg$FAILED) {
+                if (input.substr(peg$currPos, 7) === peg$c59) {
+                  s0 = peg$c59;
+                  peg$currPos += 7;
+                } else {
+                  s0 = peg$FAILED;
+                  if (peg$silentFails === 0) { peg$fail(peg$c60); }
+                }
+                if (s0 === peg$FAILED) {
+                  if (input.substr(peg$currPos, 8) === peg$c61) {
+                    s0 = peg$c61;
+                    peg$currPos += 8;
+                  } else {
+                    s0 = peg$FAILED;
+                    if (peg$silentFails === 0) { peg$fail(peg$c62); }
+                  }
+                  if (s0 === peg$FAILED) {
+                    if (input.substr(peg$currPos, 5) === peg$c63) {
+                      s0 = peg$c63;
+                      peg$currPos += 5;
+                    } else {
+                      s0 = peg$FAILED;
+                      if (peg$silentFails === 0) { peg$fail(peg$c64); }
+                    }
+                    if (s0 === peg$FAILED) {
+                      if (input.substr(peg$currPos, 10) === peg$c65) {
+                        s0 = peg$c65;
+                        peg$currPos += 10;
+                      } else {
+                        s0 = peg$FAILED;
+                        if (peg$silentFails === 0) { peg$fail(peg$c66); }
+                      }
+                      if (s0 === peg$FAILED) {
+                        if (input.substr(peg$currPos, 9) === peg$c67) {
+                          s0 = peg$c67;
+                          peg$currPos += 9;
+                        } else {
+                          s0 = peg$FAILED;
+                          if (peg$silentFails === 0) { peg$fail(peg$c68); }
+                        }
+                        if (s0 === peg$FAILED) {
+                          if (input.substr(peg$currPos, 8) === peg$c69) {
+                            s0 = peg$c69;
+                            peg$currPos += 8;
+                          } else {
+                            s0 = peg$FAILED;
+                            if (peg$silentFails === 0) { peg$fail(peg$c70); }
+                          }
+                          if (s0 === peg$FAILED) {
+                            if (input.substr(peg$currPos, 9) === peg$c71) {
+                              s0 = peg$c71;
+                              peg$currPos += 9;
+                            } else {
+                              s0 = peg$FAILED;
+                              if (peg$silentFails === 0) { peg$fail(peg$c72); }
+                            }
+                            if (s0 === peg$FAILED) {
+                              if (input.substr(peg$currPos, 10) === peg$c73) {
+                                s0 = peg$c73;
+                                peg$currPos += 10;
+                              } else {
+                                s0 = peg$FAILED;
+                                if (peg$silentFails === 0) { peg$fail(peg$c74); }
+                              }
+                              if (s0 === peg$FAILED) {
+                                if (input.substr(peg$currPos, 10) === peg$c75) {
+                                  s0 = peg$c75;
+                                  peg$currPos += 10;
+                                } else {
+                                  s0 = peg$FAILED;
+                                  if (peg$silentFails === 0) { peg$fail(peg$c76); }
+                                }
+                                if (s0 === peg$FAILED) {
+                                  if (input.substr(peg$currPos, 9) === peg$c77) {
+                                    s0 = peg$c77;
+                                    peg$currPos += 9;
+                                  } else {
+                                    s0 = peg$FAILED;
+                                    if (peg$silentFails === 0) { peg$fail(peg$c78); }
+                                  }
+                                  if (s0 === peg$FAILED) {
+                                    if (input.substr(peg$currPos, 8) === peg$c79) {
+                                      s0 = peg$c79;
+                                      peg$currPos += 8;
+                                    } else {
+                                      s0 = peg$FAILED;
+                                      if (peg$silentFails === 0) { peg$fail(peg$c80); }
+                                    }
+                                  }
+                                }
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+
+      return s0;
+    }
+
+    function peg$parsefilter() {
+      var s0, s1, s2, s3;
+
+      s0 = peg$currPos;
+      if (input.charCodeAt(peg$currPos) === 91) {
+        s1 = peg$c5;
+        peg$currPos++;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c6); }
+      }
+      if (s1 !== peg$FAILED) {
+        s2 = peg$parseexpr();
+        if (s2 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 93) {
+            s3 = peg$c7;
+            peg$currPos++;
+          } else {
+            s3 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c8); }
+          }
+          if (s3 !== peg$FAILED) {
+            peg$reportedPos = s0;
+            s1 = peg$c81(s2);
+            s0 = s1;
+          } else {
+            peg$currPos = s0;
+            s0 = peg$c0;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$c0;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$c0;
+      }
+
+      return s0;
+    }
+
+    function peg$parsename() {
+      var s0, s1, s2;
+
+      s0 = peg$currPos;
+      s1 = [];
+      if (peg$c82.test(input.charAt(peg$currPos))) {
+        s2 = input.charAt(peg$currPos);
+        peg$currPos++;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c83); }
+      }
+      if (s2 !== peg$FAILED) {
+        while (s2 !== peg$FAILED) {
+          s1.push(s2);
+          if (peg$c82.test(input.charAt(peg$currPos))) {
+            s2 = input.charAt(peg$currPos);
+            peg$currPos++;
+          } else {
+            s2 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c83); }
+          }
+        }
+      } else {
+        s1 = peg$c0;
+      }
+      if (s1 !== peg$FAILED) {
+        peg$reportedPos = s0;
+        s1 = peg$c84(s1);
+      }
+      s0 = s1;
+
+      return s0;
+    }
+
+    function peg$parsecss() {
+      var s0, s1, s2;
+
+      s0 = peg$currPos;
+      s1 = [];
+      if (peg$c85.test(input.charAt(peg$currPos))) {
+        s2 = input.charAt(peg$currPos);
+        peg$currPos++;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c86); }
+      }
+      if (s2 !== peg$FAILED) {
+        while (s2 !== peg$FAILED) {
+          s1.push(s2);
+          if (peg$c85.test(input.charAt(peg$currPos))) {
+            s2 = input.charAt(peg$currPos);
+            peg$currPos++;
+          } else {
+            s2 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c86); }
+          }
+        }
+      } else {
+        s1 = peg$c0;
+      }
+      if (s1 !== peg$FAILED) {
+        peg$reportedPos = s0;
+        s1 = peg$c87(s1);
+      }
+      s0 = s1;
+
+      return s0;
+    }
+
+    function peg$parseexpr() {
+      var s0, s1, s2;
+
+      s0 = peg$currPos;
+      s1 = [];
+      if (peg$c88.test(input.charAt(peg$currPos))) {
+        s2 = input.charAt(peg$currPos);
+        peg$currPos++;
+      } else {
+        s2 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c89); }
+      }
+      if (s2 !== peg$FAILED) {
+        while (s2 !== peg$FAILED) {
+          s1.push(s2);
+          if (peg$c88.test(input.charAt(peg$currPos))) {
+            s2 = input.charAt(peg$currPos);
+            peg$currPos++;
+          } else {
+            s2 = peg$FAILED;
+            if (peg$silentFails === 0) { peg$fail(peg$c89); }
+          }
+        }
+      } else {
+        s1 = peg$c0;
+      }
+      if (s1 !== peg$FAILED) {
+        peg$reportedPos = s0;
+        s1 = peg$c90(s1);
+      }
+      s0 = s1;
+
+      return s0;
+    }
+
+    function peg$parsesep() {
+      var s0, s1;
+
+      s0 = [];
+      if (peg$c91.test(input.charAt(peg$currPos))) {
+        s1 = input.charAt(peg$currPos);
+        peg$currPos++;
+      } else {
+        s1 = peg$FAILED;
+        if (peg$silentFails === 0) { peg$fail(peg$c92); }
+      }
+      while (s1 !== peg$FAILED) {
+        s0.push(s1);
+        if (peg$c91.test(input.charAt(peg$currPos))) {
+          s1 = input.charAt(peg$currPos);
+          peg$currPos++;
+        } else {
+          s1 = peg$FAILED;
+          if (peg$silentFails === 0) { peg$fail(peg$c92); }
+        }
+      }
+
+      return s0;
+    }
+
+    peg$result = peg$startRuleFunction();
+
+    if (peg$result !== peg$FAILED && peg$currPos === input.length) {
+      return peg$result;
+    } else {
+      if (peg$result !== peg$FAILED && peg$currPos < input.length) {
+        peg$fail({ type: "end", description: "end of input" });
+      }
+
+      throw peg$buildException(null, peg$maxFailExpected, peg$maxFailPos);
+    }
+  }
+
+  return {
+    SyntaxError: SyntaxError,
+    parse:       parse
+  };
+})();
+},{}],94:[function(require,module,exports){
+var expr = require('vega-expression'),
+    args = ['datum', 'event', 'signals'];
+
+module.exports = expr.compiler(args, {
+  idWhiteList: args,
+  fieldVar:    args[0],
+  globalVar:   args[2],
+  functions:   function(codegen) {
+    var fn = expr.functions(codegen);
+    fn.eventItem = function() { return 'event.vg.item'; };
+    fn.eventGroup = 'event.vg.getGroup';
+    fn.eventX = 'event.vg.getX';
+    fn.eventY = 'event.vg.getY';
+    fn.open = 'window.open';
+    return fn;
+  }
+});
+},{"vega-expression":43}],95:[function(require,module,exports){
+module.exports = {
+  axes: require('./axes'),
+  background: require('./background'),
+  data: require('./data'),
+  events: require('./events'),
+  expr: require('./expr'),
+  legends: require('./legends'),
+  mark: require('./mark'),
+  marks: require('./marks'),
+  modify: require('./modify'),
+  padding: require('./padding'),
+  predicates: require('./predicates'),
+  properties: require('./properties'),
+  signals: require('./signals'),
+  spec: require('./spec'),
+  streams: require('./streams'),
+  transforms: require('./transforms')
+};
+},{"./axes":90,"./background":91,"./data":92,"./events":93,"./expr":94,"./legends":96,"./mark":97,"./marks":98,"./modify":99,"./padding":100,"./predicates":101,"./properties":102,"./signals":103,"./spec":104,"./streams":105,"./transforms":106}],96:[function(require,module,exports){
+var lgnd = require('../scene/legend');
+
+function parseLegends(model, spec, legends, group) {
+  (spec || []).forEach(function(def, index) {
+    legends[index] = legends[index] || lgnd(model);
+    parseLegend(def, index, legends[index], group);
+  });
+}
+
+function parseLegend(def, index, legend, group) {
+  // legend scales
+  legend.size  (def.size   ? group.scale(def.size)   : null);
+  legend.shape (def.shape  ? group.scale(def.shape)  : null);
+  legend.fill  (def.fill   ? group.scale(def.fill)   : null);
+  legend.stroke(def.stroke ? group.scale(def.stroke) : null);
+
+  // legend orientation
+  if (def.orient) legend.orient(def.orient);
+
+  // legend offset
+  if (def.offset != null) legend.offset(def.offset);
+
+  // legend title
+  legend.title(def.title || null);
+
+  // legend values
+  legend.values(def.values || null);
+
+  // legend label formatting
+  legend.format(def.format !== undefined ? def.format : null);
+
+  // style properties
+  var p = def.properties;
+  legend.titleProperties(p && p.title || {});
+  legend.labelProperties(p && p.labels || {});
+  legend.legendProperties(p && p.legend || {});
+  legend.symbolProperties(p && p.symbols || {});
+  legend.gradientProperties(p && p.gradient || {});
+}
+
+module.exports = parseLegends;
+},{"../scene/legend":114}],97:[function(require,module,exports){
+var dl = require('datalib'),
+    parseProperties = require('./properties');
+
+function parseMark(model, mark) {
+  var props = mark.properties,
+      group = mark.marks;
+
+  // parse mark property definitions
+  dl.keys(props).forEach(function(k) {
+    props[k] = parseProperties(model, mark.type, props[k]);
+  });
+
+  // parse delay function
+  if (mark.delay) {
+    mark.delay = parseProperties(model, mark.type, {delay: mark.delay});
+  }
+
+  // recurse if group type
+  if (group) {
+    mark.marks = group.map(function(g) { return parseMark(model, g); });
+  }
+    
+  return mark;
+}
+
+module.exports = parseMark;
+},{"./properties":102,"datalib":24}],98:[function(require,module,exports){
+var parseMark = require('./mark');
+
+function parseRootMark(model, spec, width, height) {
+  return {
+    type: "group",
+    width: width,
+    height: height,
+    scales: spec.scales || [],
+    axes: spec.axes || [],
+    legends: spec.legends || [],
+    marks: (spec.marks || []).map(function(m) { return parseMark(model, m); })
+  };
+}
+
+module.exports = parseRootMark;
+},{"./mark":97}],99:[function(require,module,exports){
+var dl = require('datalib'),
+    log = require('vega-logging'),
+    df = require('vega-dataflow'),
+    Node = df.Node, // jshint ignore:line
+    Tuple = df.Tuple,
+    Deps = df.Dependencies;
+
+var Types = {
+  INSERT: "insert",
+  REMOVE: "remove",
+  TOGGLE: "toggle",
+  CLEAR:  "clear"
+};
+
+var EMPTY = [];
+
+var filter = function(field, value, src, dest) {
+  for(var i = src.length-1; i >= 0; --i) {
+    if (src[i][field] == value)
+      dest.push.apply(dest, src.splice(i, 1));
+  }
+};
+
+function parseModify(model, def, ds) {
+  var signal = def.signal ? dl.field(def.signal) : null, 
+      signalName = signal ? signal[0] : null,
+      predicate = def.predicate ? model.predicate(def.predicate.name || def.predicate) : null,
+      reeval = (predicate === null),
+      node = new Node(model).router(def.type === Types.CLEAR);
+
+  node.evaluate = function(input) {
+    if (predicate !== null) {  // TODO: predicate args
+      var db = model.values(Deps.DATA, predicate.data || EMPTY),
+          sg = model.values(Deps.SIGNALS, predicate.signals || EMPTY);
+      reeval = predicate.call(predicate, {}, db, sg, model._predicates);
+    }
+
+    log.debug(input, [def.type+"ing", reeval]);
+    if (!reeval) return input;
+
+    var datum = {}, 
+        value = signal ? model.signalRef(def.signal) : null,
+        d = model.data(ds.name),
+        t = null;
+
+    datum[def.field] = value;
+
+    // We have to modify ds._data so that subsequent pulses contain
+    // our dynamic data. W/o modifying ds._data, only the output
+    // collector will contain dynamic tuples. 
+    if (def.type === Types.INSERT) {
+      t = Tuple.ingest(datum);
+      input.add.push(t);
+      d._data.push(t);
+    } else if (def.type === Types.REMOVE) {
+      filter(def.field, value, input.add, input.rem);
+      filter(def.field, value, input.mod, input.rem);
+      d._data = d._data.filter(function(x) { return x[def.field] !== value; });
+    } else if (def.type === Types.TOGGLE) {
+      var add = [], rem = [];
+      filter(def.field, value, input.rem, add);
+      filter(def.field, value, input.add, rem);
+      filter(def.field, value, input.mod, rem);
+      if (!(add.length || rem.length)) add.push(Tuple.ingest(datum));
+
+      input.add.push.apply(input.add, add);
+      d._data.push.apply(d._data, add);
+      input.rem.push.apply(input.rem, rem);
+      d._data = d._data.filter(function(x) { return rem.indexOf(x) === -1; });
+    } else if (def.type === Types.CLEAR) {
+      input.rem.push.apply(input.rem, input.add);
+      input.rem.push.apply(input.rem, input.mod);
+      input.add = [];
+      input.mod = [];
+      d._data  = [];
+    } 
+
+    input.fields[def.field] = 1;
+    return input;
+  };
+
+  if (signalName) node.dependency(Deps.SIGNALS, signalName);
+  
+  if (predicate) {
+    node.dependency(Deps.DATA, predicate.data);
+    node.dependency(Deps.SIGNALS, predicate.signals);
+  }
+  
+  return node;
+}
+
+module.exports = parseModify;
+},{"datalib":24,"vega-dataflow":39,"vega-logging":45}],100:[function(require,module,exports){
+var dl = require('datalib');
+
+function parsePadding(pad) {
+  if (pad == null) return "auto";
+  else if (dl.isString(pad)) return pad==="strict" ? "strict" : "auto";
+  else if (dl.isObject(pad)) return pad;
+  var p = dl.isNumber(pad) ? pad : 20;
+  return {top:p, left:p, right:p, bottom:p};
+}
+
+module.exports = parsePadding;
+},{"datalib":24}],101:[function(require,module,exports){
+var dl = require('datalib');
+
+var types = {
+  '=':   parseComparator,
+  '==':  parseComparator,
+  '!=':  parseComparator,
+  '>':   parseComparator,
+  '>=':  parseComparator,
+  '<':   parseComparator,
+  '<=':  parseComparator,
+  'and': parseLogical,
+  '&&':  parseLogical,
+  'or':  parseLogical,
+  '||':  parseLogical,
+  'in':  parseIn
+};
+
+var nullScale = function() { return 0; };
+nullScale.invert = nullScale;
+
+function parsePredicates(model, spec) {
+  (spec || []).forEach(function(s) {
+    var parse = types[s.type](model, s);
+    
+    /* jshint evil:true */
+    var pred  = Function("args", "db", "signals", "predicates", parse.code);
+    pred.root = function() { return model.scene().items[0]; }; // For global scales
+    pred.nullScale = nullScale;
+    pred.isFunction = dl.isFunction;
+    pred.signals = parse.signals;
+    pred.data = parse.data;
+
+    model.predicate(s.name, pred);
+  });
+
+  return spec;
+}
+
+function parseSignal(signal, signals) {
+  var s = dl.field(signal),
+      code = "signals["+s.map(dl.str).join("][")+"]";
+  signals[s[0]] = 1;
+  return code;
+}
+
+function parseOperands(model, operands) {
+  var decl = [], defs = [],
+      signals = {}, db = {};
+
+  function setSignal(s) { signals[s] = 1; }
+  function setData(d) { db[d] = 1; }
+
+  dl.array(operands).forEach(function(o, i) {
+    var name = "o" + i,
+        def = "";
+
+    if (o.value !== undefined) {
+      def = dl.str(o.value);
+    } else if (o.arg) {
+      def = "args["+dl.str(o.arg)+"]";
+    } else if (o.signal) {
+      def = parseSignal(o.signal, signals);
+    } else if (o.predicate) {
+      var ref = o.predicate,
+          predName = ref && (ref.name || ref),
+          pred = model.predicate(predName),
+          p = "predicates["+dl.str(predName)+"]";
+
+      pred.signals.forEach(setSignal);
+      pred.data.forEach(setData);
+
+      if (dl.isObject(ref)) {
+        dl.keys(ref).forEach(function(k) {
+          if (k === "name") return;
+          var i = ref[k];
+          def += "args["+dl.str(k)+"] = ";
+          if (i.signal) {
+            def += parseSignal(i.signal, signals);
+          } else if (i.arg) {
+            def += "args["+dl.str(i.arg)+"]";
+          }
+          def += ", ";
+        });  
+      } 
+
+      def += p+".call("+p+", args, db, signals, predicates)";
+    }
+
+    decl.push(name);
+    defs.push(name+"=("+def+")");
+  });
+
+  return {
+    code: "var " + decl.join(", ") + ";\n" + defs.join(";\n") + ";\n",
+    signals: dl.keys(signals),
+    data: dl.keys(db)
+  };
+}
+
+function parseComparator(model, spec) {
+  var ops = parseOperands(model, spec.operands);
+  if (spec.type === '=') spec.type = '==';
+
+  ops.code += "o0 = o0 instanceof Date ? o0.getTime() : o0;\n" +
+    "o1 = o1 instanceof Date ? o1.getTime() : o1;\n";
+
+  return {
+    code: ops.code + "return " + ["o0", "o1"].join(spec.type) + ";",
+    signals: ops.signals,
+    data: ops.data
+  };
+}
+
+function parseLogical(model, spec) {
+  var ops = parseOperands(model, spec.operands),
+      o = [], i = 0, len = spec.operands.length;
+
+  while (o.push("o"+i++) < len);
+  if (spec.type === 'and') spec.type = '&&';
+  else if (spec.type === 'or') spec.type = '||';
+
+  return {
+    code: ops.code + "return " + o.join(spec.type) + ";",
+    signals: ops.signals,
+    data: ops.data
+  };
+}
+
+function parseIn(model, spec) {
+  var o = [spec.item], code = "";
+  if (spec.range) o.push.apply(o, spec.range);
+  if (spec.scale) {
+    code = parseScale(spec.scale, o);
+  }
+
+  var ops = parseOperands(model, o);
+  code = ops.code + code + "\n  var ordSet = null;\n";
+
+  if (spec.data) {
+    var field = dl.field(spec.field).map(dl.str);
+    code += "var where = function(d) { return d["+field.join("][")+"] == o0 };\n";
+    code += "return db["+dl.str(spec.data)+"].filter(where).length > 0;";
+  } else if (spec.range) {
+    // TODO: inclusive/exclusive range?
+    if (spec.scale) {
+      code += "if (scale.length == 2) {\n" + // inverting ordinal scales
+        "  ordSet = scale(o1, o2);\n" +
+        "} else {\n" +
+        "  o1 = scale(o1);\no2 = scale(o2);\n" +
+        "}";
+    }
+
+    code += "return ordSet !== null ? ordSet.indexOf(o0) !== -1 :\n" + 
+      "  o1 < o2 ? o1 <= o0 && o0 <= o2 : o2 <= o0 && o0 <= o1;";
+  }
+
+  return {
+    code: code, 
+    signals: ops.signals, 
+    data: ops.data.concat(spec.data ? [spec.data] : [])
+  };
+}
+
+// Populate ops such that ultimate scale/inversion function will be in `scale` var. 
+function parseScale(spec, ops) {
+  var code = "var scale = ", 
+      idx  = ops.length;
+
+  if (dl.isString(spec)) {
+    ops.push({ value: spec });
+    code += "this.root().scale(o"+idx+")";
+  } else if (spec.arg) {  // Scale function is being passed as an arg
+    ops.push(spec);
+    code += "o"+idx;
+  } else if (spec.name) { // Full scale parameter {name: ..}
+    ops.push(dl.isString(spec.name) ? {value: spec.name} : spec.name);
+    code += "(this.isFunction(o"+idx+") ? o"+idx+" : ";
+    if (spec.scope) {
+      ops.push(spec.scope);
+      code += "((o"+(idx+1)+".scale || this.root().scale)(o"+idx+") || this.nullScale)";
+    } else {
+      code += "this.root().scale(o"+idx+")";
+    }
+    code += ")";
+  }
+
+  if (spec.invert === true) {  // Allow spec.invert.arg?
+    code += ".invert";
+  }
+
+  return code+";\n";
+}
+
+module.exports = parsePredicates;
+},{"datalib":24}],102:[function(require,module,exports){
+(function (global){
+var d3 = (typeof window !== "undefined" ? window['d3'] : typeof global !== "undefined" ? global['d3'] : null),
+    dl = require('datalib'),
+    log = require('vega-logging'),
+    Tuple = require('vega-dataflow').Tuple;
+
+var DEPS = ["signals", "scales", "data", "fields"];
+
+function properties(model, mark, spec) {
+  var config = model.config(),
+      code = "",
+      names = dl.keys(spec),
+      i, len, name, ref, vars = {}, 
+      deps = {
+        signals: {},
+        scales:  {},
+        data:    {},
+        fields:  {},
+        nested:  [],
+        _nRefs:  {},  // Temp stash to de-dupe nested refs.
+        reflow:  false
+      };
+      
+  code += "var o = trans ? {} : item, d=0, set=this.tpl.set, tmpl=signals||{}, t;\n" +
+          // Stash for dl.template
+          "tmpl.datum  = item.datum;\n" + 
+          "tmpl.group  = group;\n" + 
+          "tmpl.parent = group.datum;\n";
+
+  function handleDep(p) {
+    if (ref[p] == null) return;
+    var k = dl.array(ref[p]), i, n;
+    for (i=0, n=k.length; i<n; ++i) {
+      deps[p][k[i]] = 1;
+    }
+  }
+
+  function handleNestedRefs(r) {
+    var k = (r.parent ? "parent_" : "group_")+r.level;
+    deps._nRefs[k] = r;
+  }
+
+  for (i=0, len=names.length; i<len; ++i) {
+    ref = spec[name = names[i]];
+    code += (i > 0) ? "\n  " : "  ";
+    if (ref.rule) {
+      ref = rule(model, name, ref.rule);
+      code += "\n  " + ref.code;
+    } else {
+      ref = valueRef(config, name, ref);
+      code += "d += set(o, "+dl.str(name)+", "+ref.val+");";
+    }
+
+    vars[name] = true;
+    DEPS.forEach(handleDep);
+    deps.reflow = deps.reflow || ref.reflow;
+    if (ref.nested.length) ref.nested.forEach(handleNestedRefs);
+  }
+
+  // If nested references are present, sort them based on their level
+  // to speed up determination of whether encoders should be reeval'd.
+  dl.keys(deps._nRefs).forEach(function(k) { deps.nested.push(deps._nRefs[k]); });
+  deps.nested.sort(function(a, b) { 
+    a = a.level;
+    b = b.level;
+    return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN; 
+  });
+
+  if (vars.x2) {
+    if (vars.x) {
+      code += "\n  if (o.x > o.x2) { " +
+              "\n    t = o.x;" +
+              "\n    d += set(o, 'x', o.x2);" +
+              "\n    d += set(o, 'x2', t); " +
+              "\n  };";
+      code += "\n  d += set(o, 'width', (o.x2 - o.x));";
+    } else if (vars.width) {
+      code += "\n  d += set(o, 'x', (o.x2 - o.width));";
+    } else {
+      code += "\n  d += set(o, 'x', o.x2);";
+    }
+  }
+
+  if (vars.xc) {
+    if (vars.width) {
+      code += "\n  d += set(o, 'x', (o.xc - o.width/2));" ;
+    } else {
+      code += "\n  d += set(o, 'x', o.xc);" ;
+    }
+  }
+
+  if (vars.y2) {
+    if (vars.y) {
+      code += "\n  if (o.y > o.y2) { " +
+              "\n    t = o.y;" +
+              "\n    d += set(o, 'y', o.y2);" +
+              "\n    d += set(o, 'y2', t);" +
+              "\n  };";
+      code += "\n  d += set(o, 'height', (o.y2 - o.y));";
+    } else if (vars.height) {
+      code += "\n  d += set(o, 'y', (o.y2 - o.height));";
+    } else {
+      code += "\n  d += set(o, 'y', o.y2);";
+    }
+  }
+
+  if (vars.yc) {
+    if (vars.height) {
+      code += "\n  d += set(o, 'y', (o.yc - o.height/2));" ;
+    } else {
+      code += "\n  d += set(o, 'y', o.yc);" ;
+    }
+  }
+  
+  if (hasPath(mark, vars)) code += "\n  d += (item.touch(), 1);";
+  code += "\n  if (trans) trans.interpolate(item, o);";
+  code += "\n  return d > 0;";
+
+  try {
+    /* jshint evil:true */
+    var encoder = Function('item', 'group', 'trans', 'db', 
+      'signals', 'predicates', code);
+    encoder.tpl  = Tuple;
+    encoder.util = dl;
+    encoder.d3   = d3; // For color spaces
+    dl.extend(encoder, dl.template.context);
+    return {
+      encode:  encoder,
+      signals: dl.keys(deps.signals),
+      scales:  dl.keys(deps.scales),
+      data:    dl.keys(deps.data),
+      fields:  dl.keys(deps.fields),
+      nested:  deps.nested,
+      reflow:  deps.reflow
+    };
+  } catch (e) {
+    log.error(e);
+    log.log(code);
+  }
+}
+
+function dependencies(a, b) {
+  if (!dl.isObject(a)) {
+    a = {reflow: false, nested: []};
+    DEPS.forEach(function(d) { a[d] = []; });
+  }
+
+  if (dl.isObject(b)) {
+    a.reflow = a.reflow || b.reflow;
+    a.nested.push.apply(a.nested, b.nested);
+    DEPS.forEach(function(d) { a[d].push.apply(a[d], b[d]); });
+  }
+
+  return a;
+}
+
+function hasPath(mark, vars) {
+  return vars.path ||
+    ((mark==='area' || mark==='line') &&
+      (vars.x || vars.x2 || vars.width ||
+       vars.y || vars.y2 || vars.height ||
+       vars.tension || vars.interpolate));
+}
+
+function rule(model, name, rules) {
+  var config  = model.config(),
+      deps = dependencies(),
+      inputs  = [], code = '';
+
+  (rules||[]).forEach(function(r, i) {
+    var def = r.predicate,
+        predName = def && (def.name || def),
+        pred = model.predicate(predName),
+        p = 'predicates['+dl.str(predName)+']',
+        input = [], args = name+'_arg'+i,
+        ref;
+
+    if (dl.isObject(def)) {
+      dl.keys(def).forEach(function(k) {
+        if (k === 'name') return;
+        var ref = valueRef(config, i, def[k]);
+        input.push(dl.str(k)+': '+ref.val);
+        dependencies(deps, ref);
+      });
+    }
+
+    ref = valueRef(config, name, r);
+    dependencies(deps, ref);
+
+    if (predName) {
+      deps.signals.push.apply(deps.signals, pred.signals);
+      deps.data.push.apply(deps.data, pred.data);
+      inputs.push(args+" = {\n    "+input.join(",\n    ")+"\n  }");
+      code += "if ("+p+".call("+p+","+args+", db, signals, predicates)) {" +
+        "\n    d += set(o, "+dl.str(name)+", "+ref.val+");";
+      code += rules[i+1] ? "\n  } else " : "  }";
+    } else {
+      code += "{" + 
+        "\n    d += set(o, "+dl.str(name)+", "+ref.val+");"+
+        "\n  }\n";
+    }
+  });
+
+  code = "var " + inputs.join(",\n      ") + ";\n  " + code;
+  return (deps.code = code, deps);
+}
+
+function valueRef(config, name, ref) {
+  if (ref == null) return null;
+
+  if (name==='fill' || name==='stroke') {
+    if (ref.c) {
+      return colorRef(config, 'hcl', ref.h, ref.c, ref.l);
+    } else if (ref.h || ref.s) {
+      return colorRef(config, 'hsl', ref.h, ref.s, ref.l);
+    } else if (ref.l || ref.a) {
+      return colorRef(config, 'lab', ref.l, ref.a, ref.b);
+    } else if (ref.r || ref.g || ref.b) {
+      return colorRef(config, 'rgb', ref.r, ref.g, ref.b);
+    }
+  }
+
+  // initialize value
+  var val = null, scale = null, 
+      deps = dependencies(),
+      sgRef = null, fRef = null, sRef = null, tmpl = {};
+
+  if (ref.template !== undefined) {
+    val = dl.template.source(ref.template, 'tmpl', tmpl);
+    dl.keys(tmpl).forEach(function(k) {
+      var f = dl.field(k),
+          a = f.shift();
+      if (a === 'parent' || a === 'group') {
+        deps.nested.push({ 
+          parent: a === 'parent',
+          group:  a === 'group', 
+          level:  1
+        });
+      } else if (a === 'datum') {
+        deps.fields.push(f[0]);
+      } else {
+        deps.signals.push(a);
+      }
+    });
+  }
+
+  if (ref.value !== undefined) {
+    val = dl.str(ref.value);
+  }
+
+  if (ref.signal !== undefined) {
+    sgRef = dl.field(ref.signal);
+    val = 'signals['+sgRef.map(dl.str).join('][')+']'; 
+    deps.signals.push(sgRef.shift());
+  }
+
+  if (ref.field !== undefined) {
+    ref.field = dl.isString(ref.field) ? {datum: ref.field} : ref.field;
+    fRef = fieldRef(ref.field);
+    val  = fRef.val;
+    dependencies(deps, fRef);
+  }
+
+  if (ref.scale !== undefined) {
+    sRef  = scaleRef(ref.scale);
+    scale = sRef.val;
+    dependencies(deps, sRef);
+    deps.scales.push(ref.scale.name || ref.scale);
+
+    // run through scale function if val specified.
+    // if no val, scale function is predicate arg.
+    if (val !== null || ref.band || ref.mult || ref.offset) {
+      val = scale + (ref.band ? '.rangeBand()' : 
+        '('+(val !== null ? val : 'item.datum.data')+')');
+    } else {
+      val = scale;
+    }
+  }
+  
+  // multiply, offset, return value
+  val = '(' + (ref.mult?(dl.number(ref.mult)+' * '):'') + val + ')' +
+        (ref.offset ? ' + ' + dl.number(ref.offset) : '');
+
+  // Collate dependencies
+  return (deps.val = val, deps);
+}
+
+function colorRef(config, type, x, y, z) {
+  var xx = x ? valueRef(config, '', x) : config.color[type][0],
+      yy = y ? valueRef(config, '', y) : config.color[type][1],
+      zz = z ? valueRef(config, '', z) : config.color[type][2],
+      deps = dependencies();
+
+  [xx, yy, zz].forEach(function(v) {
+    if (dl.isArray) return;
+    dependencies(deps, v);
+  });
+
+  var val = '(this.d3.' + type + '(' + [xx.val, yy.val, zz.val].join(',') + ') + "")';
+  return (deps.val = val, deps);
+}
+
+// {field: {datum: "foo"} }  -> item.datum.foo
+// {field: {group: "foo"} }  -> group.foo
+// {field: {parent: "foo"} } -> group.datum.foo
+function fieldRef(ref) {
+  if (dl.isString(ref)) {
+    return {val: dl.field(ref).map(dl.str).join('][')};
+  } 
+
+  // Resolve nesting/parent lookups
+  var l = ref.level || 1,
+      nested = (ref.group || ref.parent) && l,
+      scope = nested ? Array(l).join('group.mark.') : '',
+      r = fieldRef(ref.datum || ref.group || ref.parent || ref.signal),
+      val = r.val,
+      deps = dependencies(null, r);
+
+  if (ref.datum) {
+    val = 'item.datum['+val+']';
+    deps.fields.push(ref.datum);
+  } else if (ref.group) {
+    val = scope+'group['+val+']';
+    deps.nested.push({ level: l, group: true });
+  } else if (ref.parent) {
+    val = scope+'group.datum['+val+']';
+    deps.nested.push({ level: l, parent: true });
+  } else if (ref.signal) {
+    val = 'signals['+val+']';
+    deps.signals.push(dl.field(ref.signal)[0]);
+    deps.reflow = true;
+  }
+
+  return (deps.val = val, deps);
+}
+
+// {scale: "x"}
+// {scale: {name: "x"}},
+// {scale: fieldRef}
+function scaleRef(ref) {
+  var scale = null,
+      fr = null,
+      deps = dependencies();
+
+  if (dl.isString(ref)) {
+    scale = dl.str(ref);
+  } else if (ref.name) {
+    scale = dl.isString(ref.name) ? dl.str(ref.name) : (fr = fieldRef(ref.name)).val;
+  } else {
+    scale = (fr = fieldRef(ref)).val;
+  }
+
+  scale = '(item.mark._scaleRefs['+scale+'] = 1, group.scale('+scale+'))';
+  if (ref.invert) scale += '.invert';
+
+  // Mark scale refs as they're dealt with separately in mark._scaleRefs.
+  if (fr) fr.nested.forEach(function(g) { g.scale = true; });
+  return fr ? (fr.val = scale, fr) : (deps.val = scale, deps);
+}
+
+module.exports = properties;
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{"datalib":24,"vega-dataflow":39,"vega-logging":45}],103:[function(require,module,exports){
+var dl = require('datalib'),
+    SIGNALS = require('vega-dataflow').Dependencies.SIGNALS,
+    expr = require('./expr');
+
+var RESERVED = ['datum', 'event', 'signals']
+  .concat(dl.keys(expr.codegen.functions));
+
+function parseSignals(model, spec) {
+  // process each signal definition
+  (spec || []).forEach(function(s) {
+    if (RESERVED.indexOf(s.name) !== -1) {
+      throw Error('Signal name "'+s.name+'" is a '+
+        'reserved keyword ('+RESERVED.join(', ')+').');
+    }
+
+    var signal = model.signal(s.name, s.init)
+      .verbose(s.verbose);
+
+    if (s.init && s.init.expr) {
+      s.init.expr = expr(s.init.expr);
+      signal.value(exprVal(model, s.init));
+    }
+
+    if (s.expr) {
+      s.expr = expr(s.expr);
+      signal.evaluate = function(input) {
+        var val = exprVal(model, s);
+        if (val !== signal.value() || signal.verbose()) {
+          signal.value(val);
+          input.signals[s.name] = 1;
+          return input;
+        }
+        return model.doNotPropagate;        
+      };
+      signal.dependency(SIGNALS, s.expr.globals);
+      s.expr.globals.forEach(function(dep) {
+        model.signal(dep).addListener(signal);
+      });
+    }
+  });
+
+  return spec;
+}
+
+function exprVal(model, spec) {
+  var e = spec.expr,
+      val = e.fn(null, null, model.values(SIGNALS, e.globals));
+  return spec.scale ? parseSignals.scale(model, spec, val) : val;
+}
+
+parseSignals.scale = function scale(model, spec, value, datum, evt) {
+  var def = spec.scale,
+      name  = def.name || def.signal || def,
+      scope = def.scope, e;
+
+  if (scope) {
+    if (scope.signal) {
+      scope = model.signalRef(scope.signal);
+    } else if (dl.isString(scope)) { // Scope is an expression
+      e = def._expr = (def._expr || expr(scope));
+      scope = e.fn(datum, evt, model.values(SIGNALS, e.globals));
+    }
+  }
+
+  if (!scope || !scope.scale) {
+    scope = (scope && scope.mark) ? scope.mark.group : model.scene().items[0];
+  }
+
+  var s = scope.scale(name);
+  return !s ? value : (def.invert ? s.invert(value) : s(value));
+};
+
+module.exports = parseSignals;
+},{"./expr":94,"datalib":24,"vega-dataflow":39}],104:[function(require,module,exports){
+var dl = require('datalib'),
+    log = require('vega-logging'),
+    Model = require('../core/Model'),
+    View = require('../core/View');
+
+function parseSpec(spec, callback) {
+  var vf = arguments[arguments.length-1],
+      viewFactory = arguments.length > 2 && dl.isFunction(vf) ? vf : View.factory,
+      config = arguments[2] !== viewFactory ? arguments[2] : {},
+      model = new Model(config);
+
+  function parse(spec) {
+    // protect against subsequent spec modification
+    spec = dl.duplicate(spec);
+
+    var parsers = require('./'),
+        width = spec.width || 500,
+        height = spec.height || 500,
+        viewport = spec.viewport || null;
+
+    model.defs({
+      width: width,
+      height: height,
+      viewport: viewport,
+      background: parsers.background(spec.background),
+      padding: parsers.padding(spec.padding),
+      signals: parsers.signals(model, spec.signals),
+      predicates: parsers.predicates(model, spec.predicates),
+      marks: parsers.marks(model, spec, width, height),
+      data: parsers.data(model, spec.data, function() {
+        callback(viewFactory(model));
+      })
+    });    
+  }
+
+  if (dl.isObject(spec)) {
+    parse(spec);
+  } else if (dl.isString(spec)) {
+    var opts = dl.extend({url: spec}, model.config().load);
+    dl.load(opts, function(err, data) {
+      if (err) {
+        log.error('LOADING SPECIFICATION FAILED: ' + err.statusText);
+      } else {
+        try { 
+          parse(JSON.parse(data)); 
+        } catch (e) { 
+          log.error('INVALID SPECIFICATION: Must be a valid JSON object. '+e); 
+        }
+      }
+    });
+  } else {
+    log.error('INVALID SPECIFICATION: Must be a valid JSON object or URL.');
+  }
+}
+
+module.exports = parseSpec;
+},{"../core/Model":86,"../core/View":87,"./":95,"datalib":24,"vega-logging":45}],105:[function(require,module,exports){
+(function (global){
+var d3 = (typeof window !== "undefined" ? window['d3'] : typeof global !== "undefined" ? global['d3'] : null),
+    dl = require('datalib'),
+    df = require('vega-dataflow'),
+    SIGNALS = df.Dependencies.SIGNALS,
+    parseSignals = require('./signals'),
+    selector = require('./events'),
+    expr = require('./expr');
+
+var GATEKEEPER = '_vgGATEKEEPER';
+
+var vgEvent = {
+  getGroup: function(name) { return name ? this.name[name] : this.group; },
+  getXY: function(item) {
+      var p = {x: this.x, y: this.y};
+      if (typeof item === 'string') {
+        item = this.name[item];
+      }
+      for (; item; item = item.mark && item.mark.group) {
+        p.x -= item.x || 0;
+        p.y -= item.y || 0;
+      }
+      return p;
+    },
+  getX: function(item) { return this.getXY(item).x; },
+  getY: function(item) { return this.getXY(item).y; }
+};
+
+function parseStreams(view) {
+  var model = view.model(),
+      spec  = model.defs().signals,
+      registry = {handlers: {}, nodes: {}},
+      internal = dl.duplicate(registry),  // Internal event processing
+      external = dl.duplicate(registry);  // External event processing
+
+  (spec || []).forEach(function(sig) {
+    var signal = model.signal(sig.name);
+    if (sig.expr) return;  // Cannot have an expr and stream definition.
+
+    (sig.streams || []).forEach(function(stream) {
+      var sel = selector.parse(stream.type),
+          exp = expr(stream.expr);
+      mergedStream(signal, sel, exp, stream);
+    });
+  });
+
+  // We register the event listeners all together so that if multiple
+  // signals are registered on the same event, they will receive the
+  // new value on the same pulse. 
+  dl.keys(internal.handlers).forEach(function(type) {
+    view.on(type, function(evt, item) {
+      evt.preventDefault(); // stop text selection
+      extendEvent(evt, item);
+      fire(internal, type, (item && item.datum) || {}, evt);
+    });
+  });
+
+  // add external event listeners
+  dl.keys(external.handlers).forEach(function(type) {
+    if (typeof window === 'undefined') return; // No external support
+
+    var h = external.handlers[type],
+        t = type.split(':'), // --> no element pseudo-selectors
+        elt = (t[0] === 'window') ? [window] :
+              window.document.querySelectorAll(t[0]);
+
+    function handler(evt) {
+      extendEvent(evt);
+      fire(external, type, d3.select(this).datum(), evt);
+    }
+
+    for (var i=0; i<elt.length; ++i) {
+      elt[i].addEventListener(t[1], handler);
+    }
+
+    h.elements = elt;
+    h.listener = handler;
+  });
+
+  // remove external event listeners
+  external.detach = function() {
+    dl.keys(external.handlers).forEach(function(type) {
+      var h = external.handlers[type],
+          t = type.split(':'),
+          elt = h.elements || [];
+
+      for (var i=0; i<elt.length; ++i) {
+        elt[i].removeEventListener(t[1], h.listener);
+      }
+    });
+  };
+
+  // export detach method
+  return external.detach;
+
+  // -- helper functions -----
+
+  function extendEvent(evt, item) {
+    var mouse = d3.mouse((d3.event=evt, view.renderer().scene())),
+        pad = view.padding(),
+        names = {}, mark, group, i;
+
+    if (item) {
+      mark = item.mark;
+      group = mark.marktype === 'group' ? item : mark.group;
+      for (i=item; i!=null; i=i.mark.group) {
+        if (i.mark.def.name) {
+          names[i.mark.def.name] = i;
+        }
+      }
+    }
+    names.root = view.model().scene().items[0];
+
+    evt.vg = Object.create(vgEvent);
+    evt.vg.group = group;
+    evt.vg.item = item || {};
+    evt.vg.name = names;
+    evt.vg.x = mouse[0] - pad.left;
+    evt.vg.y = mouse[1] - pad.top;
+  }
+
+  function fire(registry, type, datum, evt) {
+    var handlers = registry.handlers[type],
+        node = registry.nodes[type],
+        cs = df.ChangeSet.create(null, true),
+        filtered = false,
+        val, i, n, h;
+
+    function invoke(f) {
+      return !f.fn(datum, evt, model.values(SIGNALS, f.globals));
+    }
+
+    for (i=0, n=handlers.length; i<n; ++i) {
+      h = handlers[i];
+      filtered = h.filters.some(invoke);
+      if (filtered) continue;
+      
+      val = h.exp.fn(datum, evt, model.values(SIGNALS, h.exp.globals));
+      if (h.spec.scale) {
+        val = parseSignals.scale(model, h.spec, val, datum, evt);
+      }
+
+      if (val !== h.signal.value() || h.signal.verbose()) {
+        h.signal.value(val);
+        cs.signals[h.signal.name()] = 1;
+      }
+    }
+
+    model.propagate(cs, node);
+  }
+
+  function mergedStream(sig, selector, exp, spec) {
+    selector.forEach(function(s) {
+      if (s.event)       domEvent(sig, s, exp, spec);
+      else if (s.signal) signal(sig, s, exp, spec);
+      else if (s.start)  orderedStream(sig, s, exp, spec);
+      else if (s.stream) mergedStream(sig, s.stream, exp, spec);
+    });
+  }
+
+  function domEvent(sig, selector, exp, spec) {
+    var evt = selector.event,
+        name = selector.name,
+        mark = selector.mark,
+        target   = selector.target,
+        filters  = selector.filters || [],
+        registry = target ? external : internal,
+        type = target ? target+':'+evt : evt,
+        node = registry.nodes[type] || (registry.nodes[type] = new df.Node(model)),
+        handlers = registry.handlers[type] || (registry.handlers[type] = []);
+
+    if (name) {
+      filters.push('!!event.vg.name["' + name + '"]'); // Mimic event bubbling
+    } else if (mark) {
+      filters.push('event.vg.item.mark && event.vg.item.mark.marktype==='+dl.str(mark));
+    }
+
+    handlers.push({
+      signal: sig,
+      exp: exp,
+      spec: spec,
+      filters: filters.map(function(f) { return expr(f); })
+    });
+
+    node.addListener(sig);
+  }
+
+  function signal(sig, selector, exp, spec) {
+    var n = new df.Node(model);
+    n.evaluate = function(input) {
+      if (!input.signals[selector.signal]) return model.doNotPropagate;
+      var val = exp.fn(null, null, model.values(SIGNALS, exp.globals));
+      if (spec.scale) {
+        val = parseSignals.scale(model, spec, val);
+      }
+
+      if (val !== sig.value() || sig.verbose()) {
+        sig.value(val);
+        input.signals[sig.name()] = 1;
+        input.reflow = true;        
+      }
+
+      return input;  
+    };
+    n.dependency(df.Dependencies.SIGNALS, selector.signal);
+    n.addListener(sig);
+    model.signal(selector.signal).addListener(n);
+  }
+
+  function orderedStream(sig, selector, exp, spec) {
+    var name = sig.name(), 
+        gk = name + GATEKEEPER, 
+        trueFn  = expr('true'), 
+        falseFn = expr('false'),
+        middle  = selector.middle,
+        filters = middle.filters || (middle.filters = []),
+        gatekeeper = model.signal(gk) || model.signal(gk, false);
+
+    // Register an anonymous signal to act as a gatekeeper. Its value is
+    // true or false depending on whether the start or end streams occur. 
+    // The middle signal then simply filters for the gatekeeper's value. 
+    mergedStream(gatekeeper, [selector.start], trueFn, {});
+    mergedStream(gatekeeper, [selector.end], falseFn, {});
+
+    filters.push(gatekeeper.name());
+    mergedStream(sig, [selector.middle], exp, spec);
+  }
+}
+
+module.exports = parseStreams;
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{"./events":93,"./expr":94,"./signals":103,"datalib":24,"vega-dataflow":39}],106:[function(require,module,exports){
+var dl = require('datalib'),
+    transforms = require('../transforms/index');
+
+function parseTransforms(model, def) {
+  var tx = new transforms[def.type](model);
+  
+  // We want to rename output fields before setting any other properties,
+  // as subsequent properties may require output to be set (e.g. group by).
+  if(def.output) tx.output(def.output);
+
+  dl.keys(def).forEach(function(k) {
+    if(k === 'type' || k === 'output') return;
+    tx.param(k, def[k]);
+  });
+
+  return tx;
+}
+
+module.exports = parseTransforms;
+},{"../transforms/index":139,"datalib":24}],107:[function(require,module,exports){
+var dl = require('datalib'),
+    df = require('vega-dataflow'),
+    Node = df.Node, // jshint ignore:line
+    log = require('vega-logging'),
+    bound = require('vega-scenegraph').bound,
+    Encoder = require('./Encoder');
+
+function Bounder(graph, mark) {
+  this._mark = mark;
+  return Node.prototype.init.call(this, graph)
+    .router(true)
+    .reflows(true)
+    .mutates(true);
+}
+
+var proto = (Bounder.prototype = new Node());
+
+proto.evaluate = function(input) {
+  log.debug(input, ['bounds', this._mark.marktype]);
+
+  var type  = this._mark.marktype,
+      isGrp = type === 'group',
+      items = this._mark.items,
+      hasLegends = dl.array(this._mark.def.legends).length > 0,
+      i, ilen, j, jlen, group, legend;
+
+  if (input.add.length || input.rem.length || !items.length || 
+      input.mod.length === items.length ||
+      type === 'area' || type === 'line') {
+    bound.mark(this._mark, null, isGrp && !hasLegends);
+  } else {
+    input.mod.forEach(function(item) { bound.item(item); });
+  }
+
+  if (isGrp && hasLegends) {
+    for (i=0, ilen=items.length; i<ilen; ++i) {
+      group = items[i];
+      group._legendPositions = null;
+      for (j=0, jlen=group.legendItems.length; j<jlen; ++j) {
+        legend = group.legendItems[j];
+        Encoder.update(this._graph, input.trans, 'vg_legendPosition', legend.items, input.dirty);
+        bound.mark(legend, null, false);
+      }
+    }
+
+    bound.mark(this._mark, null, true);
+  }
+
+  return df.ChangeSet.create(input, true);
+};
+
+module.exports = Bounder;
+},{"./Encoder":109,"datalib":24,"vega-dataflow":39,"vega-logging":45,"vega-scenegraph":46}],108:[function(require,module,exports){
+var dl = require('datalib'),
+    log = require('vega-logging'),
+    Item = require('vega-scenegraph').Item,
+    df = require('vega-dataflow'),
+    Node = df.Node, // jshint ignore:line
+    Deps = df.Dependencies,
+    Tuple = df.Tuple,
+    ChangeSet = df.ChangeSet,
+    Sentinel = {},
+    Encoder  = require('./Encoder'),
+    Bounder  = require('./Bounder'),
+    parseData = require('../parse/data');
+
+function Builder() {    
+  return arguments.length ? this.init.apply(this, arguments) : this;
+}
+
+var Status = Builder.STATUS = {
+  ENTER:  'enter',
+  UPDATE: 'update',
+  EXIT:   'exit'
+};
+
+var CONNECTED = 1, DISCONNECTED = 2;
+
+var proto = (Builder.prototype = new Node());
+
+proto.init = function(graph, def, mark, parent, parent_id, inheritFrom) {
+  Node.prototype.init.call(this, graph)
+    .router(true)
+    .collector(true);
+
+  this._def   = def;
+  this._mark  = mark;
+  this._from  = (def.from ? def.from.data : null) || inheritFrom;
+  this._ds    = dl.isString(this._from) ? graph.data(this._from) : null;
+  this._map   = {};
+  this._status = null; // Connected or disconnected?
+
+  mark.def = def;
+  mark.marktype = def.type;
+  mark.interactive = (def.interactive !== false);
+  mark.items = [];
+  if (dl.isValid(def.name)) mark.name = def.name;
+
+  this._parent = parent;
+  this._parent_id = parent_id;
+
+  if (def.from && (def.from.mark || def.from.transform || def.from.modify)) {
+    inlineDs.call(this);
+  }
+
+  // Non-group mark builders are super nodes. Encoder and Bounder remain 
+  // separate operators but are embedded and called by Builder.evaluate.
+  this._isSuper = (this._def.type !== 'group'); 
+  this._encoder = new Encoder(this._graph, this._mark, this);
+  this._bounder = new Bounder(this._graph, this._mark);
+  this._output  = null; // Output changeset for reactive geom as Bounder reflows
+
+  if (this._ds) { this._encoder.dependency(Deps.DATA, this._from); }
+
+  // Since Builders are super nodes, copy over encoder dependencies
+  // (bounder has no registered dependencies).
+  this.dependency(Deps.DATA, this._encoder.dependency(Deps.DATA));
+  this.dependency(Deps.SCALES, this._encoder.dependency(Deps.SCALES));
+  this.dependency(Deps.SIGNALS, this._encoder.dependency(Deps.SIGNALS));
+
+  return this;
+};
+
+// Reactive geometry and mark-level transformations are handled here 
+// because they need their group's data-joined context. 
+function inlineDs() {
+  var from = this._def.from,
+      geom = from.mark,
+      src, name, spec, sibling, output, input;
+
+  if (geom) {
+    name = ['vg', this._parent_id, geom].join('_');
+    spec = {
+      name: name,
+      transform: from.transform, 
+      modify: from.modify
+    };
+  } else {
+    src = this._graph.data(this._from);
+    name = ['vg', this._from, this._def.type, src.listeners(true).length].join('_');
+    spec = {
+      name: name,
+      source: this._from,
+      transform: from.transform,
+      modify: from.modify
+    };
+  }
+
+  this._from = name;
+  this._ds = parseData.datasource(this._graph, spec);
+  var node;
+
+  if (geom) {
+    sibling = this.sibling(geom);
+
+    // Bounder reflows, so we need an intermediary node to propagate
+    // the output constructed by the Builder.
+    node = new Node(this._graph).addListener(this._ds.listener());
+    node.evaluate = function() { return sibling._output; };
+
+    if (sibling._isSuper) {
+      sibling.addListener(node);
+    } else {
+      sibling._bounder.addListener(node);
+    }
+  } else {
+    // At this point, we have a new datasource but it is empty as
+    // the propagation cycle has already crossed the datasources. 
+    // So, we repulse just this datasource. This should be safe
+    // as the ds isn't connected to the scenegraph yet.
+    output = this._ds.source().last();
+    input  = ChangeSet.create(output);
+
+    input.add = output.add;
+    input.mod = output.mod;
+    input.rem = output.rem;
+    input.stamp = null;
+    this._graph.propagate(input, this._ds.listener(), output.stamp);
+  }
+}
+
+proto.ds = function() { return this._ds; };
+proto.parent   = function() { return this._parent; };
+proto.encoder  = function() { return this._encoder; };
+proto.pipeline = function() { return [this]; };
+
+proto.connect = function() {
+  var builder = this;
+
+  this._graph.connect(this.pipeline());
+  this._encoder._scales.forEach(function(s) {
+    if (!(s = builder._parent.scale(s))) return;
+    s.addListener(builder);
+  });
+
+  if (this._parent) {
+    if (this._isSuper) this.addListener(this._parent._collector);
+    else this._bounder.addListener(this._parent._collector);
+  }
+
+  return (this._status = CONNECTED, this);
+};
+
+proto.disconnect = function() {
+  var builder = this;
+  if (!this._listeners.length) return this;
+
+  function disconnectScales(scales) {
+    for(var i=0, len=scales.length, s; i<len; ++i) {
+      if (!(s = builder._parent.scale(scales[i]))) continue;
+      s.removeListener(builder);
+    }
+  }
+
+  Node.prototype.disconnect.call(this);
+  this._graph.disconnect(this.pipeline());
+  disconnectScales(this._encoder._scales);
+  disconnectScales(dl.keys(this._mark._scaleRefs));
+  
+  return (this._status = DISCONNECTED, this);
+};
+
+proto.sibling = function(name) {
+  return this._parent.child(name, this._parent_id);
+};
+
+proto.evaluate = function(input) {
+  log.debug(input, ['building', (this._from || this._def.from), this._def.type]);
+
+  var self = this,
+      def = this._mark.def,
+      props  = def.properties || {},
+      update = props.update   || {},
+      output, fullUpdate, fcs, data, name;
+
+  if (this._ds) {
+    output = ChangeSet.create(input);
+
+    // We need to determine if any encoder dependencies have been updated.
+    // However, the encoder's data source will likely be updated, and shouldn't
+    // trigger all items to mod.
+    data = output.data[(name=this._ds.name())];
+    delete output.data[name];
+    fullUpdate = this._encoder.reevaluate(output);
+    output.data[name] = data;
+
+    // If a scale or signal in the update propset has been updated, 
+    // send forward all items for reencoding if we do an early return.
+    if (fullUpdate) output.mod = this._mark.items.slice();
+
+    fcs = this._ds.last();
+    if (!fcs) throw Error('Builder evaluated before backing DataSource.');
+    if (fcs.stamp > this._stamp) {
+      output = join.call(this, fcs, this._ds.values(), true, fullUpdate);
+    }
+  } else {
+    data = dl.isFunction(this._def.from) ? this._def.from() : [Sentinel];
+    output = join.call(this, input, data);
+  }
+
+  // Stash output before Bounder for downstream reactive geometry.
+  this._output = output = this._graph.evaluate(output, this._encoder);
+
+  // Add any new scale references to the dependency list, and ensure
+  // they're connected.
+  if (update.nested && update.nested.length && this._status === CONNECTED) {
+    dl.keys(this._mark._scaleRefs).forEach(function(s) {
+      var scale = self._parent.scale(s);
+      if (!scale) return;
+
+      scale.addListener(self);
+      self.dependency(Deps.SCALES, s);
+      self._encoder.dependency(Deps.SCALES, s);
+    });
+  }
+
+  // Supernodes calculate bounds too, but only on items marked dirty.
+  if (this._isSuper) {
+    output.mod = output.mod.filter(function(x) { return x._dirty; });
+    output = this._graph.evaluate(output, this._bounder);
+  }
+
+  return output;
+};
+
+function newItem() {
+  var item = Tuple.ingest(new Item(this._mark));
+
+  // For the root node's item
+  if (this._def.width)  Tuple.set(item, 'width',  this._def.width);
+  if (this._def.height) Tuple.set(item, 'height', this._def.height);
+  return item;
+}
+
+function join(input, data, ds, fullUpdate) {
+  var output = ChangeSet.create(input),
+      keyf = keyFunction(this._def.key || (ds ? '_id' : null)),
+      prev = this._mark.items || [],
+      rem  = ds ? input.rem : prev,
+      mod  = Tuple.idMap((!ds || fullUpdate) ? data : input.mod),
+      next = [],
+      i, key, len, item, datum, enter, diff;
+
+  // Only mark rems as exiting. Due to keyf, there may be an add/mod 
+  // tuple that replaces it.
+  for (i=0, len=rem.length; i<len; ++i) {
+    item = (rem[i] === prev[i]) ? prev[i] :
+      keyf ? this._map[keyf(rem[i])] : rem[i];
+    item.status = Status.EXIT;
+  }
+
+  for(i=0, len=data.length; i<len; ++i) {
+    datum = data[i];
+    item  = keyf ? this._map[key = keyf(datum)] : prev[i];
+    enter = item ? false : (item = newItem.call(this), true);
+    item.status = enter ? Status.ENTER : Status.UPDATE;
+    diff = !enter && item.datum !== datum;
+    item.datum = datum;
+
+    if (keyf) {
+      Tuple.set(item, 'key', key);
+      this._map[key] = item;
+    }
+
+    if (enter) {
+      output.add.push(item);
+    } else if (diff || mod[datum._id]) {
+      output.mod.push(item);
+    }
+
+    next.push(item);
+  }
+
+  for (i=0, len=rem.length; i<len; ++i) {
+    item = (rem[i] === prev[i]) ? prev[i] :
+      keyf ? this._map[key = keyf(rem[i])] : rem[i];
+    if (item.status === Status.EXIT) {
+      item._dirty = true;
+      input.dirty.push(item);
+      next.push(item);
+      output.rem.push(item);
+      if (keyf) this._map[key] = null;
+    }
+  }
+
+  return (this._mark.items = next, output);
+}
+
+function keyFunction(key) {
+  if (key == null) return null;
+  var f = dl.array(key).map(dl.accessor);
+  return function(d) {
+    for (var s='', i=0, n=f.length; i<n; ++i) {
+      if (i>0) s += '|';
+      s += String(f[i](d));
+    }
+    return s;
+  };
+}
+
+module.exports = Builder;
+},{"../parse/data":92,"./Bounder":107,"./Encoder":109,"datalib":24,"vega-dataflow":39,"vega-logging":45,"vega-scenegraph":46}],109:[function(require,module,exports){
+var dl = require('datalib'),
+    log = require('vega-logging'),
+    df = require('vega-dataflow'),
+    Node = df.Node, // jshint ignore:line
+    Deps = df.Dependencies,
+    bound = require('vega-scenegraph').bound;
+
+var EMPTY = {};
+
+function Encoder(graph, mark, builder) {
+  var props  = mark.def.properties || {},
+      enter  = props.enter,
+      update = props.update,
+      exit   = props.exit;
+
+  Node.prototype.init.call(this, graph);
+
+  this._mark = mark;
+  this._builder = builder;
+  var s = this._scales = [];
+
+  // Only scales used in the 'update' property set are set as
+  // encoder depedencies to have targeted reevaluations. However,
+  // we still want scales in 'enter' and 'exit' to be evaluated
+  // before the encoder. 
+  if (enter) s.push.apply(s, enter.scales);
+
+  if (update) {
+    this.dependency(Deps.DATA, update.data);
+    this.dependency(Deps.SIGNALS, update.signals);
+    this.dependency(Deps.FIELDS, update.fields);
+    this.dependency(Deps.SCALES, update.scales);
+    s.push.apply(s, update.scales);
+  }
+
+  if (exit) s.push.apply(s, exit.scales);
+
+  return this.mutates(true);
+}
+
+var proto = (Encoder.prototype = new Node());
+
+proto.evaluate = function(input) {
+  log.debug(input, ['encoding', this._mark.def.type]);
+  var graph = this._graph,
+      props = this._mark.def.properties || {},
+      items = this._mark.items,
+      enter  = props.enter,
+      update = props.update,
+      exit   = props.exit,
+      dirty  = input.dirty,
+      preds  = graph.predicates(),
+      req = input.request,
+      group = this._mark.group,
+      guide = group && (group.mark.axis || group.mark.legend),
+      db = EMPTY, sg = EMPTY, i, len, item, prop;
+
+  if (req && !guide) {
+    if ((prop = props[req]) && input.mod.length) {
+      db = prop.data ? graph.values(Deps.DATA, prop.data) : null;
+      sg = prop.signals ? graph.values(Deps.SIGNALS, prop.signals) : null;
+
+      for (i=0, len=input.mod.length; i<len; ++i) {
+        item = input.mod[i];
+        encode.call(this, prop, item, input.trans, db, sg, preds, dirty);
+      }
+    }
+
+    return input; // exit early if given request
+  }
+
+  db = values(Deps.DATA, graph, input, props);
+  sg = values(Deps.SIGNALS, graph, input, props);
+
+  // Items marked for removal are at the tail of items. Process them first.
+  for (i=0, len=input.rem.length; i<len; ++i) {
+    item = input.rem[i];
+    if (exit) encode.call(this, exit, item, input.trans, db, sg, preds, dirty); 
+    if (input.trans && !exit) input.trans.interpolate(item, EMPTY);
+    else if (!input.trans) items.pop();
+  }
+
+  var update_status = require('./Builder').STATUS.UPDATE;
+  for (i=0, len=input.add.length; i<len; ++i) {
+    item = input.add[i];
+    if (enter)  encode.call(this, enter,  item, input.trans, db, sg, preds, dirty);
+    if (update) encode.call(this, update, item, input.trans, db, sg, preds, dirty);
+    item.status = update_status;
+  }
+
+  if (update) {
+    for (i=0, len=input.mod.length; i<len; ++i) {
+      item = input.mod[i];
+      encode.call(this, update, item, input.trans, db, sg, preds, dirty);
+    }
+  }
+
+  return input;
+};
+
+// Only marshal necessary data and signal values
+function values(type, graph, input, props) {
+  var p, x, o, add = input.add.length;
+  if ((p=props.enter) && (x=p[type]).length && add) {
+    o = graph.values(type, x, (o=o||{}));
+  }
+  if ((p=props.exit) && (x=p[type]).length && input.rem.length) {
+    o = graph.values(type, x, (o=o||{})); 
+  }
+  if ((p=props.update) && (x=p[type]).length && (add || input.mod.length)) {
+    o = graph.values(type, x, (o=o||{}));
+  }
+  return o || EMPTY;
+}
+
+function encode(prop, item, trans, db, sg, preds, dirty) {
+  var enc = prop.encode,
+      wasDirty = item._dirty,
+      isDirty  = enc.call(enc, item, item.mark.group||item, trans, db, sg, preds);
+
+  item._dirty = isDirty || wasDirty;
+  if (isDirty && !wasDirty) dirty.push(item);
+}
+
+// If a specified property set called, or update property set 
+// uses nested fieldrefs, reevaluate all items.
+proto.reevaluate = function(pulse) {
+  var def = this._mark.def,
+      props = def.properties || {},
+      reeval = dl.isFunction(def.from) || def.orient || pulse.request || 
+        Node.prototype.reevaluate.call(this, pulse);
+
+  return reeval || (props.update ? nestedRefs.call(this) : false);
+};
+
+// Test if any nested refs trigger a reflow of mark items.
+function nestedRefs() {
+  var refs = this._mark.def.properties.update.nested,
+      parent = this._builder,
+      level = 0,
+      i = 0, len = refs.length,
+      ref, ds, stamp;
+
+  for (; i<len; ++i) {
+    ref = refs[i];
+
+    // Scale references are resolved via this._mark._scaleRefs which are
+    // added to dependency lists + connected in Builder.evaluate.
+    if (ref.scale) continue;
+
+    for (; level<ref.level; ++level) {
+      parent = parent.parent();
+      ds = parent.ds();
+    }
+
+    // Compare stamps to determine if a change in a group's properties
+    // or data should trigger a reeval. We cannot check anything fancier
+    // (e.g., pulse.fields) as the ref may use item.datum.
+    stamp = (ref.group ? parent.encoder() : ds.last())._stamp;
+    if (stamp > this._stamp) return true;
+  }
+
+  return false;
+}
+
+// Short-circuit encoder if user specifies items
+Encoder.update = function(graph, trans, request, items, dirty) {
+  items = dl.array(items);
+  var preds = graph.predicates(), 
+      db = graph.values(Deps.DATA),
+      sg = graph.values(Deps.SIGNALS),
+      i, len, item, props, prop;
+
+  for (i=0, len=items.length; i<len; ++i) {
+    item = items[i];
+    props = item.mark.def.properties;
+    prop = props && props[request];
+    if (prop) {
+      encode.call(null, prop, item, trans, db, sg, preds, dirty);
+      bound.item(item);
+    }
+  }
+
+};
+
+module.exports = Encoder;
+},{"./Builder":108,"datalib":24,"vega-dataflow":39,"vega-logging":45,"vega-scenegraph":46}],110:[function(require,module,exports){
+var dl = require('datalib'),
+    df = require('vega-dataflow'),
+    Node = df.Node, // jshint ignore:line
+    Deps = df.Dependencies,
+    Collector = df.Collector,
+    log = require('vega-logging'),
+    Builder = require('./Builder'),
+    Scale = require('./Scale'),
+    parseAxes = require('../parse/axes'),
+    parseLegends = require('../parse/legends');
+
+function GroupBuilder() {
+  this._children = {};
+  this._scaler = null;
+  this._recursor = null;
+
+  this._scales = {};
+  this.scale = scale.bind(this);
+  return arguments.length ? this.init.apply(this, arguments) : this;
+}
+
+var Types = GroupBuilder.TYPES = {
+  GROUP:  "group",
+  MARK:   "mark",
+  AXIS:   "axis",
+  LEGEND: "legend"
+};
+
+var proto = (GroupBuilder.prototype = new Builder());
+
+proto.init = function(graph, def) {
+  var builder = this, name;
+
+  this._scaler = new Node(graph);
+
+  (def.scales||[]).forEach(function(s) {
+    s = builder.scale((name=s.name), new Scale(graph, s, builder));
+    builder.scale(name+":prev", s);
+    builder._scaler.addListener(s);  // Scales should be computed after group is encoded
+  });
+
+  this._recursor = new Node(graph);
+  this._recursor.evaluate = recurse.bind(this);
+
+  var scales = (def.axes||[]).reduce(function(acc, x) {
+    return (acc[x.scale] = 1, acc);
+  }, {});
+
+  scales = (def.legends||[]).reduce(function(acc, x) {
+    return (acc[x.size || x.shape || x.fill || x.stroke], acc);
+  }, scales);
+
+  this._recursor.dependency(Deps.SCALES, dl.keys(scales));
+
+  // We only need a collector for up-propagation of bounds calculation,
+  // so only GroupBuilders, and not regular Builders, have collectors.
+  this._collector = new Collector(graph);
+
+  return Builder.prototype.init.apply(this, arguments);
+};
+
+proto.evaluate = function() {
+  var output = Builder.prototype.evaluate.apply(this, arguments),
+      builder = this;
+
+  output.add.forEach(function(group) { buildGroup.call(builder, output, group); });
+  return output;
+};
+
+proto.pipeline = function() {
+  return [this, this._scaler, this._recursor, this._collector, this._bounder];
+};
+
+proto.disconnect = function() {
+  var builder = this;
+  dl.keys(builder._children).forEach(function(group_id) {
+    builder._children[group_id].forEach(function(c) {
+      builder._recursor.removeListener(c.builder);
+      c.builder.disconnect();
+    });
+  });
+
+  builder._children = {};
+  return Builder.prototype.disconnect.call(this);
+};
+
+proto.child = function(name, group_id) {
+  var children = this._children[group_id],
+      i = 0, len = children.length,
+      child;
+
+  for (; i<len; ++i) {
+    child = children[i];
+    if (child.type == Types.MARK && child.builder._def.name == name) break;
+  }
+
+  return child.builder;
+};
+
+function recurse(input) {
+  var builder = this,
+      hasMarks = dl.array(this._def.marks).length > 0,
+      hasAxes = dl.array(this._def.axes).length > 0,
+      hasLegends = dl.array(this._def.legends).length > 0,
+      i, j, c, len, group, pipeline, def, inline = false;
+
+  for (i=0, len=input.add.length; i<len; ++i) {
+    group = input.add[i];
+    if (hasMarks) buildMarks.call(this, input, group);
+    if (hasAxes)  buildAxes.call(this, input, group);
+    if (hasLegends) buildLegends.call(this, input, group);
+  }
+
+  // Wire up new children builders in reverse to minimize graph rewrites.
+  for (i=input.add.length-1; i>=0; --i) {
+    group = input.add[i];
+    for (j=this._children[group._id].length-1; j>=0; --j) {
+      c = this._children[group._id][j];
+      c.builder.connect();
+      pipeline = c.builder.pipeline();
+      def = c.builder._def;
+
+      // This new child needs to be built during this propagation cycle.
+      // We could add its builder as a listener off the _recursor node, 
+      // but try to inline it if we can to minimize graph dispatches.
+      inline = (def.type !== Types.GROUP);
+      inline = inline && (this._graph.data(c.from) !== undefined); 
+      inline = inline && (pipeline[pipeline.length-1].listeners().length === 1); // Reactive geom source
+      inline = inline && (def.from && !def.from.mark); // Reactive geom target
+      c.inline = inline;
+
+      if (inline) this._graph.evaluate(input, c.builder);
+      else this._recursor.addListener(c.builder);
+    }
+  }
+
+  function removeTemp(c) {
+    if (c.type == Types.MARK && !c.inline &&
+        builder._graph.data(c.from) !== undefined) {
+      builder._recursor.removeListener(c.builder);
+    }
+  }
+
+  function updateAxis(a) { 
+    var scale = a.scale();
+    if (!input.scales[scale.scaleName]) return;
+    a.reset().def();
+  }
+  
+  function updateLegend(l) { 
+    var scale = l.size() || l.shape() || l.fill() || l.stroke();
+    if (!input.scales[scale.scaleName]) return;
+    l.reset().def();
+  }
+
+  for (i=0, len=input.mod.length; i<len; ++i) {
+    group = input.mod[i];
+
+    // Remove temporary connection for marks that draw from a source
+    if (hasMarks) builder._children[group._id].forEach(removeTemp);
+
+    // Update axis data defs
+    if (hasAxes) group.axes.forEach(updateAxis);
+
+    // Update legend data defs
+    if (hasLegends) group.legends.forEach(updateLegend);
+  }
+
+  function disconnectChildren(c) { 
+    builder._recursor.removeListener(c.builder);
+    c.builder.disconnect(); 
+  }
+
+  for (i=0, len=input.rem.length; i<len; ++i) {
+    group = input.rem[i];
+    // For deleted groups, disconnect their children
+    builder._children[group._id].forEach(disconnectChildren);
+    delete builder._children[group._id];
+  }
+
+  return input;
+}
+
+function scale(name, x) {
+  var group = this, s = null;
+  if (arguments.length === 2) return (group._scales[name] = x, x);
+  while (s == null) {
+    s = group._scales[name];
+    group = group.mark ? group.mark.group : group._parent;
+    if (!group) break;
+  }
+  return s;
+}
+
+function buildGroup(input, group) {
+  log.debug(input, ["building group", group._id]);
+
+  group._scales = group._scales || {};    
+  group.scale = scale.bind(group);
+
+  group.items = group.items || [];
+  this._children[group._id] = this._children[group._id] || [];
+
+  group.axes = group.axes || [];
+  group.axisItems = group.axisItems || [];
+
+  group.legends = group.legends || [];
+  group.legendItems = group.legendItems || [];
+}
+
+function buildMarks(input, group) {
+  log.debug(input, ["building children marks #"+group._id]);
+  var marks = this._def.marks,
+      mark, from, inherit, i, len, b;
+
+  for (i=0, len=marks.length; i<len; ++i) {
+    mark = marks[i];
+    from = mark.from || {};
+    inherit = group.datum._facetID;
+    group.items[i] = {group: group, _scaleRefs: {}};
+    b = (mark.type === Types.GROUP) ? new GroupBuilder() : new Builder();
+    b.init(this._graph, mark, group.items[i], this, group._id, inherit);
+    this._children[group._id].push({ 
+      builder: b, 
+      from: from.data || (from.mark ? ("vg_" + group._id + "_" + from.mark) : inherit), 
+      type: Types.MARK 
+    });
+  }
+}
+
+function buildAxes(input, group) {
+  var axes = group.axes,
+      axisItems = group.axisItems,
+      builder = this;
+
+  parseAxes(this._graph, this._def.axes, axes, group);
+  axes.forEach(function(a, i) {
+    var scale = builder._def.axes[i].scale,
+        def = a.def(),
+        b = null;
+
+    axisItems[i] = {group: group, axis: true, layer: def.layer};
+    b = (def.type === Types.GROUP) ? new GroupBuilder() : new Builder();
+    b.init(builder._graph, def, axisItems[i], builder)
+      .dependency(Deps.SCALES, scale);
+    builder._children[group._id].push({ builder: b, type: Types.AXIS, scale: scale });
+  });
+}
+
+function buildLegends(input, group) {
+  var legends = group.legends,
+      legendItems = group.legendItems,
+      builder = this;
+
+  parseLegends(this._graph, this._def.legends, legends, group);
+  legends.forEach(function(l, i) {
+    var scale = l.size() || l.shape() || l.fill() || l.stroke(),
+        def = l.def(),
+        b = null;
+
+    legendItems[i] = {group: group, legend: true};
+    b = (def.type === Types.GROUP) ? new GroupBuilder() : new Builder();
+    b.init(builder._graph, def, legendItems[i], builder)
+      .dependency(Deps.SCALES, scale);
+    builder._children[group._id].push({ builder: b, type: Types.LEGEND, scale: scale });
+  });
+}
+
+module.exports = GroupBuilder;
+},{"../parse/axes":90,"../parse/legends":96,"./Builder":108,"./Scale":111,"datalib":24,"vega-dataflow":39,"vega-logging":45}],111:[function(require,module,exports){
+(function (global){
+var d3 = (typeof window !== "undefined" ? window['d3'] : typeof global !== "undefined" ? global['d3'] : null),
+    dl = require('datalib'),
+    df = require('vega-dataflow'),
+    log = require('vega-logging'),
+    Node = df.Node, // jshint ignore:line
+    Deps = df.Dependencies,
+    Aggregate = require('../transforms/Aggregate');
+
+var Properties = {
+  width: 1,
+  height: 1
+};
+
+var Types = {
+  LINEAR: 'linear',
+  ORDINAL: 'ordinal',
+  LOG: 'log',
+  POWER: 'pow',
+  SQRT: 'sqrt',
+  TIME: 'time',
+  TIME_UTC: 'utc',
+  QUANTILE: 'quantile',
+  QUANTIZE: 'quantize',
+  THRESHOLD: 'threshold'
+};
+
+var DataRef = {
+  DOMAIN: 'domain',
+  RANGE: 'range',
+
+  COUNT: 'count',
+  GROUPBY: 'groupby',
+  MIN: 'min',
+  MAX: 'max',
+  VALUE: 'value',
+
+  ASC: 'asc',
+  DESC: 'desc'
+};
+
+function Scale(graph, def, parent) {
+  this._def     = def;
+  this._parent  = parent;
+  this._updated = false;
+  return Node.prototype.init.call(this, graph).reflows(true);
+}
+
+var proto = (Scale.prototype = new Node());
+
+proto.evaluate = function(input) {
+  var self = this,
+      fn = function(group) { scale.call(self, group); };
+
+  this._updated = false;
+  input.add.forEach(fn);
+  input.mod.forEach(fn);
+
+  // Scales are at the end of an encoding pipeline, so they should forward a
+  // reflow pulse. Thus, if multiple scales update in the parent group, we don't
+  // reevaluate child marks multiple times. 
+  if (this._updated) {
+    input.scales[this._def.name] = 1;
+    log.debug(input, ["scale", this._def.name]);  
+  } 
+  return df.ChangeSet.create(input, true);
+};
+
+// All of a scale's dependencies are registered during propagation as we parse
+// dataRefs. So a scale must be responsible for connecting itself to dependents.
+proto.dependency = function(type, deps) {
+  if (arguments.length == 2) {
+    var method = (type === Deps.DATA ? 'data' : 'signal');
+    deps = dl.array(deps);
+    for (var i=0, len=deps.length; i<len; ++i) {
+      this._graph[method](deps[i]).addListener(this._parent);
+    }
+  }
+
+  return Node.prototype.dependency.call(this, type, deps);
+};
+
+function scale(group) {
+  var name = this._def.name,
+      prev = name + ':prev',
+      s = instance.call(this, group.scale(name)),
+      m = s.type===Types.ORDINAL ? ordinal : quantitative,
+      rng = range.call(this, group);
+
+  m.call(this, s, rng, group);
+
+  group.scale(name, s);
+  group.scale(prev, group.scale(prev) || s);
+
+  return s;
+}
+
+function instance(scale) {
+  var config = this._graph.config(),
+      type = this._def.type || Types.LINEAR;
+  if (!scale || type !== scale.type) {
+    var ctor = config.scale[type] || d3.scale[type];
+    if (!ctor) throw Error('Unrecognized scale type: ' + type);
+    (scale = ctor()).type = scale.type || type;
+    scale.scaleName = this._def.name;
+    scale._prev = {};
+  }
+  return scale;
+}
+
+function ordinal(scale, rng, group) {
+  var def = this._def,
+      prev = scale._prev,
+      dataDrivenRange = false,
+      pad = signal.call(this, def.padding) || 0,
+      outer = def.outerPadding == null ? pad : signal.call(this, def.outerPadding),
+      points = def.points && signal.call(this, def.points),
+      round = signal.call(this, def.round) || def.round == null,
+      domain, str;
+  
+  // range pre-processing for data-driven ranges
+  if (dl.isObject(def.range) && !dl.isArray(def.range)) {
+    dataDrivenRange = true;
+    rng = dataRef.call(this, DataRef.RANGE, def.range, scale, group);
+  }
+  
+  // domain
+  domain = dataRef.call(this, DataRef.DOMAIN, def.domain, scale, group);
+  if (domain && !dl.equal(prev.domain, domain)) {
+    scale.domain(domain);
+    prev.domain = domain;
+    this._updated = true;
+  } 
+
+  // range
+  if (dl.equal(prev.range, rng)) return;
+
+  // width-defined range
+  if (def.bandWidth) {
+    var bw = signal.call(this, def.bandWidth),
+        len = domain.length,
+        space = def.points ? (pad*bw) : (pad*bw*(len-1) + 2*outer),
+        start;
+    if (rng[0] > rng[1]) {
+      start = rng[1] || 0;
+      rng = [start + (bw * len + space), start];
+    } else {
+      start = rng[0] || 0;
+      rng = [start, start + (bw * len + space)];
+    }
+  }
+
+  str = typeof rng[0] === 'string';
+  if (str || rng.length > 2 || rng.length===1 || dataDrivenRange) {
+    scale.range(rng); // color or shape values
+  } else if (points && round) {
+    scale.rangeRoundPoints(rng, pad);
+  } else if (points) {
+    scale.rangePoints(rng, pad);
+  } else if (round) {
+    scale.rangeRoundBands(rng, pad, outer);
+  } else {
+    scale.rangeBands(rng, pad, outer);
+  }
+
+  if (!scale.invert) {
+    scale.invert = function(x, y) {
+      if (arguments.length === 1) {
+        return scale.domain()[d3.bisect(scale.range(), x) - 1];
+      } else if (arguments.length === 2) {  // Invert extents
+        if (!dl.isNumber(x) || !dl.isNumber(y)) {
+          throw Error('Extents to ordinal invert are not numbers ('+x+', '+y+').');
+        }
+
+        var points = [],
+            rng = scale.range(),
+            i = 0, len = rng.length, r;
+
+        for(; i<len; ++i) {
+          r = rng[i];
+          if (x < y ? x <= r && r <= y : y <= r && r <= x) {
+            points.push(r);
+          }
+        }
+
+        return points.map(function(p) { return scale.invert(p); });
+      }
+    };
+  }
+
+  prev.range = rng;
+  this._updated = true;
+}
+
+function quantitative(scale, rng, group) {
+  var def = this._def,
+      prev = scale._prev,
+      round = signal.call(this, def.round),
+      exponent = signal.call(this, def.exponent),
+      clamp = signal.call(this, def.clamp),
+      nice = signal.call(this, def.nice),
+      domain, interval;
+
+  // domain
+  domain = (def.type === Types.QUANTILE) ?
+    dataRef.call(this, DataRef.DOMAIN, def.domain, scale, group) :
+    domainMinMax.call(this, scale, group);
+  if (domain && !dl.equal(prev.domain, domain)) {
+    scale.domain(domain);
+    prev.domain = domain;
+    this._updated = true;
+  } 
+
+  // range
+  // vertical scales should flip by default, so use XOR here
+  if (signal.call(this, def.range) === 'height') rng = rng.reverse();
+  if (dl.equal(prev.range, rng)) return;
+  scale[round && scale.rangeRound ? 'rangeRound' : 'range'](rng);
+  prev.range = rng;
+  this._updated = true;
+
+  // TODO: Support signals for these properties. Until then, only eval
+  // them once.
+  if (this._stamp > 0) return;
+  if (exponent && def.type===Types.POWER) scale.exponent(exponent);
+  if (clamp) scale.clamp(true);
+  if (nice) {
+    if (def.type === Types.TIME) {
+      interval = d3.time[nice];
+      if (!interval) log.error('Unrecognized interval: ' + interval);
+      scale.nice(interval);
+    } else {
+      scale.nice();
+    }
+  }
+}
+
+function isUniques(scale) { 
+  return scale.type === Types.ORDINAL || scale.type === Types.QUANTILE; 
+}
+
+function getRefs(def) { 
+  return def.fields || dl.array(def);
+}
+
+function inherits(refs) {
+  return refs.some(function(r) {
+    if (!r.data) return true;
+    return r.data && dl.array(r.field).some(function(f) {
+      return f.parent;
+    });
+  });
+}
+
+function getFields(ref, group) {
+  return dl.array(ref.field).map(function(f) {
+    return f.parent ?
+      dl.accessor(f.parent)(group.datum) :
+      f; // String or {'signal'}
+  });
+}
+
+// Scale datarefs can be computed over multiple schema types. 
+// This function determines the type of aggregator created, and
+// what data is sent to it: values, tuples, or multi-tuples that must
+// be standardized into a consistent schema. 
+function aggrType(def, scale) {
+  var refs = getRefs(def);
+
+  // If we're operating over only a single domain, send full tuples
+  // through for efficiency (fewer accessor creations/calls)
+  if (refs.length == 1 && dl.array(refs[0].field).length == 1) {
+    return Aggregate.TYPES.TUPLE;
+  }
+
+  // With quantitative scales, we only care about min/max.
+  if (!isUniques(scale)) return Aggregate.TYPES.VALUE;
+
+  // If we don't sort, then we can send values directly to aggrs as well
+  if (!dl.isObject(def.sort)) return Aggregate.TYPES.VALUE;
+
+  return Aggregate.TYPES.MULTI;
+}
+
+function getCache(which, def, scale, group) {
+  var refs = getRefs(def),
+      inherit = inherits(refs),
+      atype = aggrType(def, scale),
+      uniques = isUniques(scale),
+      sort = def.sort,
+      ck = '_'+which,
+      fields = getFields(refs[0], group);
+
+  if (scale[ck] || this[ck]) return scale[ck] || this[ck];
+
+  var cache = new Aggregate(this._graph).type(atype),
+      groupby, summarize;
+
+  // If a scale's dataref doesn't inherit data from the group, we can
+  // store the dataref aggregator at the Scale (dataflow node) level. 
+  if (inherit) {
+    scale[ck] = cache;
+  } else {
+    this[ck]  = cache;
+  }
+
+  if (uniques) {
+    if (atype === Aggregate.TYPES.VALUE) {
+      groupby = [{ name: DataRef.GROUPBY, get: dl.identity }];
+      summarize = {'*': DataRef.COUNT};
+    } else if (atype === Aggregate.TYPES.TUPLE) {
+      groupby = [{ name: DataRef.GROUPBY, get: dl.$(fields[0]) }];
+      summarize = dl.isObject(sort) ? [{
+        field: DataRef.VALUE,
+        get:  dl.$(sort.field),
+        ops: [sort.op]
+      }] : {'*': DataRef.COUNT};
+    } else {  // atype === Aggregate.TYPES.MULTI
+      groupby   = DataRef.GROUPBY;
+      summarize = [{ field: DataRef.VALUE, ops: [sort.op] }]; 
+    }
+  } else {
+    groupby = [];
+    summarize = [{
+      field: DataRef.VALUE,
+      get: (atype == Aggregate.TYPES.TUPLE) ? dl.$(fields[0]) : dl.identity,
+      ops: [DataRef.MIN, DataRef.MAX],
+      as:  [DataRef.MIN, DataRef.MAX]
+    }];
+  }
+
+  cache.param('groupby', groupby)
+    .param('summarize', summarize);
+
+  return (cache._lastUpdate = -1, cache);
+}
+
+function dataRef(which, def, scale, group) {
+  if (def == null) { return []; }
+  if (dl.isArray(def)) return def.map(signal.bind(this));
+
+  var self = this, graph = this._graph,
+      refs = getRefs(def),
+      inherit = inherits(refs),
+      atype = aggrType(def, scale),
+      cache = getCache.apply(this, arguments),
+      sort  = def.sort,
+      uniques = isUniques(scale),
+      i, rlen, j, flen, ref, fields, field, data, from, so, cmp;
+
+  function addDep(s) {
+    self.dependency(Deps.SIGNALS, s);
+  }
+
+  if (inherit || (!inherit && cache._lastUpdate < this._stamp)) {
+    for (i=0, rlen=refs.length; i<rlen; ++i) {
+      ref = refs[i];
+      from = ref.data || group.datum._facetID;
+      data = graph.data(from).last();
+
+      if (data.stamp <= this._stamp) continue;
+
+      fields = getFields(ref, group);
+      for (j=0, flen=fields.length; j<flen; ++j) {
+        field = fields[j];
+
+        if (atype === Aggregate.TYPES.VALUE) {
+          cache.accessors(null, field);
+        } else if (atype === Aggregate.TYPES.MULTI) {
+          cache.accessors(field, ref.sort || sort.field);
+        } // Else (Tuple-case) is handled by the aggregator accessors by default
+
+        cache.evaluate(data);
+      }
+
+      this.dependency(Deps.DATA, from);
+      cache.dependency(Deps.SIGNALS).forEach(addDep);
+    }
+
+    cache._lastUpdate = this._stamp;
+
+    data = cache.aggr().result();
+    if (uniques) {
+      if (dl.isObject(sort)) {
+        cmp = (so = sort.order) && so.signal ? graph.signalRef(so.signal) : so;
+        cmp = (cmp == DataRef.DESC ? '-' : '+') + sort.op + '_' + DataRef.VALUE;
+        cmp = dl.comparator(cmp);
+      } else if (sort === true) {
+        cmp = dl.comparator(DataRef.GROUPBY);
+      }
+
+      if (cmp) data = data.sort(cmp);
+      cache._values = data.map(function(d) { return d[DataRef.GROUPBY]; });
+    } else {
+      data = data[0];
+      cache._values = !dl.isValid(data) ? [] : [data[DataRef.MIN], data[DataRef.MAX]];
+    }
+  }
+
+  return cache._values;
+}
+
+function signal(v) {
+  if (!v || !v.signal) return v;
+  var s = v.signal, ref;
+  this.dependency(Deps.SIGNALS, (ref = dl.field(s))[0]);
+  return this._graph.signalRef(ref);
+}
+
+function domainMinMax(scale, group) {
+  var def = this._def,
+      domain = [null, null], s, z;
+
+  if (def.domain !== undefined) {
+    domain = (!dl.isObject(def.domain)) ? domain :
+      dataRef.call(this, DataRef.DOMAIN, def.domain, scale, group);
+  }
+
+  z = domain.length - 1;
+  if (def.domainMin !== undefined) {
+    if (dl.isObject(def.domainMin)) {
+      if (def.domainMin.signal) {
+        domain[0] = dl.isValid(s=signal.call(this, def.domainMin)) ? s : domain[0];
+      } else {
+        domain[0] = dataRef.call(this, DataRef.DOMAIN+DataRef.MIN, def.domainMin, scale, group)[0];
+      }
+    } else {
+      domain[0] = def.domainMin;
+    }
+  }
+  if (def.domainMax !== undefined) {
+    if (dl.isObject(def.domainMax)) {
+      if (def.domainMax.signal) {
+        domain[z] = dl.isValid(s=signal.call(this, def.domainMax)) ? s : domain[z];
+      } else {
+        domain[z] = dataRef.call(this, DataRef.DOMAIN+DataRef.MAX, def.domainMax, scale, group)[1];
+      }
+    } else {
+      domain[z] = def.domainMax;
+    }
+  }
+  if (def.type !== Types.LOG && def.type !== Types.TIME && (def.zero || def.zero===undefined)) {
+    domain[0] = Math.min(0, domain[0]);
+    domain[z] = Math.max(0, domain[z]);
+  }
+  return domain;
+}
+
+function range(group) {
+  var def = this._def,
+      config = this._graph.config(),
+      rangeVal = signal.call(this, def.range),
+      rng = [null, null];
+
+  if (rangeVal !== undefined) {
+    if (typeof rangeVal === 'string') {
+      if (Properties[rangeVal]) {
+        rng = [0, group[rangeVal]];
+      } else if (config.range[rangeVal]) {
+        rng = config.range[rangeVal];
+      } else {
+        log.error('Unrecogized range: ' + rangeVal);
+        return rng;
+      }
+    } else if (dl.isArray(rangeVal)) {
+      rng = dl.duplicate(rangeVal).map(signal.bind(this));
+    } else if (dl.isObject(rangeVal)) {
+      return null; // early exit
+    } else {
+      rng = [0, rangeVal];
+    }
+  }
+  if (def.rangeMin !== undefined) {
+    rng[0] = def.rangeMin.signal ?
+      signal.call(this, def.rangeMin) :
+      def.rangeMin;
+  }
+  if (def.rangeMax !== undefined) {
+    rng[rng.length-1] = def.rangeMax.signal ?
+      signal.call(this, def.rangeMax) :
+      def.rangeMax;
+  }
+  
+  if (def.reverse !== undefined) {
+    var rev = signal.call(this, def.reverse);
+    if (dl.isObject(rev)) {
+      rev = dl.accessor(rev.field)(group.datum);
+    }
+    if (rev) rng = rng.reverse();
+  }
+  
+  return rng;
+}
+
+module.exports = Scale;
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{"../transforms/Aggregate":116,"datalib":24,"vega-dataflow":39,"vega-logging":45}],112:[function(require,module,exports){
+(function (global){
+var d3 = (typeof window !== "undefined" ? window['d3'] : typeof global !== "undefined" ? global['d3'] : null),
+    bound = require('vega-scenegraph').bound,
+    Tuple = require('vega-dataflow').Tuple,
+    Status = require('./Builder').STATUS;
+
+function Transition(duration, ease) {
+  this.duration = duration || 500;
+  this.ease = ease && d3.ease(ease) || d3.ease('cubic-in-out');
+  this.updates = {next: null};
+}
+
+var prototype = Transition.prototype;
+
+var skip = {
+  'text': 1,
+  'url':  1
+};
+
+prototype.interpolate = function(item, values) {
+  var key, curr, next, interp, list = null;
+
+  for (key in values) {
+    curr = item[key];
+    next = values[key];      
+    if (curr !== next) {
+      if (skip[key] || curr === undefined) {
+        // skip interpolation for specific keys or undefined start values
+        Tuple.set(item, key, next);
+      } else if (typeof curr === 'number' && !isFinite(curr)) {
+        // for NaN or infinite numeric values, skip to final value
+        Tuple.set(item, key, next);
+      } else {
+        // otherwise lookup interpolator
+        interp = d3.interpolate(curr, next);
+        interp.property = key;
+        (list || (list=[])).push(interp);
+      }
+    }
+  }
+
+  if (list === null && item.status === Status.EXIT) {
+    list = []; // ensure exiting items are included
+  }
+
+  if (list != null) {
+    list.item = item;
+    list.ease = item.mark.ease || this.ease;
+    list.next = this.updates.next;
+    this.updates.next = list;
+  }
+  return this;
+};
+
+prototype.start = function(callback) {
+  var t = this, prev = t.updates, curr = prev.next;
+  for (; curr!=null; prev=curr, curr=prev.next) {
+    if (curr.item.status === Status.EXIT) {
+      // Only mark item as exited when it is removed.
+      curr.item.status = Status.UPDATE;
+      curr.remove = true;
+    }
+  }
+  t.callback = callback;
+  d3.timer(function(elapsed) { return step.call(t, elapsed); });
+};
+
+function step(elapsed) {
+  var list = this.updates, prev = list, curr = prev.next,
+      duration = this.duration,
+      item, delay, f, e, i, n, stop = true;
+
+  for (; curr!=null; prev=curr, curr=prev.next) {
+    item = curr.item;
+    delay = item.delay || 0;
+
+    f = (elapsed - delay) / duration;
+    if (f < 0) { stop = false; continue; }
+    if (f > 1) f = 1;
+    e = curr.ease(f);
+
+    for (i=0, n=curr.length; i<n; ++i) {
+      item[curr[i].property] = curr[i](e);
+    }
+    item.touch();
+    bound.item(item);
+
+    if (f === 1) {
+      if (curr.remove) {
+        item.status = Status.EXIT;
+        item.remove();
+      }
+      prev.next = curr.next;
+      curr = prev;
+    } else {
+      stop = false;
+    }
+  }
+
+  this.callback();
+  return stop;
+}
+
+module.exports = Transition;
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{"./Builder":108,"vega-dataflow":39,"vega-scenegraph":46}],113:[function(require,module,exports){
+var dl = require('datalib'),
+    Tuple = require('vega-dataflow').Tuple,
+    parseMark = require('../parse/mark');
+
+var TIME    = 'time',
+    UTC     = 'utc',
+    STRING  = 'string',
+    ORDINAL = 'ordinal',
+    NUMBER  = 'number';
+
+function axs(model) {
+  var scale,
+      config = model.config(),
+      orient = config.axis.orient,
+      offset = 0,
+      titleOffset = config.axis.titleOffset,
+      axisDef = {},
+      layer = 'front',
+      grid = false,
+      title = null,
+      tickMajorSize = config.axis.tickSize,
+      tickMinorSize = config.axis.tickSize,
+      tickEndSize = config.axis.tickSize,
+      tickPadding = config.axis.padding,
+      tickValues = null,
+      tickFormatString = null,
+      tickFormatType = null,
+      tickSubdivide = 0,
+      tickCount = config.axis.ticks,
+      gridLineStyle = {},
+      tickLabelStyle = {},
+      majorTickStyle = {},
+      minorTickStyle = {},
+      titleStyle = {},
+      domainStyle = {},
+      m = { // Axis marks as references for updates
+        gridLines:  {},
+        majorTicks: {},
+        minorTicks: {},
+        tickLabels: {},
+        domain: {},
+        title:  {}
+      };
+
+  var axis = {};
+
+  function reset() {
+    axisDef.type = null;
+  }
+
+  function ingest(d) {
+    return {data: d};
+  }
+
+  function getTickFormat() {
+    var formatType = tickFormatType || inferFormatType();
+    return getFormatter(formatType, tickFormatString);
+  }
+
+  function inferFormatType() {
+    switch (scale.type) {
+      case TIME:    return TIME;
+      case UTC:     return UTC;
+      case ORDINAL: return STRING;
+      default:      return NUMBER;
+    }
+  }
+
+  // Adapted from d3 log scale
+  // TODO customize? replace with range-size-aware filtering?
+  function logFilter(domain, count, f) {
+    if (count == null) return f;
+    var base = scale.base(),
+        k = Math.min(base, scale.ticks().length / count),
+        v = domain[0] > 0 ? (e = 1e-12, Math.ceil) : (e = -1e-12, Math.floor),
+        e;
+    function log(x) {
+      return (domain[0] < 0 ?
+        -Math.log(x > 0 ? 0 : -x) :
+        Math.log(x < 0 ? 0 : x)) / Math.log(base);
+    }
+    function pow(x) {
+      return domain[0] < 0 ? -Math.pow(base, -x) : Math.pow(base, x);
+    }
+    return function(d) {
+      return pow(v(log(d) + e)) / d >= k ? f(d) : '';
+    };
+  }
+
+  function getFormatter(formatType, str) {
+    var fmt = dl.format,
+        log = scale.type === 'log',
+        domain, f;
+
+    switch (formatType) {
+      case NUMBER:
+         domain = scale.domain();
+         f = fmt.auto.number(domain, tickCount, str || (log ? '.1r' : null));
+         return log ? logFilter(domain, tickCount, f) : f;
+      case TIME: return (str ? fmt : fmt.auto).time(str);
+      case UTC:  return (str ? fmt : fmt.auto).utc(str);
+      default:   return String;
+    }
+  }
+  
+  function getTicks(format) {
+    var major = tickValues || (scale.ticks ? scale.ticks(tickCount) : scale.domain()),
+        minor = axisSubdivide(scale, major, tickSubdivide).map(ingest);
+    major = major.map(function(d) { return (d = ingest(d), d.label = format(d.data), d); });
+    return [major, minor];
+  }
+
+  axis.def = function() {
+    if (!axisDef.type) axis_def(scale);
+
+    var ticks = getTicks(getTickFormat());
+    var tdata = title ? [title].map(ingest) : [];
+
+    axisDef.marks[0].from = function() { return grid ? ticks[0] : []; };
+    axisDef.marks[1].from = function() { return ticks[0]; };
+    axisDef.marks[2].from = function() { return ticks[1]; };
+    axisDef.marks[3].from = axisDef.marks[1].from;
+    axisDef.marks[4].from = function() { return [1]; };
+    axisDef.marks[5].from = function() { return tdata; };
+    axisDef.offset = offset;
+    axisDef.orient = orient;
+    axisDef.layer = layer;
+
+    return axisDef;
+  };
+
+  function axis_def(scale) {
+    // setup scale mapping
+    var newScale, oldScale, range;
+    if (scale.type === ORDINAL) {
+      newScale = {scale: scale.scaleName, offset: 0.5 + scale.rangeBand()/2};
+      oldScale = newScale;
+    } else {
+      newScale = {scale: scale.scaleName, offset: 0.5};
+      oldScale = {scale: scale.scaleName+':prev', offset: 0.5};
+    }
+    range = axisScaleRange(scale);
+
+    // setup axis marks
+    dl.extend(m.gridLines, axisTicks(config));
+    dl.extend(m.majorTicks, axisTicks(config));
+    dl.extend(m.minorTicks, axisTicks(config));
+    dl.extend(m.tickLabels, axisTickLabels(config));
+    dl.extend(m.domain, axisDomain(config));
+    dl.extend(m.title, axisTitle(config));
+    m.gridLines.properties.enter.stroke = {value: config.axis.gridColor};
+    m.gridLines.properties.enter.strokeOpacity = {value: config.axis.gridOpacity};
+
+    // extend axis marks based on axis orientation
+    axisTicksExtend(orient, m.gridLines, oldScale, newScale, Infinity);
+    axisTicksExtend(orient, m.majorTicks, oldScale, newScale, tickMajorSize);
+    axisTicksExtend(orient, m.minorTicks, oldScale, newScale, tickMinorSize);
+    axisLabelExtend(orient, m.tickLabels, oldScale, newScale, tickMajorSize, tickPadding);
+
+    axisDomainExtend(orient, m.domain, range, tickEndSize);
+    axisTitleExtend(orient, m.title, range, titleOffset); // TODO get offset
+    
+    // add / override custom style properties
+    dl.extend(m.gridLines.properties.update, gridLineStyle);
+    dl.extend(m.majorTicks.properties.update, majorTickStyle);
+    dl.extend(m.minorTicks.properties.update, minorTickStyle);
+    dl.extend(m.tickLabels.properties.update, tickLabelStyle);
+    dl.extend(m.domain.properties.update, domainStyle);
+    dl.extend(m.title.properties.update, titleStyle);
+
+    var marks = [m.gridLines, m.majorTicks, m.minorTicks, m.tickLabels, m.domain, m.title];
+    dl.extend(axisDef, {
+      type: 'group',
+      interactive: false,
+      properties: { 
+        enter: {
+          encode: axisUpdate,
+          scales: [scale.scaleName],
+          signals: [], data: []
+        },
+        update: {
+          encode: axisUpdate,
+          scales: [scale.scaleName],
+          signals: [], data: []
+        }
+      }
+    });
+
+    axisDef.marks = marks.map(function(m) { return parseMark(model, m); });
+  }
+
+  axis.scale = function(x) {
+    if (!arguments.length) return scale;
+    if (scale !== x) { scale = x; reset(); }
+    return axis;
+  };
+
+  axis.orient = function(x) {
+    if (!arguments.length) return orient;
+    if (orient !== x) {
+      orient = x in axisOrients ? x + '' : config.axis.orient;
+      reset();
+    }
+    return axis;
+  };
+
+  axis.title = function(x) {
+    if (!arguments.length) return title;
+    if (title !== x) { title = x; reset(); }
+    return axis;
+  };
+
+  axis.tickCount = function(x) {
+    if (!arguments.length) return tickCount;
+    tickCount = x;
+    return axis;
+  };
+
+  axis.tickValues = function(x) {
+    if (!arguments.length) return tickValues;
+    tickValues = x;
+    return axis;
+  };
+
+  axis.tickFormat = function(x) {
+    if (!arguments.length) return tickFormatString;
+    if (tickFormatString !== x) {
+      tickFormatString = x;
+      reset();
+    }
+    return axis;
+  };
+
+  axis.tickFormatType = function(x) {
+    if (!arguments.length) return tickFormatType;
+    if (tickFormatType !== x) {
+      tickFormatType = x;
+      reset();
+    }
+    return axis;
+  };
+
+  axis.tickSize = function(x, y) {
+    if (!arguments.length) return tickMajorSize;
+    var n = arguments.length - 1,
+        major = +x,
+        minor = n > 1 ? +y : tickMajorSize,
+        end   = n > 0 ? +arguments[n] : tickMajorSize;
+
+    if (tickMajorSize !== major ||
+        tickMinorSize !== minor ||
+        tickEndSize !== end) {
+      reset();
+    }
+
+    tickMajorSize = major;
+    tickMinorSize = minor;
+    tickEndSize = end;
+    return axis;
+  };
+
+  axis.tickSubdivide = function(x) {
+    if (!arguments.length) return tickSubdivide;
+    tickSubdivide = +x;
+    return axis;
+  };
+  
+  axis.offset = function(x) {
+    if (!arguments.length) return offset;
+    offset = dl.isObject(x) ? x : +x;
+    return axis;
+  };
+
+  axis.tickPadding = function(x) {
+    if (!arguments.length) return tickPadding;
+    if (tickPadding !== +x) { tickPadding = +x; reset(); }
+    return axis;
+  };
+
+  axis.titleOffset = function(x) {
+    if (!arguments.length) return titleOffset;
+    if (titleOffset !== +x) { titleOffset = +x; reset(); }
+    return axis;
+  };
+
+  axis.layer = function(x) {
+    if (!arguments.length) return layer;
+    if (layer !== x) { layer = x; reset(); }
+    return axis;
+  };
+
+  axis.grid = function(x) {
+    if (!arguments.length) return grid;
+    if (grid !== x) { grid = x; reset(); }
+    return axis;
+  };
+
+  axis.gridLineProperties = function(x) {
+    if (!arguments.length) return gridLineStyle;
+    if (gridLineStyle !== x) { gridLineStyle = x; }
+    return axis;
+  };
+
+  axis.majorTickProperties = function(x) {
+    if (!arguments.length) return majorTickStyle;
+    if (majorTickStyle !== x) { majorTickStyle = x; }
+    return axis;
+  };
+
+  axis.minorTickProperties = function(x) {
+    if (!arguments.length) return minorTickStyle;
+    if (minorTickStyle !== x) { minorTickStyle = x; }
+    return axis;
+  };
+
+  axis.tickLabelProperties = function(x) {
+    if (!arguments.length) return tickLabelStyle;
+    if (tickLabelStyle !== x) { tickLabelStyle = x; }
+    return axis;
+  };
+
+  axis.titleProperties = function(x) {
+    if (!arguments.length) return titleStyle;
+    if (titleStyle !== x) { titleStyle = x; }
+    return axis;
+  };
+
+  axis.domainProperties = function(x) {
+    if (!arguments.length) return domainStyle;
+    if (domainStyle !== x) { domainStyle = x; }
+    return axis;
+  };
+  
+  axis.reset = function() { 
+    reset(); 
+    return axis; 
+  };
+
+  return axis;
+}
+
+var axisOrients = {top: 1, right: 1, bottom: 1, left: 1};
+
+function axisSubdivide(scale, ticks, m) {
+  var subticks = [];
+  if (m && ticks.length > 1) {
+    var extent = axisScaleExtent(scale.domain()),
+        i = -1,
+        n = ticks.length,
+        d = (ticks[1] - ticks[0]) / ++m,
+        j,
+        v;
+    while (++i < n) {
+      for (j = m; --j > 0;) {
+        if ((v = +ticks[i] - j * d) >= extent[0]) {
+          subticks.push(v);
+        }
+      }
+    }
+    for (--i, j = 0; ++j < m && (v = +ticks[i] + j * d) < extent[1];) {
+      subticks.push(v);
+    }
+  }
+  return subticks;
+}
+
+function axisScaleExtent(domain) {
+  var start = domain[0], stop = domain[domain.length - 1];
+  return start < stop ? [start, stop] : [stop, start];
+}
+
+function axisScaleRange(scale) {
+  return scale.rangeExtent ?
+    scale.rangeExtent() :
+    axisScaleExtent(scale.range());
+}
+
+var axisAlign = {
+  bottom: 'center',
+  top: 'center',
+  left: 'right',
+  right: 'left'
+};
+
+var axisBaseline = {
+  bottom: 'top',
+  top: 'bottom',
+  left: 'middle',
+  right: 'middle'
+};
+
+function axisLabelExtend(orient, labels, oldScale, newScale, size, pad) {
+  size = Math.max(size, 0) + pad;
+  if (orient === 'left' || orient === 'top') {
+    size *= -1;
+  }  
+  if (orient === 'top' || orient === 'bottom') {
+    dl.extend(labels.properties.enter, {
+      x: oldScale,
+      y: {value: size},
+    });
+    dl.extend(labels.properties.update, {
+      x: newScale,
+      y: {value: size},
+      align: {value: 'center'},
+      baseline: {value: axisBaseline[orient]}
+    });
+  } else {
+    dl.extend(labels.properties.enter, {
+      x: {value: size},
+      y: oldScale,
+    });
+    dl.extend(labels.properties.update, {
+      x: {value: size},
+      y: newScale,
+      align: {value: axisAlign[orient]},
+      baseline: {value: 'middle'}
+    });
+  }
+}
+
+function axisTicksExtend(orient, ticks, oldScale, newScale, size) {
+  var sign = (orient === 'left' || orient === 'top') ? -1 : 1;
+  if (size === Infinity) {
+    size = (orient === 'top' || orient === 'bottom') ?
+      {field: {group: 'height', level: 2}, mult: -sign} :
+      {field: {group: 'width',  level: 2}, mult: -sign};
+  } else {
+    size = {value: sign * size};
+  }
+  if (orient === 'top' || orient === 'bottom') {
+    dl.extend(ticks.properties.enter, {
+      x:  oldScale,
+      y:  {value: 0},
+      y2: size
+    });
+    dl.extend(ticks.properties.update, {
+      x:  newScale,
+      y:  {value: 0},
+      y2: size
+    });
+    dl.extend(ticks.properties.exit, {
+      x:  newScale,
+    });        
+  } else {
+    dl.extend(ticks.properties.enter, {
+      x:  {value: 0},
+      x2: size,
+      y:  oldScale
+    });
+    dl.extend(ticks.properties.update, {
+      x:  {value: 0},
+      x2: size,
+      y:  newScale
+    });
+    dl.extend(ticks.properties.exit, {
+      y:  newScale,
+    });
+  }
+}
+
+function axisTitleExtend(orient, title, range, offset) {
+  var mid = ~~((range[0] + range[1]) / 2),
+      sign = (orient === 'top' || orient === 'left') ? -1 : 1;
+  
+  if (orient === 'bottom' || orient === 'top') {
+    dl.extend(title.properties.update, {
+      x: {value: mid},
+      y: {value: sign*offset},
+      angle: {value: 0}
+    });
+  } else {
+    dl.extend(title.properties.update, {
+      x: {value: sign*offset},
+      y: {value: mid},
+      angle: {value: orient === 'left' ? -90 : 90}
+    });
+  }
+}
+
+function axisDomainExtend(orient, domain, range, size) {
+  var path;
+  if (orient === 'top' || orient === 'left') {
+    size = -1 * size;
+  }
+  if (orient === 'bottom' || orient === 'top') {
+    path = 'M' + range[0] + ',' + size + 'V0H' + range[1] + 'V' + size;
+  } else {
+    path = 'M' + size + ',' + range[0] + 'H0V' + range[1] + 'H' + size;
+  }
+  domain.properties.update.path = {value: path};
+}
+
+function axisUpdate(item, group, trans) {
+  var o = trans ? {} : item,
+      offset = item.mark.def.offset,
+      orient = item.mark.def.orient,
+      width  = group.width,
+      height = group.height; // TODO fallback to global w,h?
+
+  if (dl.isArray(offset)) {
+    var ofx = offset[0],
+        ofy = offset[1];
+
+    switch (orient) {
+      case 'left':   { Tuple.set(o, 'x', -ofx); Tuple.set(o, 'y', ofy); break; }
+      case 'right':  { Tuple.set(o, 'x', width + ofx); Tuple.set(o, 'y', ofy); break; }
+      case 'bottom': { Tuple.set(o, 'x', ofx); Tuple.set(o, 'y', height + ofy); break; }
+      case 'top':    { Tuple.set(o, 'x', ofx); Tuple.set(o, 'y', -ofy); break; }
+      default:       { Tuple.set(o, 'x', ofx); Tuple.set(o, 'y', ofy); }
+    }
+  } else {
+    if (dl.isObject(offset)) {
+      offset = -group.scale(offset.scale)(offset.value);
+    }
+
+    switch (orient) {
+      case 'left':   { Tuple.set(o, 'x', -offset); Tuple.set(o, 'y', 0); break; }
+      case 'right':  { Tuple.set(o, 'x', width + offset); Tuple.set(o, 'y', 0); break; }
+      case 'bottom': { Tuple.set(o, 'x', 0); Tuple.set(o, 'y', height + offset); break; }
+      case 'top':    { Tuple.set(o, 'x', 0); Tuple.set(o, 'y', -offset); break; }
+      default:       { Tuple.set(o, 'x', 0); Tuple.set(o, 'y', 0); }
+    }
+  }
+
+  if (trans) trans.interpolate(item, o);
+  return true;
+}
+
+function axisTicks(config) {
+  return {
+    type: 'rule',
+    interactive: false,
+    key: 'data',
+    properties: {
+      enter: {
+        stroke: {value: config.axis.tickColor},
+        strokeWidth: {value: config.axis.tickWidth},
+        opacity: {value: 1e-6}
+      },
+      exit: { opacity: {value: 1e-6} },
+      update: { opacity: {value: 1} }
+    }
+  };
+}
+
+function axisTickLabels(config) {
+  return {
+    type: 'text',
+    interactive: true,
+    key: 'data',
+    properties: {
+      enter: {
+        fill: {value: config.axis.tickLabelColor},
+        font: {value: config.axis.tickLabelFont},
+        fontSize: {value: config.axis.tickLabelFontSize},
+        opacity: {value: 1e-6},
+        text: {field: 'label'}
+      },
+      exit: { opacity: {value: 1e-6} },
+      update: { opacity: {value: 1} }
+    }
+  };
+}
+
+function axisTitle(config) {
+  return {
+    type: 'text',
+    interactive: true,
+    properties: {
+      enter: {
+        font: {value: config.axis.titleFont},
+        fontSize: {value: config.axis.titleFontSize},
+        fontWeight: {value: config.axis.titleFontWeight},
+        fill: {value: config.axis.titleColor},
+        align: {value: 'center'},
+        baseline: {value: 'middle'},
+        text: {field: 'data'}
+      },
+      update: {}
+    }
+  };
+}
+
+function axisDomain(config) {
+  return {
+    type: 'path',
+    interactive: false,
+    properties: {
+      enter: {
+        x: {value: 0.5},
+        y: {value: 0.5},
+        stroke: {value: config.axis.axisColor},
+        strokeWidth: {value: config.axis.axisWidth}
+      },
+      update: {}
+    }
+  };
+}
+
+module.exports = axs;
+},{"../parse/mark":97,"datalib":24,"vega-dataflow":39}],114:[function(require,module,exports){
+(function (global){
+var d3 = (typeof window !== "undefined" ? window['d3'] : typeof global !== "undefined" ? global['d3'] : null),
+    dl = require('datalib'),
+    Gradient = require('vega-scenegraph').Gradient,
+    parseProperties = require('../parse/properties'),
+    parseMark = require('../parse/mark');
+
+function lgnd(model) {
+  var size = null,
+      shape = null,
+      fill = null,
+      stroke = null,
+      spacing = null,
+      values = null,
+      format = null,
+      formatString = null,
+      config = model.config(),
+      title,
+      orient = 'right',
+      offset = config.legend.offset,
+      padding = config.legend.padding,
+      tickArguments = [5],
+      legendStyle = {},
+      symbolStyle = {},
+      gradientStyle = {},
+      titleStyle = {},
+      labelStyle = {},
+      m = { // Legend marks as references for updates
+        titles:  {},
+        symbols: {},
+        labels:  {},
+        gradient: {}
+      };
+
+  var legend = {},
+      legendDef = {};
+
+  function reset() { legendDef.type = null; }
+  function ingest(d, i) { return {data: d, index: i}; }
+
+  legend.def = function() {
+    var scale = size || shape || fill || stroke;
+    
+    format = !formatString ? null : ((scale.type === 'time') ?
+      dl.format.time(formatString) : dl.format.number(formatString));
+    
+    if (!legendDef.type) {
+      legendDef = (scale===fill || scale===stroke) && !discrete(scale.type) ?
+        quantDef(scale) : ordinalDef(scale);      
+    }
+    legendDef.orient = orient;
+    legendDef.offset = offset;
+    legendDef.padding = padding;
+    return legendDef;
+  };
+
+  function discrete(type) {
+    return type==='ordinal' || type==='quantize' ||
+           type==='quantile' || type==='threshold';
+  }
+
+  function ordinalDef(scale) {
+    var def = o_legend_def(size, shape, fill, stroke);
+
+    // generate data
+    var data = (values == null ?
+      (scale.ticks ? scale.ticks.apply(scale, tickArguments) : scale.domain()) :
+      values).map(ingest);
+    var fmt = format==null ? (scale.tickFormat ? scale.tickFormat.apply(scale, tickArguments) : String) : format;
+    
+    // determine spacing between legend entries
+    var fs, range, offset, pad=5, domain = d3.range(data.length);
+    if (size) {
+      range = data.map(function(x) { return Math.sqrt(size(x.data)); });
+      offset = d3.max(range);
+      range = range.reduce(function(a,b,i,z) {
+          if (i > 0) a[i] = a[i-1] + z[i-1]/2 + pad;
+          return (a[i] += b/2, a); }, [0]).map(Math.round);
+    } else {
+      offset = Math.round(Math.sqrt(config.legend.symbolSize));
+      range = spacing ||
+        (fs = labelStyle.fontSize) && (fs.value + pad) ||
+        (config.legend.labelFontSize + pad);
+      range = domain.map(function(d,i) {
+        return Math.round(offset/2 + i*range);
+      });
+    }
+
+    // account for padding and title size
+    var sz = padding, ts;
+    if (title) {
+      ts = titleStyle.fontSize;
+      sz += 5 + ((ts && ts.value) || config.legend.titleFontSize);
+    }
+    for (var i=0, n=range.length; i<n; ++i) range[i] += sz;
+    
+    // build scale for label layout
+    var scaleSpec = {
+      name: 'legend',
+      type: 'ordinal',
+      points: true,
+      domain: domain,
+      range: range
+    };
+    
+    // update legend def
+    var tdata = (title ? [title] : []).map(ingest);
+    data.forEach(function(d) {
+      d.label = fmt(d.data);
+      d.offset = offset;
+    });
+    def.scales = [ scaleSpec ];
+    def.marks[0].from = function() { return tdata; };
+    def.marks[1].from = function() { return data; };
+    def.marks[2].from = def.marks[1].from;
+
+    return def;
+  }
+
+  function o_legend_def(size, shape, fill, stroke) {
+    // setup legend marks
+    var titles  = dl.extend(m.titles, vg_legendTitle(config)),
+        symbols = dl.extend(m.symbols, vg_legendSymbols(config)),
+        labels  = dl.extend(m.labels, vg_vLegendLabels(config));
+
+    // extend legend marks
+    vg_legendSymbolExtend(symbols, size, shape, fill, stroke);
+    
+    // add / override custom style properties
+    dl.extend(titles.properties.update,  titleStyle);
+    dl.extend(symbols.properties.update, symbolStyle);
+    dl.extend(labels.properties.update,  labelStyle);
+
+    // padding from legend border
+    titles.properties.enter.x.value += padding;
+    titles.properties.enter.y.value += padding;
+    labels.properties.enter.x.offset += padding + 1;
+    symbols.properties.enter.x.offset = padding + 1;
+    labels.properties.update.x.offset += padding + 1;
+    symbols.properties.update.x.offset = padding + 1;
+
+    dl.extend(legendDef, {
+      type: 'group',
+      interactive: false,
+      properties: {
+        enter: parseProperties(model, 'group', legendStyle),
+        vg_legendPosition: {
+          encode: vg_legendPosition,
+          signals: [], scales:[], data: [], fields: []
+        }
+      }
+    });
+
+    legendDef.marks = [titles, symbols, labels].map(function(m) { return parseMark(model, m); });
+    return legendDef;
+  }
+
+  function quantDef(scale) {
+    var def = q_legend_def(scale),
+        dom = scale.domain(),
+        data = (values == null ?
+          (scale.ticks ? scale.ticks.apply(scale, tickArguments) : scale.domain()) :
+          values).map(ingest),
+        width = (gradientStyle.width && gradientStyle.width.value) || config.legend.gradientWidth,
+        fmt = format==null ? (scale.tickFormat ? scale.tickFormat.apply(scale, tickArguments) : String) : format;
+
+    // build scale for label layout
+    var layoutSpec = {
+      name: 'legend',
+      type: scale.type,
+      round: true,
+      zero: false,
+      domain: [dom[0], dom[dom.length-1]],
+      range: [padding, width+padding]
+    };
+    if (scale.type==='pow') layoutSpec.exponent = scale.exponent();
+    
+    // update legend def
+    var tdata = (title ? [title] : []).map(ingest);
+    data.forEach(function(d,i) {
+      d.label = fmt(d.data);
+      d.align = i==(data.length-1) ? 'right' : i===0 ? 'left' : 'center';
+    });
+    def.scales = [ layoutSpec ];
+    def.marks[0].from = function() { return tdata; };
+    def.marks[1].from = function() { return [1]; };
+    def.marks[2].from = function() { return data; };
+    return def;
+  }
+  
+  function q_legend_def(scale) {
+    // setup legend marks
+    var titles = dl.extend(m.titles, vg_legendTitle(config)),
+        gradient = dl.extend(m.gradient, vg_legendGradient(config)),
+        labels = dl.extend(m.labels, vg_hLegendLabels(config)),
+        grad = new Gradient();
+
+    // setup color gradient
+    var dom = scale.domain(),
+        min = dom[0],
+        max = dom[dom.length-1],
+        f = scale.copy().domain([min, max]).range([0,1]);
+        
+    var stops = (scale.type !== 'linear' && scale.ticks) ?
+      scale.ticks.call(scale, 15) : dom;
+    if (min !== stops[0]) stops.unshift(min);
+    if (max !== stops[stops.length-1]) stops.push(max);
+
+    for (var i=0, n=stops.length; i<n; ++i) {
+      grad.stop(f(stops[i]), scale(stops[i]));
+    }
+    gradient.properties.enter.fill = {value: grad};
+
+    // add / override custom style properties
+    dl.extend(titles.properties.update, titleStyle);
+    dl.extend(gradient.properties.update, gradientStyle);
+    dl.extend(labels.properties.update, labelStyle);
+
+    // account for gradient size
+    var gp = gradient.properties, gh = gradientStyle.height,
+        hh = (gh && gh.value) || gp.enter.height.value;
+    labels.properties.enter.y.value = hh;
+    labels.properties.update.y.value = hh;
+
+    // account for title size as needed
+    if (title) {
+      var tp = titles.properties, fs = titleStyle.fontSize,
+          sz = 4 + ((fs && fs.value) || tp.enter.fontSize.value);
+      gradient.properties.enter.y.value += sz;
+      labels.properties.enter.y.value += sz;
+      gradient.properties.update.y.value += sz;
+      labels.properties.update.y.value += sz;
+    }
+    
+    // padding from legend border
+    titles.properties.enter.x.value += padding;
+    titles.properties.enter.y.value += padding;
+    gradient.properties.enter.x.value += padding;
+    gradient.properties.enter.y.value += padding;
+    labels.properties.enter.y.value += padding;
+    gradient.properties.update.x.value += padding;
+    gradient.properties.update.y.value += padding;
+    labels.properties.update.y.value += padding;
+
+    dl.extend(legendDef, {
+      type: 'group',
+      interactive: false,
+      properties: {
+        enter: parseProperties(model, 'group', legendStyle),
+        vg_legendPosition: {
+          encode: vg_legendPosition,
+          signals: [], scales: [], data: [], fields: []
+        }
+      }
+    });
+
+    legendDef.marks = [titles, gradient, labels].map(function(m) { return parseMark(model, m); });
+    return legendDef;
+  }
+
+  legend.size = function(x) {
+    if (!arguments.length) return size;
+    if (size !== x) { size = x; reset(); }
+    return legend;
+  };
+
+  legend.shape = function(x) {
+    if (!arguments.length) return shape;
+    if (shape !== x) { shape = x; reset(); }
+    return legend;
+  };
+
+  legend.fill = function(x) {
+    if (!arguments.length) return fill;
+    if (fill !== x) { fill = x; reset(); }
+    return legend;
+  };
+  
+  legend.stroke = function(x) {
+    if (!arguments.length) return stroke;
+    if (stroke !== x) { stroke = x; reset(); }
+    return legend;
+  };
+
+  legend.title = function(x) {
+    if (!arguments.length) return title;
+    if (title !== x) { title = x; reset(); }
+    return legend;
+  };
+
+  legend.format = function(x) {
+    if (!arguments.length) return formatString;
+    if (formatString !== x) {
+      formatString = x;
+      reset();
+    }
+    return legend;
+  };
+
+  legend.spacing = function(x) {
+    if (!arguments.length) return spacing;
+    if (spacing !== +x) { spacing = +x; reset(); }
+    return legend;
+  };
+
+  legend.orient = function(x) {
+    if (!arguments.length) return orient;
+    orient = x in vg_legendOrients ? x + '' : config.legend.orient;
+    return legend;
+  };
+
+  legend.offset = function(x) {
+    if (!arguments.length) return offset;
+    offset = +x;
+    return legend;
+  };
+
+  legend.values = function(x) {
+    if (!arguments.length) return values;
+    values = x;
+    return legend;
+  };
+
+  legend.legendProperties = function(x) {
+    if (!arguments.length) return legendStyle;
+    legendStyle = x;
+    return legend;
+  };
+
+  legend.symbolProperties = function(x) {
+    if (!arguments.length) return symbolStyle;
+    symbolStyle = x;
+    return legend;
+  };
+
+  legend.gradientProperties = function(x) {
+    if (!arguments.length) return gradientStyle;
+    gradientStyle = x;
+    return legend;
+  };
+
+  legend.labelProperties = function(x) {
+    if (!arguments.length) return labelStyle;
+    labelStyle = x;
+    return legend;
+  };
+  
+  legend.titleProperties = function(x) {
+    if (!arguments.length) return titleStyle;
+    titleStyle = x;
+    return legend;
+  };
+
+  legend.reset = function() { 
+    reset(); 
+    return legend;
+  };
+
+  return legend;
+}
+
+var vg_legendOrients = {right: 1, left: 1};
+
+function vg_legendPosition(item, group, trans, db, signals, predicates) {
+  var o = trans ? {} : item, gx,
+      offset = item.mark.def.offset,
+      orient = item.mark.def.orient,
+      pad    = item.mark.def.padding * 2,
+      lw     = ~~item.bounds.width() + (item.width ? 0 : pad),
+      lh     = ~~item.bounds.height() + (item.height ? 0 : pad),
+      pos = group._legendPositions || 
+        (group._legendPositions = {right: 0.5, left: 0.5});
+
+  o.x = 0.5;
+  o.width = lw;
+  o.y = pos[orient];
+  pos[orient] += (o.height = lh);
+
+  // HACK: use to estimate group bounds during animated transition
+  if (!trans && group.bounds) {
+    group.bounds.delta = group.bounds.x2 - group.width;
+  }
+
+  switch (orient) {
+    case 'left':  {
+      gx = group.bounds ? group.bounds.x1 : 0;
+      o.x += gx - offset - lw;
+      break;
+    }
+    case 'right': {
+      gx = group.width + (group.bounds && trans ? group.bounds.delta : 0);
+      o.x += gx + offset;
+      break;
+    }
+  }
+  
+  if (trans) trans.interpolate(item, o);
+  var enc = item.mark.def.properties.enter.encode;
+  enc.call(enc, item, group, trans, db, signals, predicates);
+  return true;
+}
+
+function vg_legendSymbolExtend(mark, size, shape, fill, stroke) {
+  var e = mark.properties.enter,
+      u = mark.properties.update;
+  if (size)   e.size   = u.size   = {scale: size.scaleName,   field: 'data'};
+  if (shape)  e.shape  = u.shape  = {scale: shape.scaleName,  field: 'data'};
+  if (fill)   e.fill   = u.fill   = {scale: fill.scaleName,   field: 'data'};
+  if (stroke) e.stroke = u.stroke = {scale: stroke.scaleName, field: 'data'};
+}
+
+function vg_legendTitle(config) {
+  var cfg = config.legend;
+  return {
+    type: 'text',
+    interactive: false,
+    key: 'data',
+    properties: {
+      enter: {
+        x: {value: 0},
+        y: {value: 0},
+        fill: {value: cfg.titleColor},
+        font: {value: cfg.titleFont},
+        fontSize: {value: cfg.titleFontSize},
+        fontWeight: {value: cfg.titleFontWeight},
+        baseline: {value: 'top'},
+        text: {field: 'data'},
+        opacity: {value: 1e-6}
+      },
+      exit: { opacity: {value: 1e-6} },
+      update: { opacity: {value: 1} }
+    }
+  };
+}
+
+function vg_legendSymbols(config) {
+  var cfg = config.legend;
+  return {
+    type: 'symbol',
+    interactive: false,
+    key: 'data',
+    properties: {
+      enter: {
+        x: {field: 'offset', mult: 0.5},
+        y: {scale: 'legend', field: 'index'},
+        shape: {value: cfg.symbolShape},
+        size: {value: cfg.symbolSize},
+        stroke: {value: cfg.symbolColor},
+        strokeWidth: {value: cfg.symbolStrokeWidth},
+        opacity: {value: 1e-6}
+      },
+      exit: { opacity: {value: 1e-6} },
+      update: {
+        x: {field: 'offset', mult: 0.5},
+        y: {scale: 'legend', field: 'index'},
+        opacity: {value: 1}
+      }
+    }
+  };
+}
+
+function vg_vLegendLabels(config) {
+  var cfg = config.legend;
+  return {
+    type: 'text',
+    interactive: false,
+    key: 'data',
+    properties: {
+      enter: {
+        x: {field: 'offset', offset: 5},
+        y: {scale: 'legend', field: 'index'},
+        fill: {value: cfg.labelColor},
+        font: {value: cfg.labelFont},
+        fontSize: {value: cfg.labelFontSize},
+        align: {value: cfg.labelAlign},
+        baseline: {value: cfg.labelBaseline},
+        text: {field: 'label'},
+        opacity: {value: 1e-6}
+      },
+      exit: { opacity: {value: 1e-6} },
+      update: {
+        opacity: {value: 1},
+        x: {field: 'offset', offset: 5},
+        y: {scale: 'legend', field: 'index'},
+      }
+    }
+  };
+}
+
+function vg_legendGradient(config) {
+  var cfg = config.legend;
+  return {
+    type: 'rect',
+    interactive: false,
+    properties: {
+      enter: {
+        x: {value: 0},
+        y: {value: 0},
+        width: {value: cfg.gradientWidth},
+        height: {value: cfg.gradientHeight},
+        stroke: {value: cfg.gradientStrokeColor},
+        strokeWidth: {value: cfg.gradientStrokeWidth},
+        opacity: {value: 1e-6}
+      },
+      exit: { opacity: {value: 1e-6} },
+      update: {
+        x: {value: 0},
+        y: {value: 0},
+        opacity: {value: 1}
+      }
+    }
+  };
+}
+
+function vg_hLegendLabels(config) {
+  var cfg = config.legend;
+  return {
+    type: 'text',
+    interactive: false,
+    key: 'data',
+    properties: {
+      enter: {
+        x: {scale: 'legend', field: 'data'},
+        y: {value: 20},
+        dy: {value: 2},
+        fill: {value: cfg.labelColor},
+        font: {value: cfg.labelFont},
+        fontSize: {value: cfg.labelFontSize},
+        align: {field: 'align'},
+        baseline: {value: 'top'},
+        text: {field: 'label'},
+        opacity: {value: 1e-6}
+      },
+      exit: { opacity: {value: 1e-6} },
+      update: {
+        x: {scale: 'legend', field: 'data'},
+        y: {value: 20},
+        opacity: {value: 1}
+      }
+    }
+  };
+}
+
+module.exports = lgnd;
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{"../parse/mark":97,"../parse/properties":102,"datalib":24,"vega-scenegraph":46}],115:[function(require,module,exports){
+module.exports = function visit(node, func) {
+  var i, n, s, m, items;
+  if (func(node)) return true;
+
+  var sets = ['items', 'axisItems', 'legendItems'];
+  for (s=0, m=sets.length; s<m; ++s) {
+    if ((items = node[sets[s]])) {
+      for (i=0, n=items.length; i<n; ++i) {
+        if (visit(items[i], func)) return true;
+      }
+    }
+  }
+};
+},{}],116:[function(require,module,exports){
+var dl = require('datalib'),
+    df = require('vega-dataflow'),
+    log = require('vega-logging'),
+    ChangeSet = df.ChangeSet,
+    Tuple = df.Tuple,
+    Deps = df.Dependencies,
+    Transform = require('./Transform'),
+    Facetor = require('./Facetor');
+
+function Aggregate(graph) {
+  Transform.prototype.init.call(this, graph);
+
+  Transform.addParameters(this, {
+    groupby: {type: 'array<field>'},
+    summarize: {
+      type: 'custom', 
+      set: function(summarize) {
+        var signalDeps = {},
+            tx = this._transform,
+            i, len, f, fields, name, ops;
+
+        if (!dl.isArray(fields = summarize)) { // Object syntax from dl
+          fields = [];
+          for (name in summarize) {
+            ops = dl.array(summarize[name]);
+            fields.push({field: name, ops: ops});
+          }
+        }
+
+        function sg(x) { if (x.signal) signalDeps[x.signal] = 1; }
+
+        for (i=0, len=fields.length; i<len; ++i) {
+          f = fields[i];
+          if (f.field.signal) { signalDeps[f.field.signal] = 1; }
+          dl.array(f.ops).forEach(sg);
+          dl.array(f.as).forEach(sg);
+        }
+
+        tx._fields = fields;
+        tx._aggr = null;
+        tx.dependency(Deps.SIGNALS, dl.keys(signalDeps));
+        return tx;
+      }
+    }
+  });
+
+  this._aggr  = null; // dl.Aggregator
+  this._input = null; // Used by Facetor._on_keep.
+  this._args  = null; // To cull re-computation.
+  this._fields = [];
+  this._out = [];
+
+  this._type = TYPES.TUPLE; 
+  this._acc = {groupby: dl.true, value: dl.true};
+
+  return this.router(true).produces(true);
+}
+
+var prototype = (Aggregate.prototype = Object.create(Transform.prototype));
+prototype.constructor = Aggregate;
+
+var TYPES = Aggregate.TYPES = {
+  VALUE: 1, 
+  TUPLE: 2, 
+  MULTI: 3
+};
+
+Aggregate.VALID_OPS = [
+  'values', 'count', 'valid', 'missing', 'distinct', 
+  'sum', 'mean', 'average', 'variance', 'variancep', 'stdev', 
+  'stdevp', 'median', 'q1', 'q3', 'modeskew', 'min', 'max', 
+  'argmin', 'argmax'
+];
+
+prototype.type = function(type) { 
+  return (this._type = type, this); 
+};
+
+prototype.accessors = function(groupby, value) {
+  var acc = this._acc;
+  acc.groupby = dl.$(groupby) || dl.true;
+  acc.value = dl.$(value) || dl.true;
+};
+
+prototype.aggr = function() {
+  if (this._aggr) return this._aggr;
+
+  var g = this._graph,
+      hasGetter = false,
+      args = [],
+      groupby = this.param('groupby').field,
+      value = function(x) { return x.signal ? g.signalRef(x.signal) : x; };
+
+  // Prepare summarize fields.
+  var fields = this._fields.map(function(f) {
+    var field = {
+      name: value(f.field),
+      as:   dl.array(f.as),
+      ops:  dl.array(value(f.ops)).map(value),
+      get:  f.get
+    };
+    hasGetter = hasGetter || field.get != null;
+    args.push(field.name);
+    return field;
+  });
+
+  // If there is an arbitrary getter, all bets are off.
+  // Otherwise, we can check argument fields to cull re-computation.
+  groupby.forEach(function(g) {
+    if (g.get) hasGetter = true;
+    args.push(g.name || g);
+  });
+  this._args = hasGetter || !fields.length ? null : args;
+
+  if (!fields.length) fields = {'*': 'values'};
+
+  // Instatiate our aggregator instance.
+  // Facetor is a special subclass that can facet into data pipelines.
+  var aggr = this._aggr = new Facetor()
+    .groupby(groupby)
+    .stream(true)
+    .summarize(fields);
+
+  // Collect output fields sets by this aggregate.
+  this._out = getFields(aggr);
+
+  // If we are processing tuples, key them by '_id'.
+  if (this._type !== TYPES.VALUE) { aggr.key('_id'); }
+
+  return aggr;
+};
+
+function getFields(aggr) {
+  // Collect the output fields set by this aggregate.
+  var f = [], i, n, j, m, dims, vals, meas;
+
+  dims = aggr._dims;
+  for (i=0, n=dims.length; i<n; ++i) {
+    f.push(dims[i].name);
+  }
+
+  vals = aggr._aggr;
+  for (i=0, n=vals.length; i<n; ++i) {
+    meas = vals[i].measures.fields;
+    for (j=0, m=meas.length; j<m; ++j) {
+      f.push(meas[j]);
+    }
+  }
+
+  return f;
+}
+
+prototype.transform = function(input, reset) {
+  log.debug(input, ['aggregate']);
+  this._input = input; // Used by Facetor._on_keep.
+
+  var output = ChangeSet.create(input),
+      aggr = this.aggr(),
+      out = this._out,
+      args = this._args,
+      reeval = true,
+      p = Tuple.prev,
+      add, rem, mod, i;
+
+  // Upon reset, retract prior tuples and re-initialize.
+  if (reset) {
+    output.rem.push.apply(output.rem, aggr.result());
+    aggr.clear();
+    this._aggr = null;
+    aggr = this.aggr();
+  }
+
+  // Get update methods according to input type.
+  if (this._type === TYPES.TUPLE) {
+    add = function(x) { aggr._add(x); Tuple.prev_init(x); };
+    rem = function(x) { aggr._rem(p(x)); };
+    mod = function(x) { aggr._mod(x, p(x)); };
+  } else {
+    var gby = this._acc.groupby,
+        val = this._acc.value,
+        get = this._type === TYPES.VALUE ? val : function(x) {
+          return { _id: x._id, groupby: gby(x), value: val(x) };
+        };
+    add = function(x) { aggr._add(get(x)); Tuple.prev_init(x); };
+    rem = function(x) { aggr._rem(get(p(x))); };
+    mod = function(x) { aggr._mod(get(x), get(p(x))); };
+  }
+
+  input.add.forEach(add);
+  if (reset) {
+    // A signal change triggered reflow. Add everything.
+    // No need for rem, we cleared the aggregator.
+    input.mod.forEach(add);
+  } else {
+    input.rem.forEach(rem);
+
+    // If possible, check argument fields to see if we need to re-process mods.
+    if (args) for (i=0, reeval=false; i<args.length; ++i) {
+      if (input.fields[args[i]]) { reeval = true; break; }
+    }
+    if (reeval) input.mod.forEach(mod);
+  }
+
+  // Indicate output fields and return aggregate tuples.
+  for (i=0; i<out.length; ++i) {
+    output.fields[out[i]] = 1;
+  }
+  return aggr.changes(output);
+};
+
+module.exports = Aggregate;
+},{"./Facetor":122,"./Transform":135,"datalib":24,"vega-dataflow":39,"vega-logging":45}],117:[function(require,module,exports){
+var Base = require('./Transform').prototype;
+
+function BatchTransform() {
+  // Nearest appropriate collector. 
+  // Set by the dataflow Graph during connection.
+  this._collector = null; 
+}
+
+var prototype = (BatchTransform.prototype = Object.create(Base));
+prototype.constructor = BatchTransform;
+
+prototype.init = function(graph) {
+  Base.init.call(this, graph);
+  return this.batch(true);
+};
+
+prototype.transform = function(input) {
+  return this.batchTransform(input, this._collector.data());
+};
+
+prototype.batchTransform = function(/* input, data */) {
+};
+
+module.exports = BatchTransform;
+},{"./Transform":135}],118:[function(require,module,exports){
+var bins = require('datalib').bins,
+    Tuple = require('vega-dataflow').Tuple,
+    log = require('vega-logging'),
+    Transform = require('./Transform');
+
+function Bin(graph) {
+  Transform.prototype.init.call(this, graph);
+  Transform.addParameters(this, {
+    field: {type: 'field'},
+    min: {type: 'value'},
+    max: {type: 'value'},
+    base: {type: 'value', default: 10},
+    maxbins: {type: 'value', default: 20},
+    step: {type: 'value'},
+    steps: {type: 'value'},
+    minstep: {type: 'value'},
+    div: {type: 'array<value>', default: [5, 2]}
+  });
+
+  this._output = {bin: 'bin'};
+  return this.mutates(true);
+}
+
+var prototype = (Bin.prototype = Object.create(Transform.prototype));
+prototype.constructor = Bin;
+
+prototype.transform = function(input) {
+  log.debug(input, ['binning']);
+
+  var output  = this._output.bin,
+      step    = this.param('step'),
+      steps   = this.param('steps'),
+      minstep = this.param('minstep'),
+      get     = this.param('field').accessor,
+      opt = {
+        min: this.param('min'),
+        max: this.param('max'),
+        base: this.param('base'),
+        maxbins: this.param('maxbins'),
+        div: this.param('div')
+      };
+
+  if (step) opt.step = step;
+  if (steps) opt.steps = steps;
+  if (minstep) opt.minstep = minstep;
+  var b = bins(opt);
+
+  function update(d) {
+    var v = get(d);
+    v = v == null ? null
+      : b.start + b.step * ~~((v - b.start) / b.step);
+    Tuple.set(d, output, v);
+  }
+  input.add.forEach(update);
+  input.mod.forEach(update);
+  input.rem.forEach(update);
+
+  input.fields[output] = 1;
+  return input;
+};
+
+module.exports = Bin;
+},{"./Transform":135,"datalib":24,"vega-dataflow":39,"vega-logging":45}],119:[function(require,module,exports){
+var df = require('vega-dataflow'),
+    Tuple = df.Tuple,
+    log = require('vega-logging'),
+    Transform = require('./Transform');
+
+function CountPattern(graph) {
+  Transform.prototype.init.call(this, graph);
+  Transform.addParameters(this, {
+    field:     {type: 'field', default: 'data'},
+    pattern:   {type: 'value', default: '[\\w\']+'},
+    case:      {type: 'value', default: 'lower'},
+    stopwords: {type: 'value', default: ''}
+  });
+
+  this._output = {text: 'text', count: 'count'};
+
+  return this.router(true).produces(true);
+}
+
+var prototype = (CountPattern.prototype = Object.create(Transform.prototype));
+prototype.constructor = CountPattern;
+
+prototype.transform = function(input, reset) {
+  log.debug(input, ['countpattern']);
+
+  var get = this.param('field').accessor,
+      pattern = this.param('pattern'),
+      stop = this.param('stopwords'),
+      rem = false;
+
+  // update parameters
+  if (this._stop !== stop) {
+    this._stop = stop;
+    this._stop_re = new RegExp('^' + stop + '$', 'i');
+    reset = true;
+  }
+
+  if (this._pattern !== pattern) {
+    this._pattern = pattern;
+    this._match = new RegExp(this._pattern, 'g');
+    reset = true;
+  }
+
+  if (reset) this._counts = {};
+
+  function curr(t) { return (Tuple.prev_init(t), get(t)); }
+  function prev(t) { return get(Tuple.prev(t)); }
+
+  this._add(input.add, curr);
+  if (!reset) this._rem(input.rem, prev);
+  if (reset || (rem = input.fields[get.field])) {
+    if (rem) this._rem(input.mod, prev);
+    this._add(input.mod, curr);
+  }
+
+  // generate output tuples
+  return this._changeset(input);
+};
+
+prototype._changeset = function(input) {
+  var counts = this._counts,
+      tuples = this._tuples || (this._tuples = {}),
+      change = df.ChangeSet.create(input),
+      out = this._output, w, t, c;
+
+  for (w in counts) {
+    t = tuples[w];
+    c = counts[w] || 0;
+    if (!t && c) {
+      tuples[w] = (t = Tuple.ingest({}));
+      t[out.text] = w;
+      t[out.count] = c;
+      change.add.push(t);
+    } else if (c === 0) {
+      if (t) change.rem.push(t);
+      delete counts[w];
+      delete tuples[w];
+    } else if (t[out.count] !== c) {
+      Tuple.set(t, out.count, c);
+      change.mod.push(t);
+    }
+  }
+  return change;
+};
+
+prototype._tokenize = function(text) {
+  switch (this.param('case')) {
+    case 'upper': text = text.toUpperCase(); break;
+    case 'lower': text = text.toLowerCase(); break;
+  }
+  return text.match(this._match);
+};
+
+prototype._add = function(tuples, get) {
+  var counts = this._counts,
+      stop = this._stop_re,
+      tok, i, j, t;
+
+  for (j=0; j<tuples.length; ++j) {
+    tok = this._tokenize(get(tuples[j]));
+    for (i=0; i<tok.length; ++i) {
+      if (!stop.test(t=tok[i])) {
+        counts[t] = 1 + (counts[t] || 0);
+      }
+    }
+  }
+};
+
+prototype._rem = function(tuples, get) {
+  var counts = this._counts,
+      stop = this._stop_re,
+      tok, i, j, t;
+
+  for (j=0; j<tuples.length; ++j) {
+    tok = this._tokenize(get(tuples[j]));
+    for (i=0; i<tok.length; ++i) {
+      if (!stop.test(t=tok[i])) {
+        counts[t] -= 1;
+      }
+    }
+  }
+};
+
+module.exports = CountPattern;
+},{"./Transform":135,"vega-dataflow":39,"vega-logging":45}],120:[function(require,module,exports){
+var df = require('vega-dataflow'),
+    ChangeSet = df.ChangeSet,
+    Tuple = df.Tuple,
+    SIGNALS = df.Dependencies.SIGNALS,
+    log = require('vega-logging'),
+    Transform = require('./Transform'),
+    BatchTransform = require('./BatchTransform');
+
+function Cross(graph) {
+  BatchTransform.prototype.init.call(this, graph);
+  Transform.addParameters(this, {
+    with: {type: 'data'},
+    diagonal: {type: 'value', default: 'true'},
+    filter: {type: 'expr'}
+  });
+
+  this._output = {'left': 'a', 'right': 'b'};
+  this._lastRem  = null; // Most recent stamp that rem occured. 
+  this._lastWith = null; // Last time we crossed w/withds.
+  this._ids   = {};
+  this._cache = {};
+
+  return this.router(true).produces(true);
+}
+
+var prototype = (Cross.prototype = Object.create(BatchTransform.prototype));
+prototype.constructor = Cross;
+
+// Each cached incoming tuple also has a stamp to track if we need to do
+// lazy filtering of removed tuples.
+function cache(x, t) {
+  var c = this._cache[x._id] = this._cache[x._id] || {c: [], s: this._stamp};
+  c.c.push(t);
+}
+
+function add(output, left, data, diag, test, x) {
+  var i = 0, len = data.length, t = {}, y, id;
+
+  for (; i<len; ++i) {
+    y = data[i];
+    id = left ? x._id+'_'+y._id : y._id+'_'+x._id;
+    if (this._ids[id]) continue;
+    if (x._id == y._id && !diag) continue;
+
+    t[this._output.left]  = left ? x : y;
+    t[this._output.right] = left ? y : x;
+
+    // Only ingest a tuple if we keep it around.
+    if (!test || test(t)) {
+      output.add.push(t=Tuple.ingest(t));
+      cache.call(this, x, t);
+      cache.call(this, y, t);
+      this._ids[id] = 1;
+      t = {};
+    }    
+  }
+}
+
+function mod(output, left, x) {
+  var cross = this,
+      c = this._cache[x._id];
+
+  if (this._lastRem > c.s) {  // Removed tuples haven't been filtered yet
+    c.c = c.c.filter(function(y) {
+      var t = y[cross._output[left ? 'right' : 'left']];
+      return cross._cache[t._id] !== null;
+    });
+    c.s = this._lastRem;
+  }
+
+  output.mod.push.apply(output.mod, c.c);
+}
+
+function rem(output, x) {
+  output.rem.push.apply(output.rem, this._cache[x._id].c);
+  this._cache[x._id] = null;
+  this._lastRem = this._stamp;
+}
+
+function upFields(input, output) {
+  if (input.add.length || input.rem.length) {
+    output.fields[this._output.left]  = 1; 
+    output.fields[this._output.right] = 1;
+  }
+}
+
+prototype.batchTransform = function(input, data) {
+  log.debug(input, ['crossing']);
+
+  var w = this.param('with'),
+      f = this.param('filter'),
+      diag = this.param('diagonal'),
+      graph = this._graph,
+      signals = graph.values(SIGNALS, this.dependency(SIGNALS)),
+      test = f ? function(x) {return f(x, null, signals); } : null,
+      selfCross = (!w.name),
+      woutput = selfCross ? input : w.source.last(),
+      wdata   = selfCross ? data : w.source.values(),
+      output  = ChangeSet.create(input),
+      r = rem.bind(this, output);
+
+  input.rem.forEach(r);
+  input.add.forEach(add.bind(this, output, true, wdata, diag, test));
+
+  if (!selfCross && woutput.stamp > this._lastWith) {
+    woutput.rem.forEach(r);
+    woutput.add.forEach(add.bind(this, output, false, data, diag, test));
+    woutput.mod.forEach(mod.bind(this, output, false));
+    upFields.call(this, woutput, output);
+    this._lastWith = woutput.stamp;
+  }
+
+  // Mods need to come after all removals have been run.
+  input.mod.forEach(mod.bind(this, output, true));
+  upFields.call(this, input, output);
+
+  return output;
+};
+
+module.exports = Cross;
+},{"./BatchTransform":117,"./Transform":135,"vega-dataflow":39,"vega-logging":45}],121:[function(require,module,exports){
+var Transform = require('./Transform'),
+    Aggregate = require('./Aggregate');
+
+function Facet(graph) {
+  Transform.addParameters(this, {
+    transform: {
+      type: "custom",
+      set: function(pipeline) {
+        return (this._transform._pipeline = pipeline, this._transform);
+      },
+      get: function() {
+        var parse = require('../parse/transforms'),
+            facet = this._transform;
+        return facet._pipeline.map(function(t) {
+          return parse(facet._graph, t);
+        });
+      }      
+    }
+  });
+
+  this._pipeline = [];
+  return Aggregate.call(this, graph);
+}
+
+var prototype = (Facet.prototype = Object.create(Aggregate.prototype));
+prototype.constructor = Facet;
+
+prototype.aggr = function() {
+  return Aggregate.prototype.aggr.call(this).facet(this);
+};
+
+module.exports = Facet;
+},{"../parse/transforms":106,"./Aggregate":116,"./Transform":135}],122:[function(require,module,exports){
+var dl = require('datalib'),
+    Aggregator = dl.Aggregator,
+    Base = Aggregator.prototype,
+    df = require('vega-dataflow'),
+    Tuple = df.Tuple,
+    log = require('vega-logging'),
+    facetID = 0;
+
+function Facetor() {
+  Aggregator.call(this);
+  this._facet = null;
+  this._facetID = ++facetID;
+}
+
+var prototype = (Facetor.prototype = Object.create(Base));
+prototype.constructor = Facetor;
+
+prototype.facet = function(f) {
+  return arguments.length ? (this._facet = f, this) : this._facet;
+};
+
+prototype._ingest = function(t) { 
+  return Tuple.ingest(t, null);
+};
+
+prototype._assign = Tuple.set;
+
+function disconnect_cell(facet) {
+  log.debug({}, ['disconnecting cell', this.tuple._id]);
+  var pipeline = this.ds.pipeline();
+  facet.removeListener(pipeline[0]);
+  facet._graph.removeListener(pipeline[0]);
+  facet._graph.disconnect(pipeline);
+}
+
+prototype._newcell = function(x, key) {
+  var cell  = Base._newcell.call(this, x, key),
+      facet = this._facet;
+
+  if (facet) {
+    var graph = facet._graph,
+        tuple = cell.tuple,
+        pipeline = facet.param('transform');
+    cell.ds = graph.data(tuple._facetID, pipeline, tuple);
+    cell.disconnect = disconnect_cell;
+    facet.addListener(pipeline[0]);
+  }
+
+  return cell;
+};
+
+prototype._newtuple = function(x, key) {
+  var t = Base._newtuple.call(this, x);
+  if (this._facet) {
+    Tuple.set(t, 'key', key);
+    Tuple.set(t, '_facetID', this._facetID + '_' + key);
+  }
+  return t;
+};
+
+prototype.clear = function() {
+  if (this._facet) {
+    for (var k in this._cells) {
+      this._cells[k].disconnect(this._facet);
+    }
+  }
+  return Base.clear.call(this);
+};
+
+prototype._on_add = function(x, cell) {
+  if (this._facet) cell.ds._input.add.push(x);
+};
+
+prototype._on_rem = function(x, cell) {
+  if (this._facet) cell.ds._input.rem.push(x);
+};
+
+prototype._on_mod = function(x, prev, cell0, cell1) {
+  if (this._facet) { // Propagate tuples
+    if (cell0 === cell1) {
+      cell0.ds._input.mod.push(x);
+    } else {
+      cell0.ds._input.rem.push(x);
+      cell1.ds._input.add.push(x);
+    }
+  }
+};
+
+prototype._on_drop = function(cell) {
+  if (this._facet) cell.disconnect(this._facet);
+};
+
+prototype._on_keep = function(cell) {
+  // propagate sort, signals, fields, etc.
+  if (this._facet) df.ChangeSet.copy(this._input, cell.ds._input);
+};
+
+module.exports = Facetor;
+},{"datalib":24,"vega-dataflow":39,"vega-logging":45}],123:[function(require,module,exports){
+var df = require('vega-dataflow'),
+    SIGNALS = df.Dependencies.SIGNALS,
+    log = require('vega-logging'),
+    Transform = require('./Transform');
+
+function Filter(graph) {
+  Transform.prototype.init.call(this, graph);
+  Transform.addParameters(this, {test: {type: 'expr'}});
+
+  this._skip = {};
+  return this.router(true);
+}
+
+var prototype = (Filter.prototype = Object.create(Transform.prototype));
+prototype.constructor = Filter;
+
+prototype.transform = function(input) {
+  log.debug(input, ['filtering']);
+
+  var output = df.ChangeSet.create(input),
+      graph = this._graph,
+      skip = this._skip,
+      test = this.param('test'),
+      signals = graph.values(SIGNALS, this.dependency(SIGNALS));
+
+  input.rem.forEach(function(x) {
+    if (skip[x._id] !== 1) output.rem.push(x);
+    else skip[x._id] = 0;
+  });
+
+  input.add.forEach(function(x) {
+    if (test(x, null, signals)) output.add.push(x);
+    else skip[x._id] = 1;
+  });
+
+  input.mod.forEach(function(x) {
+    var b = test(x, null, signals),
+        s = (skip[x._id] === 1);
+    if (b && s) {
+      skip[x._id] = 0;
+      output.add.push(x);
+    } else if (b && !s) {
+      output.mod.push(x);
+    } else if (!b && s) {
+      // do nothing, keep skip true
+    } else { // !b && !s
+      output.rem.push(x);
+      skip[x._id] = 1;
+    }
+  });
+
+  return output;
+};
+
+module.exports = Filter;
+},{"./Transform":135,"vega-dataflow":39,"vega-logging":45}],124:[function(require,module,exports){
+var df = require('vega-dataflow'),
+    Tuple = df.Tuple,
+    log = require('vega-logging'),
+    Transform = require('./Transform');
+
+function Fold(graph) {
+  Transform.prototype.init.call(this, graph);
+  Transform.addParameters(this, {
+    fields: {type: 'array<field>'} 
+  });
+
+  this._output = {key: 'key', value: 'value'};
+  this._cache = {};
+
+  return this.router(true).produces(true);
+}
+
+var prototype = (Fold.prototype = Object.create(Transform.prototype));
+prototype.constructor = Fold;
+
+prototype._reset = function(input, output) { 
+  for (var id in this._cache) {
+    output.rem.push.apply(output.rem, this._cache[id]);
+  }
+  this._cache = {};
+};
+
+prototype._tuple = function(x, i, len) {
+  var list = this._cache[x._id] || (this._cache[x._id] = Array(len));
+  return list[i] ? Tuple.rederive(x, list[i]) : (list[i] = Tuple.derive(x));
+};
+
+prototype._fn = function(data, on, out) {
+  var i, j, n, m, d, t;
+  for (i=0, n=data.length; i<n; ++i) {
+    d = data[i];
+    for (j=0, m=on.field.length; j<m; ++j) {
+      t = this._tuple(d, j, m);  
+      Tuple.set(t, this._output.key, on.field[j]);
+      Tuple.set(t, this._output.value, on.accessor[j](d));
+      out.push(t);
+    }      
+  }
+};
+
+prototype.transform = function(input, reset) {
+  log.debug(input, ['folding']);
+
+  var fold = this,
+      on = this.param('fields'),
+      output = df.ChangeSet.create(input);
+
+  if (reset) this._reset(input, output);
+
+  this._fn(input.add, on, output.add);
+  this._fn(input.mod, on, reset ? output.add : output.mod);
+  input.rem.forEach(function(x) {
+    output.rem.push.apply(output.rem, fold._cache[x._id]);
+    fold._cache[x._id] = null;
+  });
+
+  // If we're only propagating values, don't mark key/value as updated.
+  if (input.add.length || input.rem.length || 
+      on.field.some(function(f) { return !!input.fields[f]; })) {
+    output.fields[this._output.key] = 1;
+    output.fields[this._output.value] = 1;
+  }
+  return output;
+};
+
+module.exports = Fold;
+},{"./Transform":135,"vega-dataflow":39,"vega-logging":45}],125:[function(require,module,exports){
+(function (global){
+var d3 = (typeof window !== "undefined" ? window['d3'] : typeof global !== "undefined" ? global['d3'] : null),
+    df = require('vega-dataflow'),
+    Tuple = df.Tuple,
+    ChangeSet = df.ChangeSet,
+    log = require('vega-logging'),
+    Transform = require('./Transform');
+
+function Force(graph) {
+  Transform.prototype.init.call(this, graph);
+
+  this._prev = null;
+  this._interactive = false;
+  this._setup = true;
+  this._nodes  = [];
+  this._links = [];
+  this._layout = d3.layout.force();
+
+  Transform.addParameters(this, {
+    size: {type: 'array<value>', default: [500, 500]},
+    bound: {type: 'value', default: true},
+    links: {type: 'data'},
+
+    // TODO: for now force these to be value params only (pun-intended)
+    // Can update to include fields after Parameter refactoring.
+    linkStrength: {type: 'value', default: 1},
+    linkDistance: {type: 'value', default: 20},
+    charge: {type: 'value', default: -30},
+
+    chargeDistance: {type: 'value', default: Infinity},
+    friction: {type: 'value', default: 0.9},
+    theta: {type: 'value', default: 0.8},
+    gravity: {type: 'value', default: 0.1},
+    alpha: {type: 'value', default: 0.1},
+    iterations: {type: 'value', default: 500},
+
+    interactive: {type: 'value', default: this._interactive},    
+    active: {type: 'value', default: this._prev},
+    fixed: {type: 'data'}
+  });
+
+  this._output = {
+    'x': 'layout_x',
+    'y': 'layout_y'
+  };
+
+  return this.mutates(true);
+}
+
+var prototype = (Force.prototype = Object.create(Transform.prototype));
+prototype.constructor = Force;
+
+prototype.transform = function(nodeInput, reset) {
+  log.debug(nodeInput, ['force']);
+  reset = reset - (nodeInput.signals.active ? 1 : 0);
+
+  // get variables
+  var interactive = this.param('interactive'),
+      linkSource = this.param('links').source,
+      linkInput = linkSource.last(),
+      active = this.param('active'),
+      output = this._output,
+      layout = this._layout,
+      nodes = this._nodes,
+      links = this._links;
+
+  // configure nodes, links and layout
+  if (linkInput.stamp < nodeInput.stamp) linkInput = null;
+  this.configure(nodeInput, linkInput, interactive, reset);
+  
+  // run batch layout
+  if (!interactive) {
+    var iterations = this.param('iterations');
+    for (var i=0; i<iterations; ++i) layout.tick();
+    layout.stop();
+  }
+
+  // update node positions
+  this.update(active);
+
+  // re-up alpha on parameter change
+  if (reset || active !== this._prev && active && active.update) {
+    layout.alpha(this.param('alpha')); // re-start layout
+  }
+
+  // update active node status, 
+  if (active !== this._prev) {
+    this._prev = active;
+  }
+
+  // process removed nodes or edges
+  if (nodeInput.rem.length) {
+    layout.nodes(this._nodes = Tuple.idFilter(nodes, nodeInput.rem));
+  }
+  if (linkInput && linkInput.rem.length) {
+    layout.links(this._links = Tuple.idFilter(links, linkInput.rem));
+  }
+
+  // return changeset
+  nodeInput.fields[output.x] = 1;
+  nodeInput.fields[output.y] = 1;
+  return nodeInput;
+};
+
+prototype.configure = function(nodeInput, linkInput, interactive, reset) {
+  // check if we need to run configuration
+  var layout = this._layout,
+      update = this._setup || nodeInput.add.length ||
+            linkInput && linkInput.add.length ||
+            interactive !== this._interactive ||
+            this.param('charge') !== layout.charge() ||
+            this.param('linkStrength') !== layout.linkStrength() ||
+            this.param('linkDistance') !== layout.linkDistance();
+
+  if (update || reset) {
+    // a parameter changed, so update tick-only parameters
+    layout
+      .size(this.param('size'))
+      .chargeDistance(this.param('chargeDistance'))
+      .theta(this.param('theta'))
+      .gravity(this.param('gravity'))
+      .friction(this.param('friction'));
+  }
+
+  if (!update) return; // if no more updates needed, return now
+
+  this._setup = false;
+  this._interactive = interactive;
+
+  var force = this,
+      graph = this._graph,
+      nodes = this._nodes,
+      links = this._links, a, i;
+
+  // process added nodes
+  for (a=nodeInput.add, i=0; i<a.length; ++i) {
+    nodes.push({tuple: a[i]});
+  }
+
+  // process added edges
+  if (linkInput) for (a=linkInput.add, i=0; i<a.length; ++i) {
+    // TODO add configurable source/target accessors
+    // TODO support lookup by node id
+    // TODO process 'mod' of edge source or target?
+    links.push({
+      tuple:  a[i],
+      source: nodes[a[i].source],
+      target: nodes[a[i].target]
+    });
+  }
+
+  // setup handler for force layout tick events
+  var tickHandler = !interactive ? null : function() {
+    // re-schedule the transform, force reflow
+    graph.propagate(ChangeSet.create(null, true), force);
+  };
+
+  // configure the rest of the layout
+  layout
+    .linkStrength(this.param('linkStrength'))
+    .linkDistance(this.param('linkDistance'))
+    .charge(this.param('charge'))
+    .nodes(nodes)
+    .links(links)
+    .on('tick', tickHandler)
+    .start().alpha(this.param('alpha'));
+};
+
+prototype.update = function(active) {
+  var output = this._output,
+      bound = this.param('bound'),
+      fixed = this.param('fixed'),
+      size = this.param('size'),
+      nodes = this._nodes,
+      lut = {}, id, i, n, t, x, y;
+
+  if (fixed && fixed.source) {
+    // TODO: could cache and update as needed?
+    fixed = fixed.source.values();
+    for (i=0, n=fixed.length; i<n; ++i) {
+      lut[fixed[i].id] = 1;
+    }
+  }
+
+  for (i=0; i<nodes.length; ++i) {
+    n = nodes[i];
+    t = n.tuple;
+    id = t._id;
+
+    if (active && active.id === id) {
+      n.fixed = 1;
+      if (active.update) {
+        n.x = n.px = active.x;
+        n.y = n.py = active.y;
+      }
+    } else {
+      n.fixed = lut[id] || 0;
+    }
+
+    x = bound ? Math.max(0, Math.min(n.x, size[0])) : n.x;
+    y = bound ? Math.max(0, Math.min(n.y, size[1])) : n.y;
+    Tuple.set(t, output.x, x);
+    Tuple.set(t, output.y, y);
+  }
+};
+
+module.exports = Force;
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{"./Transform":135,"vega-dataflow":39,"vega-logging":45}],126:[function(require,module,exports){
+var df = require('vega-dataflow'),
+    Tuple = df.Tuple,
+    SIGNALS = df.Dependencies.SIGNALS,
+    log = require('vega-logging'),
+    Transform = require('./Transform');
+
+function Formula(graph) {
+  Transform.prototype.init.call(this, graph);
+  Transform.addParameters(this, {
+    field: {type: 'value'},
+    expr:  {type: 'expr'}
+  });
+
+  return this.mutates(true);
+}
+
+var prototype = (Formula.prototype = Object.create(Transform.prototype));
+prototype.constructor = Formula;
+
+prototype.transform = function(input) {
+  log.debug(input, ['formulating']);
+
+  var g = this._graph,
+      field = this.param('field'),
+      expr = this.param('expr'),
+      signals = g.values(SIGNALS, this.dependency(SIGNALS));
+
+  function set(x) {
+    Tuple.set(x, field, expr(x, null, signals));
+  }
+
+  input.add.forEach(set);
+  
+  if (this.reevaluate(input)) {
+    input.mod.forEach(set);
+  }
+
+  input.fields[field] = 1;
+  return input;
+};
+
+module.exports = Formula;
+},{"./Transform":135,"vega-dataflow":39,"vega-logging":45}],127:[function(require,module,exports){
+(function (global){
+var d3 = (typeof window !== "undefined" ? window['d3'] : typeof global !== "undefined" ? global['d3'] : null),
+    dl = require('datalib'),
+    Tuple = require('vega-dataflow').Tuple,
+    log = require('vega-logging'),
+    Transform = require('./Transform');
+
+function Geo(graph) {
+  Transform.prototype.init.call(this, graph);
+  Transform.addParameters(this, Geo.Parameters);
+  Transform.addParameters(this, {
+    lon: {type: 'field'},
+    lat: {type: 'field'}
+  });
+
+  this._output = {
+    'x': 'layout_x',
+    'y': 'layout_y'
+  };
+  return this.mutates(true);
+}
+
+Geo.Parameters = {
+  projection: {type: 'value', default: 'mercator'},
+  center:     {type: 'array<value>'},
+  translate:  {type: 'array<value>'},
+  rotate:     {type: 'array<value>'},
+  scale:      {type: 'value'},
+  precision:  {type: 'value'},
+  clipAngle:  {type: 'value'},
+  clipExtent: {type: 'value'}
+};
+
+Geo.d3Projection = function() {
+  var p = this.param('projection'),
+      param = Geo.Parameters,
+      proj, name, value;
+
+  if (p !== this._mode) {
+    this._mode = p;
+    this._projection = d3.geo[p]();
+  }
+  proj = this._projection;
+
+  for (name in param) {
+    if (name === 'projection' || !proj[name]) continue;
+    value = this.param(name);
+    if (value === undefined || (dl.isArray(value) && value.length === 0)) {
+      continue;
+    }
+    if (value !== proj[name]()) {
+      proj[name](value);
+    }
+  }
+
+  return proj;
+};
+
+var prototype = (Geo.prototype = Object.create(Transform.prototype));
+prototype.constructor = Geo;
+
+prototype.transform = function(input) {
+  log.debug(input, ['geo']);
+
+  var output = this._output,
+      lon = this.param('lon').accessor,
+      lat = this.param('lat').accessor,
+      proj = Geo.d3Projection.call(this);
+
+  function set(t) {
+    var ll = [lon(t), lat(t)];
+    var xy = proj(ll) || [null, null];
+    Tuple.set(t, output.x, xy[0]);
+    Tuple.set(t, output.y, xy[1]);
+  }
+
+  input.add.forEach(set);
+  if (this.reevaluate(input)) {
+    input.mod.forEach(set);
+    input.rem.forEach(set);
+  }
+
+  input.fields[output.x] = 1;
+  input.fields[output.y] = 1;
+  return input;
+};
+
+module.exports = Geo;
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{"./Transform":135,"datalib":24,"vega-dataflow":39,"vega-logging":45}],128:[function(require,module,exports){
+(function (global){
+var d3 = (typeof window !== "undefined" ? window['d3'] : typeof global !== "undefined" ? global['d3'] : null),
+    dl = require('datalib'),
+    Tuple = require('vega-dataflow').Tuple,
+    log = require('vega-logging'),
+    Geo = require('./Geo'),
+    Transform = require('./Transform');
+
+function GeoPath(graph) {
+  Transform.prototype.init.call(this, graph);
+  Transform.addParameters(this, Geo.Parameters);
+  Transform.addParameters(this, {
+    field: {type: 'field', default: null},
+  });
+
+  this._output = {
+    'path': 'layout_path'
+  };
+  return this.mutates(true);
+}
+
+var prototype = (GeoPath.prototype = Object.create(Transform.prototype));
+prototype.constructor = GeoPath;
+
+prototype.transform = function(input) {
+  log.debug(input, ['geopath']);
+
+  var output = this._output,
+      geojson = this.param('field').accessor || dl.identity,
+      proj = Geo.d3Projection.call(this),
+      path = d3.geo.path().projection(proj);
+
+  function set(t) {
+    Tuple.set(t, output.path, path(geojson(t)));
+  }
+
+  input.add.forEach(set);
+  if (this.reevaluate(input)) {
+    input.mod.forEach(set);
+    input.rem.forEach(set);
+  }
+
+  input.fields[output.path] = 1;
+  return input;
+};
+
+module.exports = GeoPath;
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{"./Geo":127,"./Transform":135,"datalib":24,"vega-dataflow":39,"vega-logging":45}],129:[function(require,module,exports){
+var Tuple = require('vega-dataflow').Tuple,
+    log = require('vega-logging'),
+    Transform = require('./Transform');
+
+function LinkPath(graph) {
+  Transform.prototype.init.call(this, graph);
+  Transform.addParameters(this, {
+    sourceX:  {type: 'field', default: '_source.layout_x'},
+    sourceY:  {type: 'field', default: '_source.layout_y'},
+    targetX:  {type: 'field', default: '_target.layout_x'},
+    targetY:  {type: 'field', default: '_target.layout_y'},
+    tension:  {type: 'value', default: 0.2},
+    shape:    {type: 'value', default: 'line'}
+  });
+
+  this._output = {'path': 'layout_path'};
+  return this.mutates(true);
+}
+
+var prototype = (LinkPath.prototype = Object.create(Transform.prototype));
+prototype.constructor = LinkPath;
+
+function line(sx, sy, tx, ty) {
+  return 'M' + sx + ',' + sy +
+         'L' + tx + ',' + ty;
+}
+
+function curve(sx, sy, tx, ty, tension) {
+  var dx = tx - sx,
+      dy = ty - sy,
+      ix = tension * (dx + dy),
+      iy = tension * (dy - dx);
+  return 'M' + sx + ',' + sy +
+         'C' + (sx+ix) + ',' + (sy+iy) +
+         ' ' + (tx+iy) + ',' + (ty-ix) +
+         ' ' + tx + ',' + ty;
+}
+
+function diagonalX(sx, sy, tx, ty) {
+  var m = (sx + tx) / 2;
+  return 'M' + sx + ',' + sy +
+         'C' + m  + ',' + sy +
+         ' ' + m  + ',' + ty +
+         ' ' + tx + ',' + ty;
+}
+
+function diagonalY(sx, sy, tx, ty) {
+  var m = (sy + ty) / 2;
+  return 'M' + sx + ',' + sy +
+         'C' + sx + ',' + m +
+         ' ' + tx + ',' + m +
+         ' ' + tx + ',' + ty;
+}
+
+var shapes = {
+  line:      line,
+  curve:     curve,
+  diagonal:  diagonalX,
+  diagonalX: diagonalX,
+  diagonalY: diagonalY
+};
+
+prototype.transform = function(input) {
+  log.debug(input, ['linkpath']);
+
+  var output = this._output,
+      shape = shapes[this.param('shape')] || shapes.line,
+      sourceX = this.param('sourceX').accessor,
+      sourceY = this.param('sourceY').accessor,
+      targetX = this.param('targetX').accessor,
+      targetY = this.param('targetY').accessor,
+      tension = this.param('tension');
+
+  function set(t) {
+    var path = shape(sourceX(t), sourceY(t), targetX(t), targetY(t), tension);
+    Tuple.set(t, output.path, path);
+  }
+
+  input.add.forEach(set);
+  if (this.reevaluate(input)) {
+    input.mod.forEach(set);
+    input.rem.forEach(set);
+  }
+
+  input.fields[output.path] = 1;
+  return input;
+};
+
+module.exports = LinkPath;
+},{"./Transform":135,"vega-dataflow":39,"vega-logging":45}],130:[function(require,module,exports){
+var Tuple = require('vega-dataflow').Tuple,
+    log = require('vega-logging'),
+    Transform = require('./Transform');
+
+function Lookup(graph) {
+  Transform.prototype.init.call(this, graph);
+  Transform.addParameters(this, {
+    on:      {type: 'data'},
+    onKey:   {type: 'field', default: null},
+    as:      {type: 'array<value>'},
+    keys:    {type: 'array<field>', default: ['data']},
+    default: {type: 'value'}
+  });
+
+  return this.mutates(true);
+}
+
+var prototype = (Lookup.prototype = Object.create(Transform.prototype));
+prototype.constructor = Lookup;
+
+prototype.transform = function(input, reset) {
+  log.debug(input, ['lookup']);
+
+  var on = this.param('on'),
+      onLast = on.source.last(),
+      onData = on.source.values(),
+      onKey = this.param('onKey'),
+      onF = onKey.field,
+      keys = this.param('keys'),
+      get = keys.accessor,
+      as = this.param('as'),
+      defaultValue = this.param('default'),
+      lut = this._lut,
+      i, v;
+
+  // build lookup table on init, withKey modified, or tuple add/rem
+  if (lut == null || this._on !== onF || onF && onLast.fields[onF] ||
+      onLast.add.length || onLast.rem.length)
+  {
+    if (onF) { // build hash from withKey field
+      onKey = onKey.accessor;
+      for (lut={}, i=0; i<onData.length; ++i) {
+        lut[onKey(v = onData[i])] = v;
+      }
+    } else { // otherwise, use index-based lookup
+      lut = onData;
+    }
+    this._lut = lut;
+    this._on = onF;
+    reset = true;
+  }
+
+  function set(t) {
+    for (var i=0; i<get.length; ++i) {
+      var v = lut[get[i](t)] || defaultValue;
+      Tuple.set(t, as[i], v);
+    }
+  }
+
+  input.add.forEach(set);
+  var run = keys.field.some(function(f) { return input.fields[f]; });
+  if (run || reset) {
+    input.mod.forEach(set);
+    input.rem.forEach(set); 
+  }
+
+  as.forEach(function(k) { input.fields[k] = 1; });
+  return input;
+};
+
+module.exports = Lookup;
+},{"./Transform":135,"vega-dataflow":39,"vega-logging":45}],131:[function(require,module,exports){
+var dl = require('datalib'),
+    Deps = require('vega-dataflow').Dependencies,
+    expr = require('../parse/expr');
+
+var arrayType = /array/i,
+    dataType  = /data/i,
+    fieldType = /field/i,
+    exprType  = /expr/i,
+    valType   = /value/i;
+
+function Parameter(name, type, transform) {
+  this._name = name;
+  this._type = type;
+  this._transform = transform;
+
+  // If parameter is defined w/signals, it must be resolved
+  // on every pulse.
+  this._value = [];
+  this._accessors = [];
+  this._resolution = false;
+  this._signals = {};
+}
+
+var prototype = Parameter.prototype;
+
+function get() {
+  var isArray = arrayType.test(this._type),
+      isData  = dataType.test(this._type),
+      isField = fieldType.test(this._type);
+
+  var val = isArray ? this._value : this._value[0],
+      acc = isArray ? this._accessors : this._accessors[0];
+
+  if (!dl.isValid(acc) && valType.test(this._type)) {
+    return val;
+  } else {
+    return isData ? { name: val, source: acc } :
+    isField ? { field: val, accessor: acc } : val;
+  }
+}
+
+prototype.get = function() {
+  var graph = this._transform._graph, 
+      isData  = dataType.test(this._type),
+      isField = fieldType.test(this._type),
+      s, idx, val;
+
+  // If we don't require resolution, return the value immediately.
+  if (!this._resolution) return get.call(this);
+
+  if (isData) {
+    this._accessors = this._value.map(function(v) { return graph.data(v); });
+    return get.call(this); // TODO: support signal as dataTypes
+  }
+
+  for (s in this._signals) {
+    idx = this._signals[s];
+    val = graph.signalRef(s);
+
+    if (isField) {
+      this._accessors[idx] = this._value[idx] != val ? 
+        dl.accessor(val) : this._accessors[idx];
+    }
+
+    this._value[idx] = val;
+  }
+
+  return get.call(this);
+};
+
+prototype.set = function(value) {
+  var p = this,
+      isExpr = exprType.test(this._type),
+      isData  = dataType.test(this._type),
+      isField = fieldType.test(this._type);
+
+  this._value = dl.array(value).map(function(v, i) {
+    if (dl.isString(v)) {
+      if (isExpr) {
+        var e = expr(v);
+        p._transform.dependency(Deps.FIELDS,  e.fields);
+        p._transform.dependency(Deps.SIGNALS, e.globals);
+        return e.fn;
+      } else if (isField) {  // Backwards compatibility
+        p._accessors[i] = dl.accessor(v);
+        p._transform.dependency(Deps.FIELDS, dl.field(v));
+      } else if (isData) {
+        p._resolution = true;
+        p._transform.dependency(Deps.DATA, v);
+      }
+      return v;
+    } else if (v.value !== undefined) {
+      return v.value;
+    } else if (v.field !== undefined) {
+      p._accessors[i] = dl.accessor(v.field);
+      p._transform.dependency(Deps.FIELDS, dl.field(v.field));
+      return v.field;
+    } else if (v.signal !== undefined) {
+      p._resolution = true;
+      p._signals[v.signal] = i;
+      p._transform.dependency(Deps.SIGNALS, v.signal);
+      return v.signal;
+    }
+
+    return v;
+  });
+
+  return p._transform;
+};
+
+module.exports = Parameter;
+},{"../parse/expr":94,"datalib":24,"vega-dataflow":39}],132:[function(require,module,exports){
+var dl = require('datalib'),
+    Tuple = require('vega-dataflow').Tuple,
+    log = require('vega-logging'),
+    Transform = require('./Transform'),
+    BatchTransform = require('./BatchTransform');
+
+function Pie(graph) {
+  BatchTransform.prototype.init.call(this, graph);
+  Transform.addParameters(this, {
+    field:      {type: 'field', default: null},
+    startAngle: {type: 'value', default: 0},
+    endAngle:   {type: 'value', default: 2 * Math.PI},
+    sort:       {type: 'value', default: false}
+  });
+
+  this._output = {
+    'start': 'layout_start',
+    'end':   'layout_end',
+    'mid':   'layout_mid'
+  };
+
+  return this.mutates(true);
+}
+
+var prototype = (Pie.prototype = Object.create(BatchTransform.prototype));
+prototype.constructor = Pie;
+
+function ones() { return 1; }
+
+prototype.batchTransform = function(input, data) {
+  log.debug(input, ['pie']);
+
+  var output = this._output,
+      field = this.param('field').accessor || ones,
+      start = this.param('startAngle'),
+      stop = this.param('endAngle'),
+      sort = this.param('sort');
+
+  var values = data.map(field),
+      a = start,
+      k = (stop - start) / dl.sum(values),
+      index = dl.range(data.length),
+      i, t, v;
+
+  if (sort) {
+    index.sort(function(a, b) {
+      return values[a] - values[b];
+    });
+  }
+
+  for (i=0; i<index.length; ++i) {
+    t = data[index[i]];
+    v = values[index[i]];
+    Tuple.set(t, output.start, a);
+    Tuple.set(t, output.mid, (a + 0.5 * v * k));
+    Tuple.set(t, output.end, (a += v * k));
+  }
+
+  input.fields[output.start] = 1;
+  input.fields[output.end] = 1;
+  input.fields[output.mid] = 1;
+  return input;
+};
+
+module.exports = Pie;
+},{"./BatchTransform":117,"./Transform":135,"datalib":24,"vega-dataflow":39,"vega-logging":45}],133:[function(require,module,exports){
+var dl = require('datalib'),
+    log  = require('vega-logging'),
+    Transform = require('./Transform');
+
+function Sort(graph) {
+  Transform.prototype.init.call(this, graph);
+  Transform.addParameters(this, {by: {type: 'array<field>'} });
+  this.router(true);
+}
+
+var prototype = (Sort.prototype = Object.create(Transform.prototype));
+prototype.constructor = Sort;
+
+prototype.transform = function(input) {
+  log.debug(input, ['sorting']);
+
+  if (input.add.length || input.mod.length || input.rem.length) {
+    input.sort = dl.comparator(this.param('by').field);
+  }
+  return input;
+};
+
+module.exports = Sort;
+},{"./Transform":135,"datalib":24,"vega-logging":45}],134:[function(require,module,exports){
+var dl = require('datalib'),
+    Tuple = require('vega-dataflow').Tuple,
+    log = require('vega-logging'),
+    Transform = require('./Transform'),
+    BatchTransform = require('./BatchTransform');
+
+function Stack(graph) {
+  BatchTransform.prototype.init.call(this, graph);
+  Transform.addParameters(this, {
+    groupby: {type: 'array<field>'},
+    sortby: {type: 'array<field>'},
+    field: {type: 'field'},
+    offset: {type: 'value', default: 'zero'}
+  });
+
+  this._output = {
+    'start': 'layout_start',
+    'end':   'layout_end',
+    'mid':   'layout_mid'
+  };
+  return this.mutates(true);
+}
+
+var prototype = (Stack.prototype = Object.create(BatchTransform.prototype));
+prototype.constructor = Stack;
+
+prototype.batchTransform = function(input, data) {
+  log.debug(input, ['stacking']);
+
+  var groupby = this.param('groupby').accessor,
+      sortby = dl.comparator(this.param('sortby').field),
+      field = this.param('field').accessor,
+      offset = this.param('offset'),
+      output = this._output;
+
+  // partition, sum, and sort the stack groups
+  var groups = partition(data, groupby, sortby, field);
+
+  // compute stack layouts per group
+  for (var i=0, max=groups.max; i<groups.length; ++i) {
+    var group = groups[i],
+        sum = group.sum,
+        off = offset==='center' ? (max - sum)/2 : 0,
+        scale = offset==='normalize' ? (1/sum) : 1,
+        j, x, a, b = off, v = 0;
+
+    // set stack coordinates for each datum in group
+    for (j=0; j<group.length; ++j) {
+      x = group[j];
+      a = b; // use previous value for start point
+      v += field(x);
+      b = scale * v + off; // compute end point
+      Tuple.set(x, output.start, a);
+      Tuple.set(x, output.end, b);
+      Tuple.set(x, output.mid, 0.5 * (a + b));
+    }
+  }
+
+  input.fields[output.start] = 1;
+  input.fields[output.end] = 1;
+  input.fields[output.mid] = 1;
+  return input;
+};
+
+function partition(data, groupby, sortby, field) {
+  var groups = [],
+      get = function(f) { return f(x); },
+      map, i, x, k, g, s, max;
+
+  // partition data points into stack groups
+  if (groupby == null) {
+    groups.push(data.slice());
+  } else {
+    for (map={}, i=0; i<data.length; ++i) {
+      x = data[i];
+      k = groupby.map(get);
+      g = map[k] || (groups.push(map[k] = []), map[k]);
+      g.push(x);
+    }
+  }
+
+  // compute sums of groups, sort groups as needed
+  for (k=0, max=0; k<groups.length; ++k) {
+    g = groups[k];
+    for (i=0, s=0; i<g.length; ++i) {
+      s += field(g[i]);
+    }
+    g.sum = s;
+    if (s > max) max = s;
+    if (sortby != null) g.sort(sortby);
+  }
+  groups.max = max;
+
+  return groups;
+}
+
+module.exports = Stack;
+},{"./BatchTransform":117,"./Transform":135,"datalib":24,"vega-dataflow":39,"vega-logging":45}],135:[function(require,module,exports){
+var df = require('vega-dataflow'),
+    Base = df.Node.prototype, // jshint ignore:line
+    Deps = df.Dependencies,
+    Parameter = require('./Parameter');
+
+function Transform(graph) {
+  if (graph) Base.init.call(this, graph);
+}
+
+Transform.addParameters = function(proto, params) {
+  proto._parameters = proto._parameters || {};
+  for (var name in params) {
+    var p = params[name],
+        param = new Parameter(name, p.type, proto);
+
+    proto._parameters[name] = param;
+
+    if (p.type === 'custom') {
+      if (p.set) param.set = p.set.bind(param);
+      if (p.get) param.get = p.get.bind(param);
+    }
+
+    if (p.hasOwnProperty('default')) param.set(p.default);
+  }
+};
+
+var prototype = (Transform.prototype = Object.create(Base));
+prototype.constructor = Transform;
+
+prototype.param = function(name, value) {
+  var param = this._parameters[name];
+  return (param === undefined) ? this :
+    (arguments.length === 1) ? param.get() : param.set(value);
+};
+
+// Perform transformation. Subclasses should override.
+prototype.transform = function(input/*, reset */) {
+  return input;
+};
+
+prototype.evaluate = function(input) {
+  // Many transforms store caches that must be invalidated if
+  // a signal value has changed. 
+  var reset = this._stamp < input.stamp &&
+    this.dependency(Deps.SIGNALS).reduce(function(c, s) {
+      return c += input.signals[s] ? 1 : 0;
+    }, 0);
+  return this.transform(input, reset);
+};
+
+prototype.output = function(map) {
+  for (var key in this._output) {
+    if (map[key] !== undefined) {
+      this._output[key] = map[key];
+    }
+  }
+  return this;
+};
+
+module.exports = Transform;
+},{"./Parameter":131,"vega-dataflow":39}],136:[function(require,module,exports){
+(function (global){
+var d3 = (typeof window !== "undefined" ? window['d3'] : typeof global !== "undefined" ? global['d3'] : null),
+    dl = require('datalib'),
+    Tuple = require('vega-dataflow').Tuple,
+    log = require('vega-logging'),
+    Transform = require('./Transform'),
+    BatchTransform = require('./BatchTransform');
+
+var defaultRatio = 0.5 * (1 + Math.sqrt(5));
+
+function Treemap(graph) {
+  BatchTransform.prototype.init.call(this, graph);
+  Transform.addParameters(this, {
+    // hierarchy parameters
+    sort: {type: 'array<field>', default: ['-value']},
+    children: {type: 'field', default: 'children'},
+    field: {type: 'field', default: 'value'},
+    // treemap parameters
+    size: {type: 'array<value>', default: [500, 500]},
+    round: {type: 'value', default: true},
+    sticky: {type: 'value', default: false},
+    ratio: {type: 'value', default: defaultRatio},
+    padding: {type: 'value', default: null},
+    mode: {type: 'value', default: 'squarify'}
+  });
+
+  this._layout = d3.layout.treemap();
+
+  this._output = {
+    'x':      'layout_x',
+    'y':      'layout_y',
+    'width':  'layout_width',
+    'height': 'layout_height',
+    'depth':  'layout_depth',
+  };
+  return this.mutates(true);
+}
+
+var prototype = (Treemap.prototype = Object.create(BatchTransform.prototype));
+prototype.constructor = Treemap;
+
+prototype.batchTransform = function(input, data) {
+  log.debug(input, ['treemap']);
+
+  // get variables
+  var layout = this._layout,
+      output = this._output;
+
+  // configure layout
+  layout
+    .sort(dl.comparator(this.param('sort').field))
+    .children(this.param('children').accessor)
+    .value(this.param('field').accessor)
+    .size(this.param('size'))
+    .round(this.param('round'))
+    .sticky(this.param('sticky'))
+    .ratio(this.param('ratio'))
+    .padding(this.param('padding'))
+    .mode(this.param('mode'))
+    .nodes(data[0]);
+
+  // copy layout values to nodes
+  data.forEach(function(n) {
+    Tuple.set(n, output.x, n.x);
+    Tuple.set(n, output.y, n.y);
+    Tuple.set(n, output.width, n.dx);
+    Tuple.set(n, output.height, n.dy);
+    Tuple.set(n, output.depth, n.depth);
+  });
+
+  // return changeset
+  input.fields[output.x] = 1;
+  input.fields[output.y] = 1;
+  input.fields[output.width] = 1;
+  input.fields[output.height] = 1;
+  return input;
+};
+
+module.exports = Treemap;
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{"./BatchTransform":117,"./Transform":135,"datalib":24,"vega-dataflow":39,"vega-logging":45}],137:[function(require,module,exports){
+(function (global){
+var d3 = (typeof window !== "undefined" ? window['d3'] : typeof global !== "undefined" ? global['d3'] : null),
+    Tuple = require('vega-dataflow/src/Tuple'),
+    log = require('vega-logging'),
+    Transform = require('./Transform'),
+    BatchTransform = require('./BatchTransform');
+
+function Voronoi(graph) {
+  BatchTransform.prototype.init.call(this, graph);
+  Transform.addParameters(this, {
+    clipExtent: {type: 'array<value>', default: [[-1e5,-1e5],[1e5,1e5]]},
+    x: {type: 'field', default: 'layout_x'},
+    y: {type: 'field', default: 'layout_y'}
+  });
+
+  this._layout = d3.geom.voronoi();
+  this._output = {'path': 'layout_path'};
+
+  return this.mutates(true);
+}
+
+var prototype = (Voronoi.prototype = Object.create(BatchTransform.prototype));
+prototype.constructor = Voronoi;
+
+prototype.batchTransform = function(input, data) {
+  log.debug(input, ['voronoi']);
+
+  // get variables
+  var pathname = this._output.path;
+
+  // configure layout
+  var polygons = this._layout
+    .clipExtent(this.param('clipExtent'))
+    .x(this.param('x').accessor)
+    .y(this.param('y').accessor)
+    (data);
+
+  // build and assign path strings
+  for (var i=0; i<data.length; ++i) {
+    Tuple.set(data[i], pathname, 'M' + polygons[i].join('L') + 'Z');
+  }
+
+  // return changeset
+  input.fields[pathname] = 1;
+  return input;
+};
+
+module.exports = Voronoi;
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{"./BatchTransform":117,"./Transform":135,"vega-dataflow/src/Tuple":38,"vega-logging":45}],138:[function(require,module,exports){
+(function (global){
+var dl = require('datalib'),
+    d3 = (typeof window !== "undefined" ? window['d3'] : typeof global !== "undefined" ? global['d3'] : null),
+    d3_cloud = (typeof window !== "undefined" ? window['d3']['layout']['cloud'] : typeof global !== "undefined" ? global['d3']['layout']['cloud'] : null),
+    Tuple = require('vega-dataflow/src/Tuple'),
+    log = require('vega-logging'),
+    Transform = require('./Transform'),
+    BatchTransform = require('./BatchTransform');
+
+function Wordcloud(graph) {
+  BatchTransform.prototype.init.call(this, graph);
+  Transform.addParameters(this, {
+    size: {type: 'array<value>', default: [900, 500]},
+    text: {type: 'field', default: 'data'},
+    rotate: {type: 'field|value', default: 0},
+    font: {type: 'field|value', default: {value: 'sans-serif'}},
+    fontSize: {type: 'field|value', default: 14},
+    fontStyle: {type: 'field|value', default: {value: 'normal'}},
+    fontWeight: {type: 'field|value', default: {value: 'normal'}},
+    fontScale: {type: 'array<value>', default: [10, 50]},
+    padding: {type: 'value', default: 1},
+    spiral: {type: 'value', default: 'archimedean'}
+  });
+
+  this._layout = d3_cloud();
+
+  this._output = {
+    'x':          'layout_x',
+    'y':          'layout_y',
+    'font':       'layout_font',
+    'fontSize':   'layout_fontSize',
+    'fontStyle':  'layout_fontStyle',
+    'fontWeight': 'layout_fontWeight',
+    'rotate':     'layout_rotate',
+  };
+
+  return this.mutates(true);
+}
+
+var prototype = (Wordcloud.prototype = Object.create(BatchTransform.prototype));
+prototype.constructor = Wordcloud;
+
+function get(p) {
+  return (p && p.accessor) || p;
+}
+
+function wrap(tuple) {
+  var x = Object.create(tuple);
+  x._tuple = tuple;
+  return x;
+}
+
+prototype.batchTransform = function(input, data) {
+  log.debug(input, ['wordcloud']);
+
+  // get variables
+  var layout = this._layout,
+      output = this._output,
+      fontSize = this.param('fontSize'),
+      range = fontSize.accessor && this.param('fontScale'),
+      size, scale;
+  fontSize = fontSize.accessor || d3.functor(fontSize);
+  
+  // create font size scaling function as needed
+  if (range.length) {
+    scale = d3.scale.sqrt()
+      .domain(dl.extent(data, size=fontSize))
+      .range(range);
+    fontSize = function(x) { return scale(size(x)); };
+  }
+
+  // configure layout
+  layout
+    .size(this.param('size'))
+    .text(get(this.param('text')))
+    .padding(this.param('padding'))
+    .spiral(this.param('spiral'))
+    .rotate(get(this.param('rotate')))
+    .font(get(this.param('font')))
+    .fontStyle(get(this.param('fontStyle')))
+    .fontWeight(get(this.param('fontWeight')))
+    .fontSize(fontSize)
+    .words(data.map(wrap)) // wrap to avoid tuple writes
+    .on('end', function(words) {
+      var size = layout.size(),
+          dx = size[0] >> 1,
+          dy = size[1] >> 1,
+          w, t, i, len;
+
+      for (i=0, len=words.length; i<len; ++i) {
+        w = words[i];
+        t = w._tuple;
+        Tuple.set(t, output.x, w.x + dx);
+        Tuple.set(t, output.y, w.y + dy);
+        Tuple.set(t, output.font, w.font);
+        Tuple.set(t, output.fontSize, w.size);
+        Tuple.set(t, output.fontStyle, w.style);
+        Tuple.set(t, output.fontWeight, w.weight);
+        Tuple.set(t, output.rotate, w.rotate);
+      }
+    })
+    .start();
+
+  // return changeset
+  for (var key in output) input.fields[output[key]] = 1;
+  return input;
+};
+
+module.exports = Wordcloud;
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{"./BatchTransform":117,"./Transform":135,"datalib":24,"vega-dataflow/src/Tuple":38,"vega-logging":45}],139:[function(require,module,exports){
+module.exports = {
+  aggregate:    require('./Aggregate'),
+  bin:          require('./Bin'),
+  cross:        require('./Cross'),
+  countpattern: require('./CountPattern'),
+  linkpath:     require('./LinkPath'),
+  facet:        require('./Facet'),
+  filter:       require('./Filter'),
+  fold:         require('./Fold'),
+  force:        require('./Force'),
+  formula:      require('./Formula'),
+  geo:          require('./Geo'),
+  geopath:      require('./GeoPath'),
+  lookup:       require('./Lookup'),
+  pie:          require('./Pie'),
+  sort:         require('./Sort'),
+  stack:        require('./Stack'),
+  treemap:      require('./Treemap'),
+  voronoi:      require('./Voronoi'),
+  wordcloud:    require('./Wordcloud')
+};
+},{"./Aggregate":116,"./Bin":118,"./CountPattern":119,"./Cross":120,"./Facet":121,"./Filter":123,"./Fold":124,"./Force":125,"./Formula":126,"./Geo":127,"./GeoPath":128,"./LinkPath":129,"./Lookup":130,"./Pie":132,"./Sort":133,"./Stack":134,"./Treemap":136,"./Voronoi":137,"./Wordcloud":138}]},{},[1])(1)
+});
+//# sourceMappingURL=vega.js.map