vega-transforms/build/vega-transforms.min.js.map

{"version":3,"file":"vega-transforms.min.js","sources":["../src/util/AggregateKeys.js","../src/util/AggregateOps.js","../src/util/TupleStore.js","../src/Aggregate.js","../src/Bin.js","../src/util/SortedList.js","../src/Collect.js","../src/Compare.js","../src/CountPattern.js","../src/Cross.js","../src/util/Distributions.js","../src/Density.js","../src/util/util.js","../src/DotBin.js","../src/Expression.js","../src/Extent.js","../src/Subflow.js","../src/Facet.js","../src/Field.js","../src/Filter.js","../src/Flatten.js","../src/Fold.js","../src/Formula.js","../src/Generate.js","../../../node_modules/d3-array/src/ascending.js","../../../node_modules/d3-array/src/descending.js","../../../node_modules/d3-array/src/bisector.js","../../../node_modules/d3-array/src/sort.js","../../../node_modules/d3-array/src/max.js","../../../node_modules/d3-array/src/min.js","../../../node_modules/d3-array/src/quickselect.js","../../../node_modules/d3-array/src/range.js","../src/Impute.js","../../../node_modules/d3-array/src/median.js","../../../node_modules/d3-array/src/quantile.js","../../../node_modules/d3-array/src/number.js","../../../node_modules/d3-array/src/mean.js","../src/JoinAggregate.js","../src/KDE.js","../src/Key.js","../src/Load.js","../src/Lookup.js","../src/MultiExtent.js","../src/MultiValues.js","../src/Params.js","../src/Pivot.js","../src/PreFacet.js","../src/Project.js","../src/Proxy.js","../src/Quantile.js","../src/Relay.js","../src/Sample.js","../src/Sequence.js","../src/Sieve.js","../src/TimeUnit.js","../src/TupleIndex.js","../src/Values.js","../src/util/WindowOps.js","../src/util/WindowState.js","../src/Window.js"],"sourcesContent":["export function multikey(f) {\n  return x => {\n    const n = f.length;\n    let i = 1,\n        k = String(f[0](x));\n\n    for (; i<n; ++i) {\n      k += '|' + f[i](x);\n    }\n\n    return k;\n  };\n}\n\nexport function groupkey(fields) {\n  return !fields || !fields.length ? function() { return ''; }\n    : fields.length === 1 ? fields[0]\n    : multikey(fields);\n}\n","import {extend, identity} from 'vega-util';\n\nexport function measureName(op, field, as) {\n  return as || (op + (!field ? '' : '_' + field));\n}\n\nconst noop = () => {};\n\nconst base_op = {\n  init: noop,\n  add:  noop,\n  rem:  noop,\n  idx:  0\n};\n\nexport const AggregateOps = {\n  values: {\n    init:  m => m.cell.store = true,\n    value: m => m.cell.data.values(),\n    idx:  -1\n  },\n  count: {\n    value: m => m.cell.num\n  },\n  __count__: {\n    value: m => m.missing + m.valid\n  },\n  missing: {\n    value: m => m.missing\n  },\n  valid: {\n    value: m => m.valid\n  },\n  sum: {\n    init:  m => m.sum = 0,\n    value: m => m.sum,\n    add:  (m, v) => m.sum += +v,\n    rem:  (m, v) => m.sum -= v\n  },\n  product: {\n    init:  m => m.product = 1,\n    value: m => m.valid ? m.product : undefined,\n    add:  (m, v) => m.product *= v,\n    rem:  (m, v) => m.product /= v\n  },\n  mean: {\n    init:  m => m.mean = 0,\n    value: m => m.valid ? m.mean : undefined,\n    add:  (m, v) => (m.mean_d = v - m.mean, m.mean += m.mean_d / m.valid),\n    rem:  (m, v) => (m.mean_d = v - m.mean, m.mean -= m.valid ? m.mean_d / m.valid : m.mean)\n  },\n  average: {\n    value: m => m.valid ? m.mean : undefined,\n    req:  ['mean'], idx: 1\n  },\n  variance: {\n    init:  m => m.dev = 0,\n    value: m => m.valid > 1 ? m.dev / (m.valid - 1) : undefined,\n    add:  (m, v) => m.dev += m.mean_d * (v - m.mean),\n    rem:  (m, v) => m.dev -= m.mean_d * (v - m.mean),\n    req:  ['mean'], idx: 1\n  },\n  variancep: {\n    value: m => m.valid > 1 ? m.dev / m.valid : undefined,\n    req:  ['variance'], idx: 2\n  },\n  stdev: {\n    value: m => m.valid > 1 ? Math.sqrt(m.dev / (m.valid - 1)) : undefined,\n    req:  ['variance'], idx: 2\n  },\n  stdevp: {\n    value: m => m.valid > 1 ? Math.sqrt(m.dev / m.valid) : undefined,\n    req:  ['variance'], idx: 2\n  },\n  stderr: {\n    value: m => m.valid > 1 ? Math.sqrt(m.dev / (m.valid * (m.valid - 1))) : undefined,\n    req:  ['variance'], idx: 2\n  },\n  distinct: {\n    value: m => m.cell.data.distinct(m.get),\n    req:  ['values'], idx: 3\n  },\n  ci0: {\n    value: m => m.cell.data.ci0(m.get),\n    req:  ['values'], idx: 3\n  },\n  ci1: {\n    value: m => m.cell.data.ci1(m.get),\n    req:  ['values'], idx: 3\n  },\n  median: {\n    value: m => m.cell.data.q2(m.get),\n    req:  ['values'], idx: 3\n  },\n  q1: {\n    value: m => m.cell.data.q1(m.get),\n    req: ['values'], idx: 3\n  },\n  q3: {\n    value: m => m.cell.data.q3(m.get),\n    req:  ['values'], idx: 3\n  },\n  min: {\n    init:  m => m.min = undefined,\n    value: m => m.min = (Number.isNaN(m.min) ? m.cell.data.min(m.get) : m.min),\n    add:  (m, v) => { if (v < m.min || m.min === undefined) m.min = v; },\n    rem:  (m, v) => { if (v <= m.min) m.min = NaN; },\n    req:  ['values'], idx: 4\n  },\n  max: {\n    init:  m => m.max = undefined,\n    value: m => m.max = (Number.isNaN(m.max) ? m.cell.data.max(m.get) : m.max),\n    add:  (m, v) => { if (v > m.max || m.max === undefined) m.max = v; },\n    rem:  (m, v) => { if (v >= m.max) m.max = NaN; },\n    req:  ['values'], idx: 4\n  },\n  argmin: {\n    init:  m => m.argmin = undefined,\n    value: m => m.argmin || m.cell.data.argmin(m.get),\n    add:  (m, v, t) => { if (v < m.min) m.argmin = t; },\n    rem:  (m, v) => { if (v <= m.min) m.argmin = undefined; },\n    req:  ['min', 'values'], idx: 3\n  },\n  argmax: {\n    init:  m => m.argmax = undefined,\n    value: m => m.argmax || m.cell.data.argmax(m.get),\n    add:  (m, v, t) => { if (v > m.max) m.argmax = t; },\n    rem:  (m, v) => { if (v >= m.max) m.argmax = undefined; },\n    req:  ['max', 'values'], idx: 3\n  }\n};\n\nexport const ValidAggregateOps = Object.keys(AggregateOps).filter(d => d !== '__count__');\n\nfunction measure(key, value) {\n  return out => extend({\n    name: key,\n    out: out || key\n  }, base_op, value);\n}\n\n[...ValidAggregateOps, '__count__'].forEach(key => {\n  AggregateOps[key] = measure(key, AggregateOps[key]);\n});\n\nexport function createMeasure(op, name) {\n  return AggregateOps[op](name);\n}\n\nfunction compareIndex(a, b) {\n  return a.idx - b.idx;\n}\n\nfunction resolve(agg) {\n  const map = {};\n  agg.forEach(a => map[a.name] = a);\n\n  const getreqs = a => {\n    if (!a.req) return;\n    a.req.forEach(key => {\n      if (!map[key]) getreqs(map[key] = AggregateOps[key]());\n    });\n  };\n  agg.forEach(getreqs);\n\n  return Object.values(map).sort(compareIndex);\n}\n\nfunction init() {\n  this.valid = 0;\n  this.missing = 0;\n  this._ops.forEach(op => op.init(this));\n}\n\nfunction add(v, t) {\n  if (v == null || v === '') { ++this.missing; return; }\n  if (v !== v) return;\n  ++this.valid;\n  this._ops.forEach(op => op.add(this, v, t));\n}\n\nfunction rem(v, t) {\n  if (v == null || v === '') { --this.missing; return; }\n  if (v !== v) return;\n  --this.valid;\n  this._ops.forEach(op => op.rem(this, v, t));\n}\n\nfunction set(t) {\n  this._out.forEach(op => t[op.out] = op.value(this));\n  return t;\n}\n\nexport function compileMeasures(agg, field) {\n  const get = field || identity,\n        ops = resolve(agg),\n        out = agg.slice().sort(compareIndex);\n\n  function ctr(cell) {\n    this._ops = ops;\n    this._out = out;\n    this.cell = cell;\n    this.init();\n  }\n\n  ctr.prototype.init = init;\n  ctr.prototype.add = add;\n  ctr.prototype.rem = rem;\n  ctr.prototype.set = set;\n  ctr.prototype.get = get;\n  ctr.fields = agg.map(op => op.out);\n\n  return ctr;\n}\n","import {tupleid} from 'vega-dataflow';\nimport {bootstrapCI, quartiles} from 'vega-statistics';\nimport {extentIndex, field, hasOwnProperty} from 'vega-util';\n\nexport default function TupleStore(key) {\n  this._key = key ? field(key) : tupleid;\n  this.reset();\n}\n\nconst prototype = TupleStore.prototype;\n\nprototype.reset = function() {\n  this._add = [];\n  this._rem = [];\n  this._ext = null;\n  this._get = null;\n  this._q = null;\n};\n\nprototype.add = function(v) {\n  this._add.push(v);\n};\n\nprototype.rem = function(v) {\n  this._rem.push(v);\n};\n\nprototype.values = function() {\n  this._get = null;\n  if (this._rem.length === 0) return this._add;\n\n  const a = this._add,\n        r = this._rem,\n        k = this._key,\n        n = a.length,\n        m = r.length,\n        x = Array(n - m),\n        map = {};\n  let i, j, v;\n\n  // use unique key field to clear removed values\n  for (i=0; i<m; ++i) {\n    map[k(r[i])] = 1;\n  }\n  for (i=0, j=0; i<n; ++i) {\n    if (map[k(v = a[i])]) {\n      map[k(v)] = 0;\n    } else {\n      x[j++] = v;\n    }\n  }\n\n  this._rem = [];\n  return (this._add = x);\n};\n\n// memoizing statistics methods\n\nprototype.distinct = function(get) {\n  const v = this.values(),\n        map = {};\n\n  let n = v.length,\n      count = 0, s;\n\n  while (--n >= 0) {\n    s = get(v[n]) + '';\n    if (!hasOwnProperty(map, s)) {\n      map[s] = 1;\n      ++count;\n    }\n  }\n\n  return count;\n};\n\nprototype.extent = function(get) {\n  if (this._get !== get || !this._ext) {\n    const v = this.values(),\n          i = extentIndex(v, get);\n    this._ext = [v[i[0]], v[i[1]]];\n    this._get = get;\n  }\n  return this._ext;\n};\n\nprototype.argmin = function(get) {\n  return this.extent(get)[0] || {};\n};\n\nprototype.argmax = function(get) {\n  return this.extent(get)[1] || {};\n};\n\nprototype.min = function(get) {\n  const m = this.extent(get)[0];\n  return m != null ? get(m) : undefined;\n};\n\nprototype.max = function(get) {\n  const m = this.extent(get)[1];\n  return m != null ? get(m) : undefined;\n};\n\nprototype.quartile = function(get) {\n  if (this._get !== get || !this._q) {\n    this._q = quartiles(this.values(), get);\n    this._get = get;\n  }\n  return this._q;\n};\n\nprototype.q1 = function(get) {\n  return this.quartile(get)[0];\n};\n\nprototype.q2 = function(get) {\n  return this.quartile(get)[1];\n};\n\nprototype.q3 = function(get) {\n  return this.quartile(get)[2];\n};\n\nprototype.ci = function(get) {\n  if (this._get !== get || !this._ci) {\n    this._ci = bootstrapCI(this.values(), 1000, 0.05, get);\n    this._get = get;\n  }\n  return this._ci;\n};\n\nprototype.ci0 = function(get) {\n  return this.ci(get)[0];\n};\n\nprototype.ci1 = function(get) {\n  return this.ci(get)[1];\n};\n","import {groupkey} from './util/AggregateKeys';\nimport {ValidAggregateOps, compileMeasures, createMeasure, measureName} from './util/AggregateOps';\nimport TupleStore from './util/TupleStore';\nimport {Transform, ingest, replace} from 'vega-dataflow';\nimport {accessorFields, accessorName, array, error, inherits} from 'vega-util';\n\n/**\n * Group-by aggregation operator.\n * @constructor\n * @param {object} params - The parameters for this operator.\n * @param {Array<function(object): *>} [params.groupby] - An array of accessors to groupby.\n * @param {Array<function(object): *>} [params.fields] - An array of accessors to aggregate.\n * @param {Array<string>} [params.ops] - An array of strings indicating aggregation operations.\n * @param {Array<string>} [params.as] - An array of output field names for aggregated values.\n * @param {boolean} [params.cross=false] - A flag indicating that the full\n *   cross-product of groupby values should be generated, including empty cells.\n *   If true, the drop parameter is ignored and empty cells are retained.\n * @param {boolean} [params.drop=true] - A flag indicating if empty cells should be removed.\n */\nexport default function Aggregate(params) {\n  Transform.call(this, null, params);\n\n  this._adds = []; // array of added output tuples\n  this._mods = []; // array of modified output tuples\n  this._alen = 0;  // number of active added tuples\n  this._mlen = 0;  // number of active modified tuples\n  this._drop = true;   // should empty aggregation cells be removed\n  this._cross = false; // produce full cross-product of group-by values\n\n  this._dims = [];   // group-by dimension accessors\n  this._dnames = []; // group-by dimension names\n\n  this._measures = []; // collection of aggregation monoids\n  this._countOnly = false; // flag indicating only count aggregation\n  this._counts = null; // collection of count fields\n  this._prev = null;   // previous aggregation cells\n\n  this._inputs = null;  // array of dependent input tuple field names\n  this._outputs = null; // array of output tuple field names\n}\n\nAggregate.Definition = {\n  'type': 'Aggregate',\n  'metadata': {'generates': true, 'changes': true},\n  'params': [\n    { 'name': 'groupby', 'type': 'field', 'array': true },\n    { 'name': 'ops', 'type': 'enum', 'array': true, 'values': ValidAggregateOps },\n    { 'name': 'fields', 'type': 'field', 'null': true, 'array': true },\n    { 'name': 'as', 'type': 'string', 'null': true, 'array': true },\n    { 'name': 'drop', 'type': 'boolean', 'default': true },\n    { 'name': 'cross', 'type': 'boolean', 'default': false },\n    { 'name': 'key', 'type': 'field' }\n  ]\n};\n\ninherits(Aggregate, Transform, {\n  transform(_, pulse) {\n    const aggr = this,\n          out = pulse.fork(pulse.NO_SOURCE | pulse.NO_FIELDS),\n          mod = _.modified();\n\n    aggr.stamp = out.stamp;\n\n    if (aggr.value && (mod || pulse.modified(aggr._inputs, true))) {\n      aggr._prev = aggr.value;\n      aggr.value = mod ? aggr.init(_) : {};\n      pulse.visit(pulse.SOURCE, t => aggr.add(t));\n    } else {\n      aggr.value = aggr.value || aggr.init(_);\n      pulse.visit(pulse.REM, t => aggr.rem(t));\n      pulse.visit(pulse.ADD, t => aggr.add(t));\n    }\n\n    // Indicate output fields and return aggregate tuples.\n    out.modifies(aggr._outputs);\n\n    // Should empty cells be dropped?\n    aggr._drop = _.drop !== false;\n\n    // If domain cross-product requested, generate empty cells as needed\n    // and ensure that empty cells are not dropped\n    if (_.cross && aggr._dims.length > 1) {\n      aggr._drop = false;\n      aggr.cross();\n    }\n\n    if (pulse.clean() && aggr._drop) {\n      out.clean(true).runAfter(() => this.clean());\n    }\n\n    return aggr.changes(out);\n  },\n\n  cross() {\n    const aggr = this,\n          curr = aggr.value,\n          dims = aggr._dnames,\n          vals = dims.map(() => ({})),\n          n = dims.length;\n\n    // collect all group-by domain values\n    function collect(cells) {\n      let key, i, t, v;\n      for (key in cells) {\n        t = cells[key].tuple;\n        for (i=0; i<n; ++i) {\n          vals[i][(v = t[dims[i]])] = v;\n        }\n      }\n    }\n    collect(aggr._prev);\n    collect(curr);\n\n    // iterate over key cross-product, create cells as needed\n    function generate(base, tuple, index) {\n      const name = dims[index],\n          v = vals[index++];\n\n      for (const k in v) {\n        const key = base ? base + '|' + k : k;\n        tuple[name] = v[k];\n        if (index < n) generate(key, tuple, index);\n        else if (!curr[key]) aggr.cell(key, tuple);\n      }\n    }\n    generate('', {}, 0);\n  },\n\n  init(_) {\n    // initialize input and output fields\n    const inputs = (this._inputs = []),\n          outputs = (this._outputs = []),\n          inputMap = {};\n\n    function inputVisit(get) {\n      const fields = array(accessorFields(get)),\n            n = fields.length;\n      let i = 0, f;\n      for (; i<n; ++i) {\n        if (!inputMap[f=fields[i]]) {\n          inputMap[f] = 1;\n          inputs.push(f);\n        }\n      }\n    }\n\n    // initialize group-by dimensions\n    this._dims = array(_.groupby);\n    this._dnames = this._dims.map(d => {\n      const dname = accessorName(d);\n      inputVisit(d);\n      outputs.push(dname);\n      return dname;\n    });\n    this.cellkey = _.key ? _.key : groupkey(this._dims);\n\n    // initialize aggregate measures\n    this._countOnly = true;\n    this._counts = [];\n    this._measures = [];\n\n    const fields = _.fields || [null],\n          ops = _.ops || ['count'],\n          as = _.as || [],\n          n = fields.length,\n          map = {};\n    let field, op, m, mname, outname, i;\n\n    if (n !== ops.length) {\n      error('Unmatched number of fields and aggregate ops.');\n    }\n\n    for (i=0; i<n; ++i) {\n      field = fields[i];\n      op = ops[i];\n\n      if (field == null && op !== 'count') {\n        error('Null aggregate field specified.');\n      }\n      mname = accessorName(field);\n      outname = measureName(op, mname, as[i]);\n      outputs.push(outname);\n\n      if (op === 'count') {\n        this._counts.push(outname);\n        continue;\n      }\n\n      m = map[mname];\n      if (!m) {\n        inputVisit(field);\n        m = (map[mname] = []);\n        m.field = field;\n        this._measures.push(m);\n      }\n\n      if (op !== 'count') this._countOnly = false;\n      m.push(createMeasure(op, outname));\n    }\n\n    this._measures = this._measures.map(m => compileMeasures(m, m.field));\n\n    return {}; // aggregation cells (this.value)\n  },\n\n  // -- Cell Management -----\n\n  cellkey: groupkey(),\n\n  cell(key, t) {\n    let cell = this.value[key];\n    if (!cell) {\n      cell = this.value[key] = this.newcell(key, t);\n      this._adds[this._alen++] = cell;\n    } else if (cell.num === 0 && this._drop && cell.stamp < this.stamp) {\n      cell.stamp = this.stamp;\n      this._adds[this._alen++] = cell;\n    } else if (cell.stamp < this.stamp) {\n      cell.stamp = this.stamp;\n      this._mods[this._mlen++] = cell;\n    }\n    return cell;\n  },\n\n  newcell(key, t) {\n    const cell = {\n      key:   key,\n      num:   0,\n      agg:   null,\n      tuple: this.newtuple(t, this._prev && this._prev[key]),\n      stamp: this.stamp,\n      store: false\n    };\n\n    if (!this._countOnly) {\n      const measures = this._measures,\n            n = measures.length;\n\n      cell.agg = Array(n);\n      for (let i=0; i<n; ++i) {\n        cell.agg[i] = new measures[i](cell);\n      }\n    }\n\n    if (cell.store) {\n      cell.data = new TupleStore();\n    }\n\n    return cell;\n  },\n\n  newtuple(t, p) {\n    const names = this._dnames,\n          dims = this._dims,\n          n = dims.length,\n          x = {};\n\n    for (let i=0; i<n; ++i) {\n      x[names[i]] = dims[i](t);\n    }\n\n    return p ? replace(p.tuple, x) : ingest(x);\n  },\n\n  clean() {\n    const cells = this.value;\n    for (const key in cells) {\n      if (cells[key].num === 0) {\n        delete cells[key];\n      }\n    }\n  },\n\n  // -- Process Tuples -----\n\n  add(t) {\n    const key = this.cellkey(t),\n          cell = this.cell(key, t);\n\n    cell.num += 1;\n    if (this._countOnly) return;\n\n    if (cell.store) cell.data.add(t);\n\n    const agg = cell.agg;\n    for (let i=0, n=agg.length; i<n; ++i) {\n      agg[i].add(agg[i].get(t), t);\n    }\n  },\n\n  rem(t) {\n    const key = this.cellkey(t),\n          cell = this.cell(key, t);\n\n    cell.num -= 1;\n    if (this._countOnly) return;\n\n    if (cell.store) cell.data.rem(t);\n\n    const agg = cell.agg;\n    for (let i=0, n=agg.length; i<n; ++i) {\n      agg[i].rem(agg[i].get(t), t);\n    }\n  },\n\n  celltuple(cell) {\n    const tuple = cell.tuple,\n          counts = this._counts;\n\n    // consolidate stored values\n    if (cell.store) {\n      cell.data.values();\n    }\n\n    // update tuple properties\n    for (let i=0, n=counts.length; i<n; ++i) {\n      tuple[counts[i]] = cell.num;\n    }\n    if (!this._countOnly) {\n      const agg = cell.agg;\n      for (let i=0, n=agg.length; i<n; ++i) {\n        agg[i].set(tuple);\n      }\n    }\n\n    return tuple;\n  },\n\n  changes(out) {\n    const adds = this._adds,\n          mods = this._mods,\n          prev = this._prev,\n          drop = this._drop,\n          add = out.add,\n          rem = out.rem,\n          mod = out.mod;\n\n    let cell, key, i, n;\n\n    if (prev) for (key in prev) {\n      cell = prev[key];\n      if (!drop || cell.num) rem.push(cell.tuple);\n    }\n\n    for (i=0, n=this._alen; i<n; ++i) {\n      add.push(this.celltuple(adds[i]));\n      adds[i] = null; // for garbage collection\n    }\n\n    for (i=0, n=this._mlen; i<n; ++i) {\n      cell = mods[i];\n      (cell.num === 0 && drop ? rem : mod).push(this.celltuple(cell));\n      mods[i] = null; // for garbage collection\n    }\n\n    this._alen = this._mlen = 0; // reset list of active cells\n    this._prev = null;\n    return out;\n  }\n});\n","import {Transform} from 'vega-dataflow';\nimport {bin} from 'vega-statistics';\nimport {accessor, accessorFields, accessorName, inherits, toNumber} from 'vega-util';\n\n// epsilon bias to offset floating point error (#1737)\nconst EPSILON = 1e-14;\n\n/**\n * Generates a binning function for discretizing data.\n * @constructor\n * @param {object} params - The parameters for this operator. The\n *   provided values should be valid options for the {@link bin} function.\n * @param {function(object): *} params.field - The data field to bin.\n */\nexport default function Bin(params) {\n  Transform.call(this, null, params);\n}\n\nBin.Definition = {\n  'type': 'Bin',\n  'metadata': {'modifies': true},\n  'params': [\n    { 'name': 'field', 'type': 'field', 'required': true },\n    { 'name': 'interval', 'type': 'boolean', 'default': true },\n    { 'name': 'anchor', 'type': 'number' },\n    { 'name': 'maxbins', 'type': 'number', 'default': 20 },\n    { 'name': 'base', 'type': 'number', 'default': 10 },\n    { 'name': 'divide', 'type': 'number', 'array': true, 'default': [5, 2] },\n    { 'name': 'extent', 'type': 'number', 'array': true, 'length': 2, 'required': true },\n    { 'name': 'span', 'type': 'number' },\n    { 'name': 'step', 'type': 'number' },\n    { 'name': 'steps', 'type': 'number', 'array': true },\n    { 'name': 'minstep', 'type': 'number', 'default': 0 },\n    { 'name': 'nice', 'type': 'boolean', 'default': true },\n    { 'name': 'name', 'type': 'string' },\n    { 'name': 'as', 'type': 'string', 'array': true, 'length': 2, 'default': ['bin0', 'bin1'] }\n  ]\n};\n\ninherits(Bin, Transform, {\n  transform(_, pulse) {\n    const band = _.interval !== false,\n        bins = this._bins(_),\n        start = bins.start,\n        step = bins.step,\n        as = _.as || ['bin0', 'bin1'],\n        b0 = as[0],\n        b1 = as[1];\n\n    let flag;\n    if (_.modified()) {\n      pulse = pulse.reflow(true);\n      flag = pulse.SOURCE;\n    } else {\n      flag = pulse.modified(accessorFields(_.field)) ? pulse.ADD_MOD : pulse.ADD;\n    }\n\n    pulse.visit(flag, band\n      ? t => {\n          const v = bins(t);\n          // minimum bin value (inclusive)\n          t[b0] = v;\n          // maximum bin value (exclusive)\n          // use convoluted math for better floating point agreement\n          // see https://github.com/vega/vega/issues/830\n          // infinite values propagate through this formula! #2227\n          t[b1] = v == null ? null : start + step * (1 + (v - start) / step);\n        }\n      : t => t[b0] = bins(t)\n    );\n\n    return pulse.modifies(band ? as : b0);\n  },\n\n  _bins(_) {\n    if (this.value && !_.modified()) {\n      return this.value;\n    }\n\n    const field = _.field,\n          bins  = bin(_),\n          step  = bins.step;\n    let start = bins.start,\n        stop  = start + Math.ceil((bins.stop - start) / step) * step,\n        a, d;\n\n    if ((a = _.anchor) != null) {\n      d = a - (start + step * Math.floor((a - start) / step));\n      start += d;\n      stop += d;\n    }\n\n    const f = function(t) {\n      let v = toNumber(field(t));\n      return v == null ? null\n        : v < start ? -Infinity\n        : v > stop ? +Infinity\n        : (\n            v = Math.max(start, Math.min(v, stop - step)),\n            start + step * Math.floor(EPSILON + (v - start) / step)\n          );\n    };\n\n    f.start = start;\n    f.stop = bins.stop;\n    f.step = step;\n\n    return this.value = accessor(\n      f,\n      accessorFields(field),\n      _.name || 'bin_' + accessorName(field)\n    );\n  }\n});\n","import {merge} from 'vega-util';\n\nexport default function(idFunc, source, input) {\n  const $ = idFunc;\n  let data = source || [],\n      add = input || [],\n      rem = {},\n      cnt = 0;\n\n  return {\n    add: t => add.push(t),\n    remove: t => rem[$(t)] = ++cnt,\n    size: () => data.length,\n    data: (compare, resort) => {\n      if (cnt) {\n        data = data.filter(t => !rem[$(t)]);\n        rem = {};\n        cnt = 0;\n      }\n      if (resort && compare) {\n        data.sort(compare);\n      }\n      if (add.length) {\n        data = compare\n          ? merge(compare, data, add.sort(compare))\n          : data.concat(add);\n        add = [];\n      }\n      return data;\n    }\n  };\n}","import SortedList from './util/SortedList';\nimport {Transform, stableCompare, tupleid} from 'vega-dataflow';\nimport {inherits} from 'vega-util';\n\n/**\n * Collects all data tuples that pass through this operator.\n * @constructor\n * @param {object} params - The parameters for this operator.\n * @param {function(*,*): number} [params.sort] - An optional\n *   comparator function for additionally sorting the collected tuples.\n */\nexport default function Collect(params) {\n  Transform.call(this, [], params);\n}\n\nCollect.Definition = {\n  'type': 'Collect',\n  'metadata': {'source': true},\n  'params': [\n    { 'name': 'sort', 'type': 'compare' }\n  ]\n};\n\ninherits(Collect, Transform, {\n  transform(_, pulse) {\n    const out = pulse.fork(pulse.ALL),\n          list = SortedList(tupleid, this.value, out.materialize(out.ADD).add),\n          sort = _.sort,\n          mod = pulse.changed() || (sort &&\n                (_.modified('sort') || pulse.modified(sort.fields)));\n\n    out.visit(out.REM, list.remove);\n\n    this.modified(mod);\n    this.value = out.source = list.data(stableCompare(sort), mod);\n\n    // propagate tree root if defined\n    if (pulse.source && pulse.source.root) {\n      this.value.root = pulse.source.root;\n    }\n\n    return out;\n  }\n});\n","import {Operator} from 'vega-dataflow';\nimport {compare, inherits} from 'vega-util';\n\n/**\n * Generates a comparator function.\n * @constructor\n * @param {object} params - The parameters for this operator.\n * @param {Array<string|function>} params.fields - The fields to compare.\n * @param {Array<string>} [params.orders] - The sort orders.\n *   Each entry should be one of \"ascending\" (default) or \"descending\".\n */\nexport default function Compare(params) {\n  Operator.call(this, null, update, params);\n}\n\ninherits(Compare, Operator);\n\nfunction update(_) {\n  return (this.value && !_.modified())\n    ? this.value\n    : compare(_.fields, _.orders);\n}\n","import {Transform, ingest} from 'vega-dataflow';\nimport {inherits} from 'vega-util';\n\n/**\n * Count regexp-defined pattern occurrences in a text field.\n * @constructor\n * @param {object} params - The parameters for this operator.\n * @param {function(object): *} params.field - An accessor for the text field.\n * @param {string} [params.pattern] - RegExp string defining the text pattern.\n * @param {string} [params.case] - One of 'lower', 'upper' or null (mixed) case.\n * @param {string} [params.stopwords] - RegExp string of words to ignore.\n */\nexport default function CountPattern(params) {\n  Transform.call(this, null, params);\n}\n\nCountPattern.Definition = {\n  'type': 'CountPattern',\n  'metadata': {'generates': true, 'changes': true},\n  'params': [\n    { 'name': 'field', 'type': 'field', 'required': true },\n    { 'name': 'case', 'type': 'enum', 'values': ['upper', 'lower', 'mixed'], 'default': 'mixed' },\n    { 'name': 'pattern', 'type': 'string', 'default': '[\\\\w\"]+' },\n    { 'name': 'stopwords', 'type': 'string', 'default': '' },\n    { 'name': 'as', 'type': 'string', 'array': true, 'length': 2, 'default': ['text', 'count'] }\n  ]\n};\n\nfunction tokenize(text, tcase, match) {\n  switch (tcase) {\n    case 'upper': text = text.toUpperCase(); break;\n    case 'lower': text = text.toLowerCase(); break;\n  }\n  return text.match(match);\n}\n\ninherits(CountPattern, Transform, {\n  transform(_, pulse) {\n    const process = update => tuple => {\n      var tokens = tokenize(get(tuple), _.case, match) || [], t;\n      for (var i=0, n=tokens.length; i<n; ++i) {\n        if (!stop.test(t = tokens[i])) update(t);\n      }\n    };\n\n    const init = this._parameterCheck(_, pulse),\n          counts = this._counts,\n          match = this._match,\n          stop = this._stop,\n          get = _.field,\n          as = _.as || ['text', 'count'],\n          add = process(t => counts[t] = 1 + (counts[t] || 0)),\n          rem = process(t => counts[t] -= 1);\n\n    if (init) {\n      pulse.visit(pulse.SOURCE, add);\n    } else {\n      pulse.visit(pulse.ADD, add);\n      pulse.visit(pulse.REM, rem);\n    }\n\n    return this._finish(pulse, as); // generate output tuples\n  },\n\n  _parameterCheck(_, pulse) {\n    let init = false;\n\n    if (_.modified('stopwords') || !this._stop) {\n      this._stop = new RegExp('^' + (_.stopwords || '') + '$', 'i');\n      init = true;\n    }\n\n    if (_.modified('pattern') || !this._match) {\n      this._match = new RegExp((_.pattern || '[\\\\w\\']+'), 'g');\n      init = true;\n    }\n\n    if (_.modified('field') || pulse.modified(_.field.fields)) {\n      init = true;\n    }\n\n    if (init) this._counts = {};\n    return init;\n  },\n\n  _finish(pulse, as) {\n    const counts = this._counts,\n          tuples = this._tuples || (this._tuples = {}),\n          text = as[0],\n          count = as[1],\n          out = pulse.fork(pulse.NO_SOURCE | pulse.NO_FIELDS);\n    let w, t, c;\n\n    for (w in counts) {\n      t = tuples[w];\n      c = counts[w] || 0;\n      if (!t && c) {\n        tuples[w] = (t = ingest({}));\n        t[text] = w;\n        t[count] = c;\n        out.add.push(t);\n      } else if (c === 0) {\n        if (t) out.rem.push(t);\n        counts[w] = null;\n        tuples[w] = null;\n      } else if (t[count] !== c) {\n        t[count] = c;\n        out.mod.push(t);\n      }\n    }\n\n    return out.modifies(as);\n  }\n});\n","import {Transform, ingest} from 'vega-dataflow';\nimport {inherits, truthy} from 'vega-util';\n\n/**\n * Perform a cross-product of a tuple stream with itself.\n * @constructor\n * @param {object} params - The parameters for this operator.\n * @param {function(object):boolean} [params.filter] - An optional filter\n *   function for selectively including tuples in the cross product.\n * @param {Array<string>} [params.as] - The names of the output fields.\n */\nexport default function Cross(params) {\n  Transform.call(this, null, params);\n}\n\nCross.Definition = {\n  'type': 'Cross',\n  'metadata': {'generates': true},\n  'params': [\n    { 'name': 'filter', 'type': 'expr' },\n    { 'name': 'as', 'type': 'string', 'array': true, 'length': 2, 'default': ['a', 'b'] }\n  ]\n};\n\ninherits(Cross, Transform, {\n  transform(_, pulse) {\n    const out = pulse.fork(pulse.NO_SOURCE),\n          as = _.as || ['a', 'b'],\n          a = as[0], b = as[1],\n          reset = !this.value\n              || pulse.changed(pulse.ADD_REM)\n              || _.modified('as')\n              || _.modified('filter');\n\n    let data = this.value;\n    if (reset) {\n      if (data) out.rem = data;\n      data = pulse.materialize(pulse.SOURCE).source;\n      out.add = this.value = cross(data, a, b, _.filter || truthy);\n    } else {\n      out.mod = data;\n    }\n\n    out.source = this.value;\n    return out.modifies(as);\n  }\n});\n\nfunction cross(input, a, b, filter) {\n  var data = [],\n      t = {},\n      n = input.length,\n      i = 0,\n      j, left;\n\n  for (; i<n; ++i) {\n    t[a] = left = input[i];\n    for (j=0; j<n; ++j) {\n      t[b] = input[j];\n      if (filter(t)) {\n        data.push(ingest(t));\n        t = {};\n        t[a] = left;\n      }\n    }\n  }\n\n  return data;\n}\n","import {\n  randomKDE,\n  randomLogNormal,\n  randomMixture,\n  randomNormal,\n  randomUniform\n} from 'vega-statistics';\n\nimport {error, hasOwnProperty} from 'vega-util';\n\nconst Distributions = {\n  kde:       randomKDE,\n  mixture:   randomMixture,\n  normal:    randomNormal,\n  lognormal: randomLogNormal,\n  uniform:   randomUniform\n};\n\nconst DISTRIBUTIONS = 'distributions',\n      FUNCTION = 'function',\n      FIELD = 'field';\n\n/**\n * Parse a parameter object for a probability distribution.\n * @param {object} def - The distribution parameter object.\n * @param {function():Array<object>} - A method for requesting\n *   source data. Used for distributions (such as KDE) that\n *   require sample data points. This method will only be\n *   invoked if the 'from' parameter for a target data source\n *   is not provided. Typically this method returns backing\n *   source data for a Pulse object.\n * @return {object} - The output distribution object.\n */\nexport default function parse(def, data) {\n  const func = def[FUNCTION];\n  if (!hasOwnProperty(Distributions, func)) {\n    error('Unknown distribution function: ' + func);\n  }\n\n  const d = Distributions[func]();\n\n  for (const name in def) {\n    // if data field, extract values\n    if (name === FIELD) {\n      d.data((def.from || data()).map(def[name]));\n    }\n\n    // if distribution mixture, recurse to parse each definition\n    else if (name === DISTRIBUTIONS) {\n      d[name](def[name].map(_ => parse(_, data)));\n    }\n\n    // otherwise, simply set the parameter\n    else if (typeof d[name] === FUNCTION) {\n      d[name](def[name]);\n    }\n  }\n\n  return d;\n}\n","import parseDist from './util/Distributions';\nimport {Transform, ingest} from 'vega-dataflow';\nimport {sampleCurve} from 'vega-statistics';\nimport {error, extent, inherits} from 'vega-util';\n\n/**\n * Grid sample points for a probability density. Given a distribution and\n * a sampling extent, will generate points suitable for plotting either\n * PDF (probability density function) or CDF (cumulative distribution\n * function) curves.\n * @constructor\n * @param {object} params - The parameters for this operator.\n * @param {object} params.distribution - The probability distribution. This\n *   is an object parameter dependent on the distribution type.\n * @param {string} [params.method='pdf'] - The distribution method to sample.\n *   One of 'pdf' or 'cdf'.\n * @param {Array<number>} [params.extent] - The [min, max] extent over which\n *   to sample the distribution. This argument is required in most cases, but\n *   can be omitted if the distribution (e.g., 'kde') supports a 'data' method\n *   that returns numerical sample points from which the extent can be deduced.\n * @param {number} [params.minsteps=25] - The minimum number of curve samples\n *   for plotting the density.\n * @param {number} [params.maxsteps=200] - The maximum number of curve samples\n *   for plotting the density.\n * @param {number} [params.steps] - The exact number of curve samples for\n *   plotting the density. If specified, overrides both minsteps and maxsteps\n *   to set an exact number of uniform samples. Useful in conjunction with\n *   a fixed extent to ensure consistent sample points for stacked densities.\n */\nexport default function Density(params) {\n  Transform.call(this, null, params);\n}\n\nconst distributions = [\n  {\n    'key': {'function': 'normal'},\n    'params': [\n      { 'name': 'mean', 'type': 'number', 'default': 0 },\n      { 'name': 'stdev', 'type': 'number', 'default': 1 }\n    ]\n  },\n  {\n    'key': {'function': 'lognormal'},\n    'params': [\n      { 'name': 'mean', 'type': 'number', 'default': 0 },\n      { 'name': 'stdev', 'type': 'number', 'default': 1 }\n    ]\n  },\n  {\n    'key': {'function': 'uniform'},\n    'params': [\n      { 'name': 'min', 'type': 'number', 'default': 0 },\n      { 'name': 'max', 'type': 'number', 'default': 1 }\n    ]\n  },\n  {\n    'key': {'function': 'kde'},\n    'params': [\n      { 'name': 'field', 'type': 'field', 'required': true },\n      { 'name': 'from', 'type': 'data' },\n      { 'name': 'bandwidth', 'type': 'number', 'default': 0 }\n    ]\n  }\n];\n\nconst mixture = {\n  'key': {'function': 'mixture'},\n  'params': [\n    { 'name': 'distributions', 'type': 'param', 'array': true,\n      'params': distributions },\n    { 'name': 'weights', 'type': 'number', 'array': true }\n  ]\n};\n\nDensity.Definition = {\n  'type': 'Density',\n  'metadata': {'generates': true},\n  'params': [\n    { 'name': 'extent', 'type': 'number', 'array': true, 'length': 2 },\n    { 'name': 'steps', 'type': 'number' },\n    { 'name': 'minsteps', 'type': 'number', 'default': 25 },\n    { 'name': 'maxsteps', 'type': 'number', 'default': 200 },\n    { 'name': 'method', 'type': 'string', 'default': 'pdf',\n      'values': ['pdf', 'cdf'] },\n    { 'name': 'distribution', 'type': 'param',\n      'params': distributions.concat(mixture) },\n    { 'name': 'as', 'type': 'string', 'array': true,\n      'default': ['value', 'density'] }\n  ]\n};\n\ninherits(Density, Transform, {\n  transform(_, pulse) {\n    const out = pulse.fork(pulse.NO_SOURCE | pulse.NO_FIELDS);\n\n    if (!this.value || pulse.changed() || _.modified()) {\n      const dist = parseDist(_.distribution, source(pulse)),\n            minsteps = _.steps || _.minsteps || 25,\n            maxsteps = _.steps || _.maxsteps || 200;\n      let method = _.method || 'pdf';\n\n      if (method !== 'pdf' && method !== 'cdf') {\n        error('Invalid density method: ' + method);\n      }\n      if (!_.extent && !dist.data) {\n        error('Missing density extent parameter.');\n      }\n      method = dist[method];\n\n      const as = _.as || ['value', 'density'],\n            domain = _.extent || extent(dist.data()),\n            values = sampleCurve(method, domain, minsteps, maxsteps)\n              .map(v => {\n                const tuple = {};\n                tuple[as[0]] = v[0];\n                tuple[as[1]] = v[1];\n                return ingest(tuple);\n              });\n\n      if (this.value) out.rem = this.value;\n      this.value = out.add = out.source = values;\n    }\n\n    return out;\n  }\n});\n\nfunction source(pulse) {\n  return () => pulse.materialize(pulse.SOURCE).source;\n}\n","import {accessorName} from 'vega-util';\n\n// use either provided alias or accessor field name\nexport function fieldNames(fields, as) {\n  if (!fields) return null;\n  return fields.map((f, i) => as[i] || accessorName(f));\n}\n\nexport function partition(data, groupby, field) {\n  const groups = [],\n        get = f => f(t);\n  let map, i, n, t, k, g;\n\n  // partition data points into groups\n  if (groupby == null) {\n    groups.push(data.map(field));\n  } else {\n    for (map={}, i=0, n=data.length; i<n; ++i) {\n      t = data[i];\n      k = groupby.map(get);\n      g = map[k];\n      if (!g) {\n        map[k] = (g = []);\n        g.dims = k;\n        groups.push(g);\n      }\n      g.push(field(t));\n    }\n  }\n\n  return groups;\n}\n","import {partition} from './util/util';\nimport {Transform, stableCompare} from 'vega-dataflow';\nimport {dotbin} from 'vega-statistics';\nimport {extent, identity, inherits, span} from 'vega-util';\n\nconst Output = 'bin';\n\n/**\n * Dot density binning for dot plot construction.\n * Based on Leland Wilkinson, Dot Plots, The American Statistician, 1999.\n * https://www.cs.uic.edu/~wilkinson/Publications/dotplots.pdf\n * @constructor\n * @param {object} params - The parameters for this operator.\n * @param {function(object): *} params.field - The value field to bin.\n * @param {Array<function(object): *>} [params.groupby] - An array of accessors to groupby.\n * @param {number} [params.step] - The step size (bin width) within which dots should be\n *   stacked. Defaults to 1/30 of the extent of the data *field*.\n * @param {boolean} [params.smooth=false] - A boolean flag indicating if dot density\n *   stacks should be smoothed to reduce variance.\n */\nexport default function DotBin(params) {\n  Transform.call(this, null, params);\n}\n\nDotBin.Definition = {\n  'type': 'DotBin',\n  'metadata': {'modifies': true},\n  'params': [\n    { 'name': 'field', 'type': 'field', 'required': true },\n    { 'name': 'groupby', 'type': 'field', 'array': true },\n    { 'name': 'step', 'type': 'number' },\n    { 'name': 'smooth', 'type': 'boolean', 'default': false },\n    { 'name': 'as', 'type': 'string', 'default': Output }\n  ]\n};\n\nconst autostep = (data, field) => span(extent(data, field)) / 30;\n\ninherits(DotBin, Transform, {\n  transform(_, pulse) {\n    if (this.value && !(_.modified() || pulse.changed())) {\n      return pulse; // early exit\n    }\n\n    const source = pulse.materialize(pulse.SOURCE).source,\n          groups = partition(pulse.source, _.groupby, identity),\n          smooth = _.smooth || false,\n          field = _.field,\n          step = _.step || autostep(source, field),\n          sort = stableCompare((a, b) => field(a) - field(b)),\n          as = _.as || Output,\n          n = groups.length;\n\n    // compute dotplot bins per group\n    let min = Infinity, max = -Infinity, i = 0, j;\n    for (; i<n; ++i) {\n      const g = groups[i].sort(sort);\n      j = -1;\n      for (const v of dotbin(g, step, smooth, field)) {\n        if (v < min) min = v;\n        if (v > max) max = v;\n        g[++j][as] = v;\n      }\n    }\n\n    this.value = {\n      start: min,\n      stop: max,\n      step: step\n    };\n    return pulse.reflow(true).modifies(as);\n  }\n});\n","import {Operator} from 'vega-dataflow';\nimport {accessor, accessorFields, accessorName, inherits} from 'vega-util';\n\n/**\n * Wraps an expression function with access to external parameters.\n * @constructor\n * @param {object} params - The parameters for this operator.\n * @param {function} params.expr - The expression function. The\n *  function should accept both a datum and a parameter object.\n *  This operator's value will be a new function that wraps the\n *  expression function with access to this operator's parameters.\n */\nexport default function Expression(params) {\n  Operator.call(this, null, update, params);\n  this.modified(true);\n}\n\ninherits(Expression, Operator);\n\nfunction update(_) {\n  const expr = _.expr;\n  return this.value && !_.modified('expr')\n    ? this.value\n    : accessor(\n        datum => expr(datum, _),\n        accessorFields(expr),\n        accessorName(expr)\n      );\n}\n","import {Transform} from 'vega-dataflow';\nimport {accessorName, inherits, toNumber} from 'vega-util';\n\n/**\n * Computes extents (min/max) for a data field.\n * @constructor\n * @param {object} params - The parameters for this operator.\n * @param {function(object): *} params.field - The field over which to compute extends.\n */\nexport default function Extent(params) {\n  Transform.call(this, [undefined, undefined], params);\n}\n\nExtent.Definition = {\n  'type': 'Extent',\n  'metadata': {},\n  'params': [\n    { 'name': 'field', 'type': 'field', 'required': true }\n  ]\n};\n\ninherits(Extent, Transform, {\n  transform(_, pulse) {\n    const extent = this.value,\n          field = _.field,\n          mod = pulse.changed()\n            || pulse.modified(field.fields)\n            || _.modified('field');\n\n    let min = extent[0],\n        max = extent[1];\n    if (mod || min == null) {\n      min = +Infinity;\n      max = -Infinity;\n    }\n\n    pulse.visit(mod ? pulse.SOURCE : pulse.ADD, t => {\n      const v = toNumber(field(t));\n      if (v != null) {\n        // NaNs will fail all comparisons!\n        if (v < min) min = v;\n        if (v > max) max = v;\n      }\n    });\n\n    if (!Number.isFinite(min) || !Number.isFinite(max)) {\n      let name = accessorName(field);\n      if (name) name = ` for field \"${name}\"`;\n      pulse.dataflow.warn(`Infinite extent${name}: [${min}, ${max}]`);\n      min = max = undefined;\n    }\n    this.value = [min, max];\n  }\n});\n","import {Operator} from 'vega-dataflow';\nimport {inherits} from 'vega-util';\n\n/**\n * Provides a bridge between a parent transform and a target subflow that\n * consumes only a subset of the tuples that pass through the parent.\n * @constructor\n * @param {Pulse} pulse - A pulse to use as the value of this operator.\n * @param {Transform} parent - The parent transform (typically a Facet instance).\n */\nexport default function Subflow(pulse, parent) {\n  Operator.call(this, pulse);\n  this.parent = parent;\n  this.count = 0;\n}\n\ninherits(Subflow, Operator, {\n  /**\n   * Routes pulses from this subflow to a target transform.\n   * @param {Transform} target - A transform that receives the subflow of tuples.\n   */\n  connect(target) {\n    this.detachSubflow = target.detachSubflow;\n    this.targets().add(target);\n    return (target.source = this);\n  },\n\n  /**\n   * Add an 'add' tuple to the subflow pulse.\n   * @param {Tuple} t - The tuple being added.\n   */\n  add(t) {\n    this.count += 1;\n    this.value.add.push(t);\n  },\n\n  /**\n   * Add a 'rem' tuple to the subflow pulse.\n   * @param {Tuple} t - The tuple being removed.\n   */\n  rem(t) {\n    this.count -= 1;\n    this.value.rem.push(t);\n  },\n\n  /**\n   * Add a 'mod' tuple to the subflow pulse.\n   * @param {Tuple} t - The tuple being modified.\n   */\n  mod(t) {\n    this.value.mod.push(t);\n  },\n\n  /**\n   * Re-initialize this operator's pulse value.\n   * @param {Pulse} pulse - The pulse to copy from.\n   * @see Pulse.init\n   */\n  init(pulse) {\n    this.value.init(pulse, pulse.NO_SOURCE);\n  },\n\n  /**\n   * Evaluate this operator. This method overrides the\n   * default behavior to simply return the contained pulse value.\n   * @return {Pulse}\n   */\n  evaluate() {\n    // assert: this.value.stamp === pulse.stamp\n    return this.value;\n  }\n});\n","import Subflow from './Subflow';\nimport {Transform, tupleid} from 'vega-dataflow';\nimport {fastmap, hasOwnProperty, inherits} from 'vega-util';\n\n/**\n * Facets a dataflow into a set of subflows based on a key.\n * @constructor\n * @param {object} params - The parameters for this operator.\n * @param {function(Dataflow, string): Operator} params.subflow - A function\n *   that generates a subflow of operators and returns its root operator.\n * @param {function(object): *} params.key - The key field to facet by.\n */\nexport default function Facet(params) {\n  Transform.call(this, {}, params);\n  this._keys = fastmap(); // cache previously calculated key values\n\n  // keep track of active subflows, use as targets array for listeners\n  // this allows us to limit propagation to only updated subflows\n  const a = this._targets = [];\n  a.active = 0;\n  a.forEach = f => {\n    for (let i=0, n=a.active; i<n; ++i) {\n      f(a[i], i, a);\n    }\n  };\n}\n\ninherits(Facet, Transform, {\n  activate(flow) {\n    this._targets[this._targets.active++] = flow;\n  },\n\n  // parent argument provided by PreFacet subclass\n  subflow(key, flow, pulse, parent) {\n    const flows = this.value;\n    let sf = hasOwnProperty(flows, key) && flows[key],\n        df, p;\n\n    if (!sf) {\n      p = parent || (p = this._group[key]) && p.tuple;\n      df = pulse.dataflow;\n      sf = new Subflow(pulse.fork(pulse.NO_SOURCE), this);\n      df.add(sf).connect(flow(df, key, p));\n      flows[key] = sf;\n      this.activate(sf);\n    } else if (sf.value.stamp < pulse.stamp) {\n      sf.init(pulse);\n      this.activate(sf);\n    }\n\n    return sf;\n  },\n\n  clean() {\n    const flows = this.value;\n    let detached = 0;\n    for (const key in flows) {\n      if (flows[key].count === 0) {\n        const detach = flows[key].detachSubflow;\n        if (detach) detach();\n        delete flows[key];\n        ++detached;\n      }\n    }\n\n    // remove inactive targets from the active targets array\n    if (detached) {\n      const active = this._targets.filter(sf => sf && sf.count > 0);\n      this.initTargets(active);\n    }\n  },\n\n  initTargets(act) {\n    const a = this._targets,\n          n = a.length,\n          m = act ? act.length : 0;\n    let i = 0;\n\n    for (; i<m; ++i) {\n      a[i] = act[i];\n    }\n    for (; i<n && a[i] != null; ++i) {\n      a[i] = null; // ensure old flows can be garbage collected\n    }\n    a.active = m;\n  },\n\n  transform(_, pulse) {\n    const df = pulse.dataflow,\n          key = _.key,\n          flow = _.subflow,\n          cache = this._keys,\n          rekey = _.modified('key'),\n          subflow = key => this.subflow(key, flow, pulse);\n\n    this._group = _.group || {};\n    this.initTargets(); // reset list of active subflows\n\n    pulse.visit(pulse.REM, t => {\n      const id = tupleid(t),\n            k = cache.get(id);\n      if (k !== undefined) {\n        cache.delete(id);\n        subflow(k).rem(t);\n      }\n    });\n\n    pulse.visit(pulse.ADD, t => {\n      const k = key(t);\n      cache.set(tupleid(t), k);\n      subflow(k).add(t);\n    });\n\n    if (rekey || pulse.modified(key.fields)) {\n      pulse.visit(pulse.MOD, t => {\n        const id = tupleid(t),\n              k0 = cache.get(id),\n              k1 = key(t);\n        if (k0 === k1) {\n          subflow(k1).mod(t);\n        } else {\n          cache.set(id, k1);\n          subflow(k0).rem(t);\n          subflow(k1).add(t);\n        }\n      });\n    } else if (pulse.changed(pulse.MOD)) {\n      pulse.visit(pulse.MOD, t => {\n        subflow(cache.get(tupleid(t))).mod(t);\n      });\n    }\n\n    if (rekey) {\n      pulse.visit(pulse.REFLOW, t => {\n        const id = tupleid(t),\n              k0 = cache.get(id),\n              k1 = key(t);\n        if (k0 !== k1) {\n          cache.set(id, k1);\n          subflow(k0).rem(t);\n          subflow(k1).add(t);\n        }\n      });\n    }\n\n    if (pulse.clean()) {\n      df.runAfter(() => { this.clean(); cache.clean(); });\n    } else if (cache.empty > df.cleanThreshold) {\n      df.runAfter(cache.clean);\n    }\n\n    return pulse;\n  }\n});\n","import {Operator} from 'vega-dataflow';\nimport {array, field, inherits, isArray} from 'vega-util';\n\n/**\n * Generates one or more field accessor functions.\n * If the 'name' parameter is an array, an array of field accessors\n * will be created and the 'as' parameter will be ignored.\n * @constructor\n * @param {object} params - The parameters for this operator.\n * @param {string} params.name - The field name(s) to access.\n * @param {string} params.as - The accessor function name.\n */\nexport default function Field(params) {\n  Operator.call(this, null, update, params);\n}\n\ninherits(Field, Operator);\n\nfunction update(_) {\n  return (this.value && !_.modified()) ? this.value\n    : isArray(_.name) ? array(_.name).map(f => field(f))\n    : field(_.name, _.as);\n}\n","import {Transform, tupleid} from 'vega-dataflow';\nimport {fastmap, inherits} from 'vega-util';\n\n/**\n * Filters data tuples according to a predicate function.\n * @constructor\n * @param {object} params - The parameters for this operator.\n * @param {function(object): *} params.expr - The predicate expression function\n *   that determines a tuple's filter status. Truthy values pass the filter.\n */\nexport default function Filter(params) {\n  Transform.call(this, fastmap(), params);\n}\n\nFilter.Definition = {\n  'type': 'Filter',\n  'metadata': {'changes': true},\n  'params': [\n    { 'name': 'expr', 'type': 'expr', 'required': true }\n  ]\n};\n\ninherits(Filter, Transform, {\n  transform(_, pulse) {\n    const df = pulse.dataflow,\n          cache = this.value, // cache ids of filtered tuples\n          output = pulse.fork(),\n          add = output.add,\n          rem = output.rem,\n          mod = output.mod,\n          test = _.expr;\n    let isMod = true;\n\n    pulse.visit(pulse.REM, t => {\n      const id = tupleid(t);\n      if (!cache.has(id)) rem.push(t);\n      else cache.delete(id);\n    });\n\n    pulse.visit(pulse.ADD, t => {\n      if (test(t, _)) add.push(t);\n      else cache.set(tupleid(t), 1);\n    });\n\n    function revisit(t) {\n      const id = tupleid(t),\n            b = test(t, _),\n            s = cache.get(id);\n      if (b && s) {\n        cache.delete(id);\n        add.push(t);\n      } else if (!b && !s) {\n        cache.set(id, 1);\n        rem.push(t);\n      } else if (isMod && b && !s) {\n        mod.push(t);\n      }\n    }\n\n    pulse.visit(pulse.MOD, revisit);\n\n    if (_.modified()) {\n      isMod = false;\n      pulse.visit(pulse.REFLOW, revisit);\n    }\n\n    if (cache.empty > df.cleanThreshold) df.runAfter(cache.clean);\n    return output;\n  }\n});\n","import {fieldNames} from './util/util';\nimport {Transform, derive} from 'vega-dataflow';\nimport {inherits} from 'vega-util';\n\n/**\n * Flattens array-typed field values into new data objects.\n * If multiple fields are specified, they are treated as parallel arrays,\n * with output values included for each matching index (or null if missing).\n * @constructor\n * @param {object} params - The parameters for this operator.\n * @param {Array<function(object): *>} params.fields - An array of field\n *   accessors for the tuple fields that should be flattened.\n * @param {string} [params.index] - Optional output field name for index\n *   value. If unspecified, no index field is included in the output.\n * @param {Array<string>} [params.as] - Output field names for flattened\n *   array fields. Any unspecified fields will use the field name provided\n *   by the fields accessors.\n */\nexport default function Flatten(params) {\n  Transform.call(this, [], params);\n}\n\nFlatten.Definition = {\n  'type': 'Flatten',\n  'metadata': {'generates': true},\n  'params': [\n    { 'name': 'fields', 'type': 'field', 'array': true, 'required': true },\n    { 'name': 'index', 'type': 'string' },\n    { 'name': 'as', 'type': 'string', 'array': true }\n  ]\n};\n\ninherits(Flatten, Transform, {\n  transform(_, pulse) {\n    const out = pulse.fork(pulse.NO_SOURCE),\n          fields = _.fields,\n          as = fieldNames(fields, _.as || []),\n          index = _.index || null,\n          m = as.length;\n\n    // remove any previous results\n    out.rem = this.value;\n\n    // generate flattened tuples\n    pulse.visit(pulse.SOURCE, t => {\n      const arrays = fields.map(f => f(t)),\n            maxlen = arrays.reduce((l, a) => Math.max(l, a.length), 0);\n      let i = 0, j, d, v;\n\n      for (; i<maxlen; ++i) {\n        d = derive(t);\n        for (j=0; j<m; ++j) {\n          d[as[j]] = (v = arrays[j][i]) == null ? null : v;\n        }\n        if (index) {\n          d[index] = i;\n        }\n        out.add.push(d);\n      }\n    });\n\n    this.value = out.source = out.add;\n    if (index) out.modifies(index);\n    return out.modifies(as);\n  }\n});\n","import {Transform, derive} from 'vega-dataflow';\nimport {accessorName, inherits} from 'vega-util';\n\n/**\n * Folds one more tuple fields into multiple tuples in which the field\n * name and values are available under new 'key' and 'value' fields.\n * @constructor\n * @param {object} params - The parameters for this operator.\n * @param {function(object): *} params.fields - An array of field accessors\n *   for the tuple fields that should be folded.\n * @param {Array<string>} [params.as] - Output field names for folded key\n *   and value fields, defaults to ['key', 'value'].\n */\nexport default function Fold(params) {\n  Transform.call(this, [], params);\n}\n\nFold.Definition = {\n  'type': 'Fold',\n  'metadata': {'generates': true},\n  'params': [\n    { 'name': 'fields', 'type': 'field', 'array': true, 'required': true },\n    { 'name': 'as', 'type': 'string', 'array': true, 'length': 2, 'default': ['key', 'value'] }\n  ]\n};\n\ninherits(Fold, Transform, {\n  transform(_, pulse) {\n    const out = pulse.fork(pulse.NO_SOURCE),\n          fields = _.fields,\n          fnames = fields.map(accessorName),\n          as = _.as || ['key', 'value'],\n          k = as[0],\n          v = as[1],\n          n = fields.length;\n\n    out.rem = this.value;\n\n    pulse.visit(pulse.SOURCE, t => {\n      for (let i=0, d; i<n; ++i) {\n        d = derive(t);\n        d[k] = fnames[i];\n        d[v] = fields[i](t);\n        out.add.push(d);\n      }\n    });\n\n    this.value = out.source = out.add;\n    return out.modifies(as);\n  }\n});\n","import {Transform} from 'vega-dataflow';\nimport {inherits} from 'vega-util';\n\n/**\n * Invokes a function for each data tuple and saves the results as a new field.\n * @constructor\n * @param {object} params - The parameters for this operator.\n * @param {function(object): *} params.expr - The formula function to invoke for each tuple.\n * @param {string} params.as - The field name under which to save the result.\n * @param {boolean} [params.initonly=false] - If true, the formula is applied to\n *   added tuples only, and does not update in response to modifications.\n */\nexport default function Formula(params) {\n  Transform.call(this, null, params);\n}\n\nFormula.Definition = {\n  'type': 'Formula',\n  'metadata': {'modifies': true},\n  'params': [\n    { 'name': 'expr', 'type': 'expr', 'required': true },\n    { 'name': 'as', 'type': 'string', 'required': true },\n    { 'name': 'initonly', 'type': 'boolean' }\n  ]\n};\n\ninherits(Formula, Transform, {\n  transform (_, pulse) {\n    const func = _.expr,\n          as = _.as,\n          mod = _.modified(),\n          flag = _.initonly ? pulse.ADD\n            : mod ? pulse.SOURCE\n            : pulse.modified(func.fields) || pulse.modified(as) ? pulse.ADD_MOD\n            : pulse.ADD;\n\n    if (mod) {\n      // parameters updated, need to reflow\n      pulse = pulse.materialize().reflow(true);\n    }\n\n    if (!_.initonly) {\n      pulse.modifies(as);\n    }\n\n    return pulse.visit(flag, t => t[as] = func(t, _));\n  }\n});\n","import {Transform, ingest} from 'vega-dataflow';\nimport {inherits} from 'vega-util';\n\n/**\n * Generates data tuples using a provided generator function.\n * @constructor\n * @param {object} params - The parameters for this operator.\n * @param {function(Parameters): object} params.generator - A tuple generator\n *   function. This function is given the operator parameters as input.\n *   Changes to any additional parameters will not trigger re-calculation\n *   of previously generated tuples. Only future tuples are affected.\n * @param {number} params.size - The number of tuples to produce.\n */\nexport default function Generate(params) {\n  Transform.call(this, [], params);\n}\n\ninherits(Generate, Transform, {\n  transform(_, pulse) {\n    const out = pulse.fork(pulse.ALL),\n          gen = _.generator;\n\n    let data = this.value,\n        num = _.size - data.length,\n        add, rem, t;\n\n    if (num > 0) {\n      // need more tuples, generate and add\n      for (add=[]; --num >= 0;) {\n        add.push(t = ingest(gen(_)));\n        data.push(t);\n      }\n      out.add = out.add.length\n        ? out.materialize(out.ADD).add.concat(add)\n        : add;\n    } else {\n      // need fewer tuples, remove\n      rem = data.slice(0, -num);\n      out.rem = out.rem.length\n        ? out.materialize(out.REM).rem.concat(rem)\n        : rem;\n      data = data.slice(-num);\n    }\n\n    out.source = this.value = data;\n    return out;\n  }\n});\n","export default function ascending(a, b) {\n  return a == null || b == null ? NaN : a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;\n}\n","export default function descending(a, b) {\n  return a == null || b == null ? NaN\n    : b < a ? -1\n    : b > a ? 1\n    : b >= a ? 0\n    : NaN;\n}\n","import ascending from \"./ascending.js\";\nimport descending from \"./descending.js\";\n\nexport default function bisector(f) {\n  let compare1, compare2, delta;\n\n  // If an accessor is specified, promote it to a comparator. In this case we\n  // can test whether the search value is (self-) comparable. We can’t do this\n  // for a comparator (except for specific, known comparators) because we can’t\n  // tell if the comparator is symmetric, and an asymmetric comparator can’t be\n  // used to test whether a single value is comparable.\n  if (f.length !== 2) {\n    compare1 = ascending;\n    compare2 = (d, x) => ascending(f(d), x);\n    delta = (d, x) => f(d) - x;\n  } else {\n    compare1 = f === ascending || f === descending ? f : zero;\n    compare2 = f;\n    delta = f;\n  }\n\n  function left(a, x, lo = 0, hi = a.length) {\n    if (lo < hi) {\n      if (compare1(x, x) !== 0) return hi;\n      do {\n        const mid = (lo + hi) >>> 1;\n        if (compare2(a[mid], x) < 0) lo = mid + 1;\n        else hi = mid;\n      } while (lo < hi);\n    }\n    return lo;\n  }\n\n  function right(a, x, lo = 0, hi = a.length) {\n    if (lo < hi) {\n      if (compare1(x, x) !== 0) return hi;\n      do {\n        const mid = (lo + hi) >>> 1;\n        if (compare2(a[mid], x) <= 0) lo = mid + 1;\n        else hi = mid;\n      } while (lo < hi);\n    }\n    return lo;\n  }\n\n  function center(a, x, lo = 0, hi = a.length) {\n    const i = left(a, x, lo, hi - 1);\n    return i > lo && delta(a[i - 1], x) > -delta(a[i], x) ? i - 1 : i;\n  }\n\n  return {left, center, right};\n}\n\nfunction zero() {\n  return 0;\n}\n","import ascending from \"./ascending.js\";\nimport permute from \"./permute.js\";\n\nexport default function sort(values, ...F) {\n  if (typeof values[Symbol.iterator] !== \"function\") throw new TypeError(\"values is not iterable\");\n  values = Array.from(values);\n  let [f] = F;\n  if ((f && f.length !== 2) || F.length > 1) {\n    const index = Uint32Array.from(values, (d, i) => i);\n    if (F.length > 1) {\n      F = F.map(f => values.map(f));\n      index.sort((i, j) => {\n        for (const f of F) {\n          const c = ascendingDefined(f[i], f[j]);\n          if (c) return c;\n        }\n      });\n    } else {\n      f = values.map(f);\n      index.sort((i, j) => ascendingDefined(f[i], f[j]));\n    }\n    return permute(values, index);\n  }\n  return values.sort(compareDefined(f));\n}\n\nexport function compareDefined(compare = ascending) {\n  if (compare === ascending) return ascendingDefined;\n  if (typeof compare !== \"function\") throw new TypeError(\"compare is not a function\");\n  return (a, b) => {\n    const x = compare(a, b);\n    if (x || x === 0) return x;\n    return (compare(b, b) === 0) - (compare(a, a) === 0);\n  };\n}\n\nexport function ascendingDefined(a, b) {\n  return (a == null || !(a >= a)) - (b == null || !(b >= b)) || (a < b ? -1 : a > b ? 1 : 0);\n}\n","export default function max(values, valueof) {\n  let max;\n  if (valueof === undefined) {\n    for (const value of values) {\n      if (value != null\n          && (max < value || (max === undefined && value >= value))) {\n        max = value;\n      }\n    }\n  } else {\n    let index = -1;\n    for (let value of values) {\n      if ((value = valueof(value, ++index, values)) != null\n          && (max < value || (max === undefined && value >= value))) {\n        max = value;\n      }\n    }\n  }\n  return max;\n}\n","export default function min(values, valueof) {\n  let min;\n  if (valueof === undefined) {\n    for (const value of values) {\n      if (value != null\n          && (min > value || (min === undefined && value >= value))) {\n        min = value;\n      }\n    }\n  } else {\n    let index = -1;\n    for (let value of values) {\n      if ((value = valueof(value, ++index, values)) != null\n          && (min > value || (min === undefined && value >= value))) {\n        min = value;\n      }\n    }\n  }\n  return min;\n}\n","import {ascendingDefined, compareDefined} from \"./sort.js\";\n\n// Based on https://github.com/mourner/quickselect\n// ISC license, Copyright 2018 Vladimir Agafonkin.\nexport default function quickselect(array, k, left = 0, right = Infinity, compare) {\n  k = Math.floor(k);\n  left = Math.floor(Math.max(0, left));\n  right = Math.floor(Math.min(array.length - 1, right));\n\n  if (!(left <= k && k <= right)) return array;\n\n  compare = compare === undefined ? ascendingDefined : compareDefined(compare);\n\n  while (right > left) {\n    if (right - left > 600) {\n      const n = right - left + 1;\n      const m = k - left + 1;\n      const z = Math.log(n);\n      const s = 0.5 * Math.exp(2 * z / 3);\n      const sd = 0.5 * Math.sqrt(z * s * (n - s) / n) * (m - n / 2 < 0 ? -1 : 1);\n      const newLeft = Math.max(left, Math.floor(k - m * s / n + sd));\n      const newRight = Math.min(right, Math.floor(k + (n - m) * s / n + sd));\n      quickselect(array, k, newLeft, newRight, compare);\n    }\n\n    const t = array[k];\n    let i = left;\n    let j = right;\n\n    swap(array, left, k);\n    if (compare(array[right], t) > 0) swap(array, left, right);\n\n    while (i < j) {\n      swap(array, i, j), ++i, --j;\n      while (compare(array[i], t) < 0) ++i;\n      while (compare(array[j], t) > 0) --j;\n    }\n\n    if (compare(array[left], t) === 0) swap(array, left, j);\n    else ++j, swap(array, j, right);\n\n    if (j <= k) left = j + 1;\n    if (k <= j) right = j - 1;\n  }\n\n  return array;\n}\n\nfunction swap(array, i, j) {\n  const t = array[i];\n  array[i] = array[j];\n  array[j] = t;\n}\n","export default function range(start, stop, step) {\n  start = +start, stop = +stop, step = (n = arguments.length) < 2 ? (stop = start, start = 0, 1) : n < 3 ? 1 : +step;\n\n  var i = -1,\n      n = Math.max(0, Math.ceil((stop - start) / step)) | 0,\n      range = new Array(n);\n\n  while (++i < n) {\n    range[i] = start + i * step;\n  }\n\n  return range;\n}\n","import {Transform, ingest} from 'vega-dataflow';\nimport {accessorName, error, inherits} from 'vega-util';\nimport {max, mean, median, min} from 'd3-array';\n\nconst Methods = {\n  value: 'value',\n  median: median,\n  mean: mean,\n  min: min,\n  max: max\n};\n\nconst Empty = [];\n\n/**\n * Impute missing values.\n * @constructor\n * @param {object} params - The parameters for this operator.\n * @param {function(object): *} params.field - The value field to impute.\n * @param {Array<function(object): *>} [params.groupby] - An array of\n *   accessors to determine series within which to perform imputation.\n * @param {function(object): *} params.key - An accessor for a key value.\n *   Each key value should be unique within a group. New tuples will be\n *   imputed for any key values that are not found within a group.\n * @param {Array<*>} [params.keyvals] - Optional array of required key\n *   values. New tuples will be imputed for any key values that are not\n *   found within a group. In addition, these values will be automatically\n *   augmented with the key values observed in the input data.\n * @param {string} [method='value'] - The imputation method to use. One of\n *   'value', 'mean', 'median', 'max', 'min'.\n * @param {*} [value=0] - The constant value to use for imputation\n *   when using method 'value'.\n */\nexport default function Impute(params) {\n  Transform.call(this, [], params);\n}\n\nImpute.Definition = {\n  'type': 'Impute',\n  'metadata': {'changes': true},\n  'params': [\n    { 'name': 'field', 'type': 'field', 'required': true },\n    { 'name': 'key', 'type': 'field', 'required': true },\n    { 'name': 'keyvals', 'array': true },\n    { 'name': 'groupby', 'type': 'field', 'array': true },\n    { 'name': 'method', 'type': 'enum', 'default': 'value',\n      'values': ['value', 'mean', 'median', 'max', 'min'] },\n    { 'name': 'value', 'default': 0 }\n  ]\n};\n\nfunction getValue(_) {\n  var m = _.method || Methods.value, v;\n\n  if (Methods[m] == null) {\n    error('Unrecognized imputation method: ' + m);\n  } else if (m === Methods.value) {\n    v = _.value !== undefined ? _.value : 0;\n    return () => v;\n  } else {\n    return Methods[m];\n  }\n}\n\nfunction getField(_) {\n  const f = _.field;\n  return t => t ? f(t) : NaN;\n}\n\ninherits(Impute, Transform, {\n  transform(_, pulse) {\n    var out = pulse.fork(pulse.ALL),\n        impute = getValue(_),\n        field = getField(_),\n        fName = accessorName(_.field),\n        kName = accessorName(_.key),\n        gNames = (_.groupby || []).map(accessorName),\n        groups = partition(pulse.source, _.groupby, _.key, _.keyvals),\n        curr = [],\n        prev = this.value,\n        m = groups.domain.length,\n        group, value, gVals, kVal, g, i, j, l, n, t;\n\n    for (g=0, l=groups.length; g<l; ++g) {\n      group = groups[g];\n      gVals = group.values;\n      value = NaN;\n\n      // add tuples for missing values\n      for (j=0; j<m; ++j) {\n        if (group[j] != null) continue;\n        kVal = groups.domain[j];\n\n        t = {_impute: true};\n        for (i=0, n=gVals.length; i<n; ++i) t[gNames[i]] = gVals[i];\n        t[kName] = kVal;\n        t[fName] = Number.isNaN(value) ? (value = impute(group, field)) : value;\n\n        curr.push(ingest(t));\n      }\n    }\n\n    // update pulse with imputed tuples\n    if (curr.length) out.add = out.materialize(out.ADD).add.concat(curr);\n    if (prev.length) out.rem = out.materialize(out.REM).rem.concat(prev);\n    this.value = curr;\n\n    return out;\n  }\n});\n\nfunction partition(data, groupby, key, keyvals) {\n  var get = f => f(t),\n      groups = [],\n      domain = keyvals ? keyvals.slice() : [],\n      kMap = {},\n      gMap = {}, gVals, gKey,\n      group, i, j, k, n, t;\n\n  domain.forEach((k, i) => kMap[k] = i + 1);\n\n  for (i=0, n=data.length; i<n; ++i) {\n    t = data[i];\n    k = key(t);\n    j = kMap[k] || (kMap[k] = domain.push(k));\n\n    gKey = (gVals = groupby ? groupby.map(get) : Empty) + '';\n    if (!(group = gMap[gKey])) {\n      group = (gMap[gKey] = []);\n      groups.push(group);\n      group.values = gVals;\n    }\n    group[j-1] = t;\n  }\n\n  groups.domain = domain;\n  return groups;\n}\n","import quantile, {quantileIndex} from \"./quantile.js\";\n\nexport default function median(values, valueof) {\n  return quantile(values, 0.5, valueof);\n}\n\nexport function medianIndex(values, valueof) {\n  return quantileIndex(values, 0.5, valueof);\n}\n","import max from \"./max.js\";\nimport maxIndex from \"./maxIndex.js\";\nimport min from \"./min.js\";\nimport minIndex from \"./minIndex.js\";\nimport quickselect from \"./quickselect.js\";\nimport number, {numbers} from \"./number.js\";\nimport {ascendingDefined} from \"./sort.js\";\nimport greatest from \"./greatest.js\";\n\nexport default function quantile(values, p, valueof) {\n  values = Float64Array.from(numbers(values, valueof));\n  if (!(n = values.length) || isNaN(p = +p)) return;\n  if (p <= 0 || n < 2) return min(values);\n  if (p >= 1) return max(values);\n  var n,\n      i = (n - 1) * p,\n      i0 = Math.floor(i),\n      value0 = max(quickselect(values, i0).subarray(0, i0 + 1)),\n      value1 = min(values.subarray(i0 + 1));\n  return value0 + (value1 - value0) * (i - i0);\n}\n\nexport function quantileSorted(values, p, valueof = number) {\n  if (!(n = values.length) || isNaN(p = +p)) return;\n  if (p <= 0 || n < 2) return +valueof(values[0], 0, values);\n  if (p >= 1) return +valueof(values[n - 1], n - 1, values);\n  var n,\n      i = (n - 1) * p,\n      i0 = Math.floor(i),\n      value0 = +valueof(values[i0], i0, values),\n      value1 = +valueof(values[i0 + 1], i0 + 1, values);\n  return value0 + (value1 - value0) * (i - i0);\n}\n\nexport function quantileIndex(values, p, valueof) {\n  values = Float64Array.from(numbers(values, valueof));\n  if (!(n = values.length) || isNaN(p = +p)) return;\n  if (p <= 0 || n < 2) return minIndex(values);\n  if (p >= 1) return maxIndex(values);\n  var n,\n      i = Math.floor((n - 1) * p),\n      order = (i, j) => ascendingDefined(values[i], values[j]),\n      index = quickselect(Uint32Array.from(values, (_, i) => i), i, 0, n - 1, order);\n  return greatest(index.subarray(0, i + 1), i => values[i]);\n}\n","export default function number(x) {\n  return x === null ? NaN : +x;\n}\n\nexport function* numbers(values, valueof) {\n  if (valueof === undefined) {\n    for (let value of values) {\n      if (value != null && (value = +value) >= value) {\n        yield value;\n      }\n    }\n  } else {\n    let index = -1;\n    for (let value of values) {\n      if ((value = valueof(value, ++index, values)) != null && (value = +value) >= value) {\n        yield value;\n      }\n    }\n  }\n}\n","export default function mean(values, valueof) {\n  let count = 0;\n  let sum = 0;\n  if (valueof === undefined) {\n    for (let value of values) {\n      if (value != null && (value = +value) >= value) {\n        ++count, sum += value;\n      }\n    }\n  } else {\n    let index = -1;\n    for (let value of values) {\n      if ((value = valueof(value, ++index, values)) != null && (value = +value) >= value) {\n        ++count, sum += value;\n      }\n    }\n  }\n  if (count) return sum / count;\n}\n","import Aggregate from './Aggregate';\nimport {ValidAggregateOps} from './util/AggregateOps';\nimport {extend, inherits} from 'vega-util';\n\n/**\n * Extend input tuples with aggregate values.\n * Calcuates aggregate values and joins them with the input stream.\n * @constructor\n */\nexport default function JoinAggregate(params) {\n  Aggregate.call(this, params);\n}\n\nJoinAggregate.Definition = {\n  'type': 'JoinAggregate',\n  'metadata': {'modifies': true},\n  'params': [\n    { 'name': 'groupby', 'type': 'field', 'array': true },\n    { 'name': 'fields', 'type': 'field', 'null': true, 'array': true },\n    { 'name': 'ops', 'type': 'enum', 'array': true, 'values': ValidAggregateOps },\n    { 'name': 'as', 'type': 'string', 'null': true, 'array': true },\n    { 'name': 'key', 'type': 'field' }\n  ]\n};\n\ninherits(JoinAggregate, Aggregate, {\n  transform(_, pulse) {\n    const aggr = this,\n          mod = _.modified();\n    let cells;\n\n    // process all input tuples to calculate aggregates\n    if (aggr.value && (mod || pulse.modified(aggr._inputs, true))) {\n      cells = aggr.value = mod ? aggr.init(_) : {};\n      pulse.visit(pulse.SOURCE, t => aggr.add(t));\n    } else {\n      cells = aggr.value = aggr.value || this.init(_);\n      pulse.visit(pulse.REM, t => aggr.rem(t));\n      pulse.visit(pulse.ADD, t => aggr.add(t));\n    }\n\n    // update aggregation cells\n    aggr.changes();\n\n    // write aggregate values to input tuples\n    pulse.visit(pulse.SOURCE, t => {\n      extend(t, cells[aggr.cellkey(t)].tuple);\n    });\n\n    return pulse.reflow(mod).modifies(this._outputs);\n  },\n\n  changes() {\n    const adds = this._adds,\n          mods = this._mods;\n    let i, n;\n\n    for (i=0, n=this._alen; i<n; ++i) {\n      this.celltuple(adds[i]);\n      adds[i] = null; // for garbage collection\n    }\n\n    for (i=0, n=this._mlen; i<n; ++i) {\n      this.celltuple(mods[i]);\n      mods[i] = null; // for garbage collection\n    }\n\n    this._alen = this._mlen = 0; // reset list of active cells\n  }\n});\n","import {partition} from './util/util';\nimport {randomKDE} from 'vega-statistics';\nimport {Transform, ingest} from 'vega-dataflow';\nimport {sampleCurve} from 'vega-statistics';\nimport {accessorName, error, extent, inherits} from 'vega-util';\n\n/**\n * Compute kernel density estimates (KDE) for one or more data groups.\n * @constructor\n * @param {object} params - The parameters for this operator.\n * @param {Array<function(object): *>} [params.groupby] - An array of accessors\n *   to groupby.\n * @param {function(object): *} params.field - An accessor for the data field\n *   to estimate.\n * @param {number} [params.bandwidth=0] - The KDE kernel bandwidth.\n *   If zero or unspecified, the bandwidth is automatically determined.\n * @param {boolean} [params.counts=false] - A boolean flag indicating if the\n *   output values should be probability estimates (false, default) or\n *   smoothed counts (true).\n * @param {string} [params.cumulative=false] - A boolean flag indicating if a\n *   density (false) or cumulative distribution (true) should be generated.\n * @param {Array<number>} [params.extent] - The domain extent over which to\n *   plot the density. If unspecified, the [min, max] data extent is used.\n * @param {string} [params.resolve='independent'] - Indicates how parameters for\n *   multiple densities should be resolved. If \"independent\" (the default), each\n *   density may have its own domain extent and dynamic number of curve sample\n *   steps. If \"shared\", the KDE transform will ensure that all densities are\n *   defined over a shared domain and curve steps, enabling stacking.\n * @param {number} [params.minsteps=25] - The minimum number of curve samples\n *   for plotting the density.\n * @param {number} [params.maxsteps=200] - The maximum number of curve samples\n *   for plotting the density.\n * @param {number} [params.steps] - The exact number of curve samples for\n *   plotting the density. If specified, overrides both minsteps and maxsteps\n *   to set an exact number of uniform samples. Useful in conjunction with\n *   a fixed extent to ensure consistent sample points for stacked densities.\n */\nexport default function KDE(params) {\n  Transform.call(this, null, params);\n}\n\nKDE.Definition = {\n  'type': 'KDE',\n  'metadata': {'generates': true},\n  'params': [\n    { 'name': 'groupby', 'type': 'field', 'array': true },\n    { 'name': 'field', 'type': 'field', 'required': true },\n    { 'name': 'cumulative', 'type': 'boolean', 'default': false },\n    { 'name': 'counts', 'type': 'boolean', 'default': false },\n    { 'name': 'bandwidth', 'type': 'number', 'default': 0 },\n    { 'name': 'extent', 'type': 'number', 'array': true, 'length': 2 },\n    { 'name': 'resolve', 'type': 'enum', 'values': ['shared', 'independent'], 'default': 'independent' },\n    { 'name': 'steps', 'type': 'number' },\n    { 'name': 'minsteps', 'type': 'number', 'default': 25 },\n    { 'name': 'maxsteps', 'type': 'number', 'default': 200 },\n    { 'name': 'as', 'type': 'string', 'array': true, 'default': ['value', 'density'] }\n  ]\n};\n\ninherits(KDE, Transform, {\n  transform(_, pulse) {\n    const out = pulse.fork(pulse.NO_SOURCE | pulse.NO_FIELDS);\n\n    if (!this.value || pulse.changed() || _.modified()) {\n      const source = pulse.materialize(pulse.SOURCE).source,\n            groups = partition(source, _.groupby, _.field),\n            names = (_.groupby || []).map(accessorName),\n            bandwidth = _.bandwidth,\n            method = _.cumulative ? 'cdf' : 'pdf',\n            as = _.as || ['value', 'density'],\n            values = [];\n\n      let domain = _.extent,\n          minsteps = _.steps || _.minsteps || 25,\n          maxsteps = _.steps || _.maxsteps || 200;\n\n      if (method !== 'pdf' && method !== 'cdf') {\n        error('Invalid density method: ' + method);\n      }\n\n      if (_.resolve === 'shared') {\n        if (!domain) domain = extent(source, _.field);\n        minsteps = maxsteps = _.steps || maxsteps;\n      }\n\n      groups.forEach(g => {\n        const density = randomKDE(g, bandwidth)[method],\n              scale = _.counts ? g.length : 1,\n              local = domain || extent(g);\n\n        sampleCurve(density, local, minsteps, maxsteps)\n          .forEach(v => {\n            const t = {};\n            for (let i=0; i<names.length; ++i) {\n              t[names[i]] = g.dims[i];\n            }\n            t[as[0]] = v[0];\n            t[as[1]] = v[1] * scale;\n            values.push(ingest(t));\n          });\n      });\n\n      if (this.value) out.rem = this.value;\n      this.value = out.add = out.source = values;\n    }\n\n    return out;\n  }\n});\n","import {Operator} from 'vega-dataflow';\nimport {inherits, key} from 'vega-util';\n\n/**\n * Generates a key function.\n * @constructor\n * @param {object} params - The parameters for this operator.\n * @param {Array<string>} params.fields - The field name(s) for the key function.\n * @param {boolean} params.flat - A boolean flag indicating if the field names\n *  should be treated as flat property names, side-stepping nested field\n *  lookups normally indicated by dot or bracket notation.\n */\nexport default function Key(params) {\n  Operator.call(this, null, update, params);\n}\n\ninherits(Key, Operator);\n\nfunction update(_) {\n  return (this.value && !_.modified()) ? this.value : key(_.fields, _.flat);\n}\n","import {Transform, ingest} from 'vega-dataflow';\nimport {array, inherits} from 'vega-util';\n\n/**\n * Load and parse data from an external source. Marshalls parameter\n * values and then invokes the Dataflow request method.\n * @constructor\n * @param {object} params - The parameters for this operator.\n * @param {string} params.url - The URL to load from.\n * @param {object} params.format - The data format options.\n */\nexport default function Load(params) {\n  Transform.call(this, [], params);\n  this._pending = null;\n}\n\ninherits(Load, Transform, {\n  transform(_, pulse) {\n    const df = pulse.dataflow;\n\n    if (this._pending) {\n      // update state and return pulse\n      return output(this, pulse, this._pending);\n    }\n\n    if (stop(_)) return pulse.StopPropagation;\n\n    if (_.values) {\n      // parse and ingest values, return output pulse\n      return output(this, pulse, df.parse(_.values, _.format));\n    } else if (_.async) {\n      // return promise for non-blocking async loading\n      const p = df.request(_.url, _.format).then(res => {\n        this._pending = array(res.data);\n        return df => df.touch(this);\n      });\n      return {async: p};\n    } else {\n      // return promise for synchronous loading\n      return df.request(_.url, _.format)\n        .then(res => output(this, pulse, array(res.data)));\n    }\n  }\n});\n\nfunction stop(_) {\n  return _.modified('async') && !(\n    _.modified('values') || _.modified('url') || _.modified('format')\n  );\n}\n\nfunction output(op, pulse, data) {\n  data.forEach(ingest);\n  const out = pulse.fork(pulse.NO_FIELDS & pulse.NO_SOURCE);\n  out.rem = op.value;\n  op.value = out.source = out.add = data;\n  op._pending = null;\n  if (out.rem.length) out.clean(true);\n  return out;\n}\n","import {Transform} from 'vega-dataflow';\nimport {accessorName, error, inherits} from 'vega-util';\n\n/**\n * Extend tuples by joining them with values from a lookup table.\n * @constructor\n * @param {object} params - The parameters for this operator.\n * @param {Map} params.index - The lookup table map.\n * @param {Array<function(object): *} params.fields - The fields to lookup.\n * @param {Array<string>} params.as - Output field names for each lookup value.\n * @param {*} [params.default] - A default value to use if lookup fails.\n */\nexport default function Lookup(params) {\n  Transform.call(this, {}, params);\n}\n\nLookup.Definition = {\n  'type': 'Lookup',\n  'metadata': {'modifies': true},\n  'params': [\n    { 'name': 'index', 'type': 'index', 'params': [\n        {'name': 'from', 'type': 'data', 'required': true },\n        {'name': 'key', 'type': 'field', 'required': true }\n      ] },\n    { 'name': 'values', 'type': 'field', 'array': true },\n    { 'name': 'fields', 'type': 'field', 'array': true, 'required': true },\n    { 'name': 'as', 'type': 'string', 'array': true },\n    { 'name': 'default', 'default': null }\n  ]\n};\n\ninherits(Lookup, Transform, {\n  transform(_, pulse) {\n    const keys = _.fields,\n          index = _.index,\n          values = _.values,\n          defaultValue = _.default==null ? null : _.default,\n          reset = _.modified(),\n          n = keys.length;\n\n    let flag = reset ? pulse.SOURCE : pulse.ADD,\n        out = pulse,\n        as = _.as,\n        set, m, mods;\n\n    if (values) {\n      m = values.length;\n\n      if (n > 1 && !as) {\n        error('Multi-field lookup requires explicit \"as\" parameter.');\n      }\n      if (as && as.length !== n * m) {\n        error('The \"as\" parameter has too few output field names.');\n      }\n      as = as || values.map(accessorName);\n\n      set = function(t) {\n        for (var i=0, k=0, j, v; i<n; ++i) {\n          v = index.get(keys[i](t));\n          if (v == null) for (j=0; j<m; ++j, ++k) t[as[k]] = defaultValue;\n          else for (j=0; j<m; ++j, ++k) t[as[k]] = values[j](v);\n        }\n      };\n    } else {\n      if (!as) {\n        error('Missing output field names.');\n      }\n\n      set = function(t) {\n        for (var i=0, v; i<n; ++i) {\n          v = index.get(keys[i](t));\n          t[as[i]] = v==null ? defaultValue : v;\n        }\n      };\n    }\n\n    if (reset) {\n      out = pulse.reflow(true);\n    } else {\n      mods = keys.some(k =>pulse.modified(k.fields));\n      flag |= (mods ? pulse.MOD : 0);\n    }\n    pulse.visit(flag, set);\n\n    return out.modifies(as);\n  }\n});\n","import {Operator} from 'vega-dataflow';\nimport {inherits} from 'vega-util';\n\n/**\n * Computes global min/max extents over a collection of extents.\n * @constructor\n * @param {object} params - The parameters for this operator.\n * @param {Array<Array<number>>} params.extents - The input extents.\n */\nexport default function MultiExtent(params) {\n  Operator.call(this, null, update, params);\n}\n\ninherits(MultiExtent, Operator);\n\nfunction update(_) {\n  if (this.value && !_.modified()) {\n    return this.value;\n  }\n\n  const ext = _.extents,\n        n = ext.length;\n\n  let min = +Infinity,\n      max = -Infinity,\n      i, e;\n\n  for (i = 0; i < n; ++i) {\n    e = ext[i];\n    if (e[0] < min) min = e[0];\n    if (e[1] > max) max = e[1];\n  }\n  return [min, max];\n}\n","import {Operator} from 'vega-dataflow';\nimport {inherits} from 'vega-util';\n\n/**\n * Merge a collection of value arrays.\n * @constructor\n * @param {object} params - The parameters for this operator.\n * @param {Array<Array<*>>} params.values - The input value arrrays.\n */\nexport default function MultiValues(params) {\n  Operator.call(this, null, update, params);\n}\n\ninherits(MultiValues, Operator);\n\nfunction update(_) {\n  return (this.value && !_.modified())\n    ? this.value\n    : _.values.reduce((data, _) => data.concat(_), []);\n}\n","import {Transform} from 'vega-dataflow';\nimport {inherits} from 'vega-util';\n\n/**\n * Operator whose value is simply its parameter hash. This operator is\n * useful for enabling reactive updates to values of nested objects.\n * @constructor\n * @param {object} params - The parameters for this operator.\n */\nexport default function Params(params) {\n  Transform.call(this, null, params);\n}\n\ninherits(Params, Transform, {\n  transform(_, pulse) {\n    this.modified(_.modified());\n    this.value = _;\n    return pulse.fork(pulse.NO_SOURCE | pulse.NO_FIELDS); // do not pass tuples\n  }\n});\n","import Aggregate from './Aggregate';\nimport {ValidAggregateOps} from './util/AggregateOps';\nimport {accessor, accessorFields, ascending, inherits} from 'vega-util';\n\n/**\n * Aggregate and pivot selected field values to become new fields.\n * This operator is useful to construction cross-tabulations.\n * @constructor\n * @param {Array<function(object): *>} [params.groupby] - An array of accessors\n *  to groupby. These fields act just like groupby fields of an Aggregate transform.\n * @param {function(object): *} params.field - The field to pivot on. The unique\n *  values of this field become new field names in the output stream.\n * @param {function(object): *} params.value - The field to populate pivoted fields.\n *  The aggregate values of this field become the values of the new pivoted fields.\n * @param {string} [params.op] - The aggregation operation for the value field,\n *  applied per cell in the output stream. The default is \"sum\".\n * @param {number} [params.limit] - An optional parameter indicating the maximum\n *  number of pivoted fields to generate. The pivoted field names are sorted in\n *  ascending order prior to enforcing the limit.\n */\nexport default function Pivot(params) {\n  Aggregate.call(this, params);\n}\n\nPivot.Definition = {\n  'type': 'Pivot',\n  'metadata': {'generates': true, 'changes': true},\n  'params': [\n    { 'name': 'groupby', 'type': 'field', 'array': true },\n    { 'name': 'field', 'type': 'field', 'required': true },\n    { 'name': 'value', 'type': 'field', 'required': true },\n    { 'name': 'op', 'type': 'enum', 'values': ValidAggregateOps, 'default': 'sum' },\n    { 'name': 'limit', 'type': 'number', 'default': 0 },\n    { 'name': 'key', 'type': 'field' }\n  ]\n};\n\ninherits(Pivot, Aggregate, {\n  _transform: Aggregate.prototype.transform,\n  transform(_, pulse) {\n    return this._transform(aggregateParams(_, pulse), pulse);\n  }\n});\n\n// Shoehorn a pivot transform into an aggregate transform!\n// First collect all unique pivot field values.\n// Then generate aggregate fields for each output pivot field.\nfunction aggregateParams(_, pulse) {\n  const key    = _.field,\n        value  = _.value,\n        op     = (_.op === 'count' ? '__count__' : _.op) || 'sum',\n        fields = accessorFields(key).concat(accessorFields(value)),\n        keys   = pivotKeys(key, _.limit || 0, pulse);\n\n  // if data stream content changes, pivot fields may change\n  // flag parameter modification to ensure re-initialization\n  if (pulse.changed()) _.set('__pivot__', null, null, true);\n\n  return {\n    key:      _.key,\n    groupby:  _.groupby,\n    ops:      keys.map(() => op),\n    fields:   keys.map(k => get(k, key, value, fields)),\n    as:       keys.map(k => k + ''),\n    modified: _.modified.bind(_)\n  };\n}\n\n// Generate aggregate field accessor.\n// Output NaN for non-existent values; aggregator will ignore!\nfunction get(k, key, value, fields) {\n  return accessor(\n    d => key(d) === k ? value(d) : NaN,\n    fields,\n    k + ''\n  );\n}\n\n// Collect (and optionally limit) all unique pivot values.\nfunction pivotKeys(key, limit, pulse) {\n  const map = {},\n        list = [];\n\n  pulse.visit(pulse.SOURCE, t => {\n    const k = key(t);\n    if (!map[k]) {\n      map[k] = 1;\n      list.push(k);\n    }\n  });\n\n  list.sort(ascending);\n\n  return limit ? list.slice(0, limit) : list;\n}\n","import Facet from './Facet';\nimport {ingest, tupleid} from 'vega-dataflow';\nimport {accessorFields, error, inherits} from 'vega-util';\n\n/**\n * Partitions pre-faceted data into tuple subflows.\n * @constructor\n * @param {object} params - The parameters for this operator.\n * @param {function(Dataflow, string): Operator} params.subflow - A function\n *   that generates a subflow of operators and returns its root operator.\n * @param {function(object): Array<object>} params.field - The field\n *   accessor for an array of subflow tuple objects.\n */\nexport default function PreFacet(params) {\n  Facet.call(this, params);\n}\n\ninherits(PreFacet, Facet, {\n  transform(_, pulse) {\n    const flow = _.subflow,\n          field = _.field,\n          subflow = t => this.subflow(tupleid(t), flow, pulse, t);\n\n    if (_.modified('field') || field && pulse.modified(accessorFields(field))) {\n      error('PreFacet does not support field modification.');\n    }\n\n    this.initTargets(); // reset list of active subflows\n\n    if (field) {\n      pulse.visit(pulse.MOD, t => {\n        const sf = subflow(t);\n        field(t).forEach(_ => sf.mod(_));\n      });\n\n      pulse.visit(pulse.ADD, t => {\n        const sf = subflow(t);\n        field(t).forEach(_ => sf.add(ingest(_)));\n      });\n\n      pulse.visit(pulse.REM, t => {\n        const sf = subflow(t);\n        field(t).forEach(_ => sf.rem(_));\n      });\n    } else {\n      pulse.visit(pulse.MOD, t => subflow(t).mod(t));\n      pulse.visit(pulse.ADD, t => subflow(t).add(t));\n      pulse.visit(pulse.REM, t => subflow(t).rem(t));\n    }\n\n    if (pulse.clean()) {\n      pulse.runAfter(() => this.clean());\n    }\n\n    return pulse;\n  }\n});\n","import {fieldNames} from './util/util';\nimport {Transform, ingest, rederive, tupleid} from 'vega-dataflow';\nimport {inherits} from 'vega-util';\n\n/**\n * Performs a relational projection, copying selected fields from source\n * tuples to a new set of derived tuples.\n * @constructor\n * @param {object} params - The parameters for this operator.\n * @param {Array<function(object): *} params.fields - The fields to project,\n *   as an array of field accessors. If unspecified, all fields will be\n *   copied with names unchanged.\n * @param {Array<string>} [params.as] - Output field names for each projected\n *   field. Any unspecified fields will use the field name provided by\n *   the field accessor.\n */\nexport default function Project(params) {\n  Transform.call(this, null, params);\n}\n\nProject.Definition = {\n  'type': 'Project',\n  'metadata': {'generates': true, 'changes': true},\n  'params': [\n    { 'name': 'fields', 'type': 'field', 'array': true },\n    { 'name': 'as', 'type': 'string', 'null': true, 'array': true }\n  ]\n};\n\ninherits(Project, Transform, {\n  transform(_, pulse) {\n    const out = pulse.fork(pulse.NO_SOURCE),\n          fields = _.fields,\n          as = fieldNames(_.fields, _.as || []),\n          derive = fields\n            ? (s, t) => project(s, t, fields, as)\n            : rederive;\n\n    let lut;\n    if (this.value) {\n      lut = this.value;\n    } else {\n      pulse = pulse.addAll();\n      lut = this.value = {};\n    }\n\n    pulse.visit(pulse.REM, t => {\n      const id = tupleid(t);\n      out.rem.push(lut[id]);\n      lut[id] = null;\n    });\n\n    pulse.visit(pulse.ADD, t => {\n      const dt = derive(t, ingest({}));\n      lut[tupleid(t)] = dt;\n      out.add.push(dt);\n    });\n\n    pulse.visit(pulse.MOD, t => {\n      out.mod.push(derive(t, lut[tupleid(t)]));\n    });\n\n    return out;\n  }\n});\n\nfunction project(s, t, fields, as) {\n  for (let i=0, n=fields.length; i<n; ++i) {\n    t[as[i]] = fields[i](s);\n  }\n  return t;\n}\n","import {Transform} from 'vega-dataflow';\nimport {inherits} from 'vega-util';\n\n/**\n * Proxy the value of another operator as a pure signal value.\n * Ensures no tuples are propagated.\n * @constructor\n * @param {object} params - The parameters for this operator.\n * @param {*} params.value - The value to proxy, becomes the value of this operator.\n */\nexport default function Proxy(params) {\n  Transform.call(this, null, params);\n}\n\ninherits(Proxy, Transform, {\n  transform(_, pulse) {\n    this.value = _.value;\n    return _.modified('value')\n      ? pulse.fork(pulse.NO_SOURCE | pulse.NO_FIELDS)\n      : pulse.StopPropagation;\n  }\n});\n","import {partition} from './util/util';\nimport {Transform, ingest} from 'vega-dataflow';\nimport {quantiles} from 'vega-statistics';\nimport {accessorName, inherits} from 'vega-util';\nimport {range} from 'd3-array';\n\n/**\n * Generates sample quantile values from an input data stream.\n * @constructor\n * @param {object} params - The parameters for this operator.\n * @param {function(object): *} params.field - An accessor for the data field\n *   over which to calculate quantile values.\n * @param {Array<function(object): *>} [params.groupby] - An array of accessors\n *   to groupby.\n * @param {Array<number>} [params.probs] - An array of probabilities in\n *   the range (0, 1) for which to compute quantile values. If not specified,\n *   the *step* parameter will be used.\n * @param {Array<number>} [params.step=0.01] - A probability step size for\n *   sampling quantile values. All values from one-half the step size up to\n *   1 (exclusive) will be sampled. This parameter is only used if the\n *   *quantiles* parameter is not provided.\n */\nexport default function Quantile(params) {\n  Transform.call(this, null, params);\n}\n\nQuantile.Definition = {\n  'type': 'Quantile',\n  'metadata': {'generates': true, 'changes': true},\n  'params': [\n    { 'name': 'groupby', 'type': 'field', 'array': true },\n    { 'name': 'field', 'type': 'field', 'required': true },\n    { 'name': 'probs', 'type': 'number', 'array': true },\n    { 'name': 'step', 'type': 'number', 'default': 0.01 },\n    { 'name': 'as', 'type': 'string', 'array': true, 'default': ['prob', 'value'] }\n  ]\n};\n\nconst EPSILON = 1e-14;\n\ninherits(Quantile, Transform, {\n  transform(_, pulse) {\n    const out = pulse.fork(pulse.NO_SOURCE | pulse.NO_FIELDS),\n          as = _.as || ['prob', 'value'];\n\n    if (this.value && !_.modified() && !pulse.changed()) {\n      out.source = this.value;\n      return out;\n    }\n\n    const source = pulse.materialize(pulse.SOURCE).source,\n          groups = partition(source, _.groupby, _.field),\n          names = (_.groupby || []).map(accessorName),\n          values = [],\n          step = _.step || 0.01,\n          p = _.probs || range(step/2, 1 - EPSILON, step),\n          n = p.length;\n\n    groups.forEach(g => {\n      const q = quantiles(g, p);\n\n      for (let i=0; i<n; ++i) {\n        const t = {};\n        for (let i=0; i<names.length; ++i) {\n          t[names[i]] = g.dims[i];\n        }\n        t[as[0]] = p[i];\n        t[as[1]] = q[i];\n        values.push(ingest(t));\n      }\n    });\n\n    if (this.value) out.rem = this.value;\n    this.value = out.add = out.source = values;\n\n    return out;\n  }\n});\n","import {Transform, derive, tupleid} from 'vega-dataflow';\nimport {inherits} from 'vega-util';\n\n/**\n * Relays a data stream between data processing pipelines.\n * If the derive parameter is set, this transform will create derived\n * copies of observed tuples. This provides derived data streams in which\n * modifications to the tuples do not pollute an upstream data source.\n * @param {object} params - The parameters for this operator.\n * @param {number} [params.derive=false] - Boolean flag indicating if\n *   the transform should make derived copies of incoming tuples.\n * @constructor\n */\nexport default function Relay(params) {\n  Transform.call(this, null, params);\n}\n\ninherits(Relay, Transform, {\n  transform(_, pulse) {\n    let out, lut;\n\n    if (this.value) {\n      lut = this.value;\n    } else {\n      out = pulse = pulse.addAll();\n      lut = this.value = {};\n    }\n\n    if (_.derive) {\n      out = pulse.fork(pulse.NO_SOURCE);\n\n      pulse.visit(pulse.REM, t => {\n        const id = tupleid(t);\n        out.rem.push(lut[id]);\n        lut[id] = null;\n      });\n\n      pulse.visit(pulse.ADD, t => {\n        const dt = derive(t);\n        lut[tupleid(t)] = dt;\n        out.add.push(dt);\n      });\n\n      pulse.visit(pulse.MOD, t => {\n        const dt = lut[tupleid(t)];\n        for (const k in t) {\n          dt[k] = t[k];\n          // down stream writes may overwrite re-derived tuples\n          // conservatively mark all source fields as modified\n          out.modifies(k);\n        }\n        out.mod.push(dt);\n      });\n    }\n\n    return out;\n  }\n});\n","import {Transform, tupleid} from 'vega-dataflow';\nimport {random} from 'vega-statistics';\nimport {inherits} from 'vega-util';\n\n/**\n * Samples tuples passing through this operator.\n * Uses reservoir sampling to maintain a representative sample.\n * @constructor\n * @param {object} params - The parameters for this operator.\n * @param {number} [params.size=1000] - The maximum number of samples.\n */\nexport default function Sample(params) {\n  Transform.call(this, [], params);\n  this.count = 0;\n}\n\nSample.Definition = {\n  'type': 'Sample',\n  'metadata': {},\n  'params': [\n    { 'name': 'size', 'type': 'number', 'default': 1000 }\n  ]\n};\n\ninherits(Sample, Transform, {\n  transform(_, pulse) {\n    const out = pulse.fork(pulse.NO_SOURCE),\n          mod = _.modified('size'),\n          num = _.size,\n          map = this.value.reduce((m, t) => (m[tupleid(t)] = 1, m), {});\n\n    let res = this.value,\n        cnt = this.count,\n        cap = 0;\n\n    // sample reservoir update function\n    function update(t) {\n      let p, idx;\n\n      if (res.length < num) {\n        res.push(t);\n      } else {\n        idx = ~~((cnt + 1) * random());\n        if (idx < res.length && idx >= cap) {\n          p = res[idx];\n          if (map[tupleid(p)]) out.rem.push(p); // eviction\n          res[idx] = t;\n        }\n      }\n      ++cnt;\n    }\n\n    if (pulse.rem.length) {\n      // find all tuples that should be removed, add to output\n      pulse.visit(pulse.REM, t => {\n        const id = tupleid(t);\n        if (map[id]) {\n          map[id] = -1;\n          out.rem.push(t);\n        }\n        --cnt;\n      });\n\n      // filter removed tuples out of the sample reservoir\n      res = res.filter(t => map[tupleid(t)] !== -1);\n    }\n\n    if ((pulse.rem.length || mod) && res.length < num && pulse.source) {\n      // replenish sample if backing data source is available\n      cap = cnt = res.length;\n      pulse.visit(pulse.SOURCE, t => {\n        // update, but skip previously sampled tuples\n        if (!map[tupleid(t)]) update(t);\n      });\n      cap = -1;\n    }\n\n    if (mod && res.length > num) {\n      const n = res.length-num;\n      for (let i=0; i<n; ++i) {\n        map[tupleid(res[i])] = -1;\n        out.rem.push(res[i]);\n      }\n      res = res.slice(n);\n    }\n\n    if (pulse.mod.length) {\n      // propagate modified tuples in the sample reservoir\n      pulse.visit(pulse.MOD, t => {\n        if (map[tupleid(t)]) out.mod.push(t);\n      });\n    }\n\n    if (pulse.add.length) {\n      // update sample reservoir\n      pulse.visit(pulse.ADD, update);\n    }\n\n    if (pulse.add.length || cap < 0) {\n      // output newly added tuples\n      out.add = res.filter(t => !map[tupleid(t)]);\n    }\n\n    this.count = cnt;\n    this.value = out.source = res;\n    return out;\n  }\n});\n","import {Transform, ingest} from 'vega-dataflow';\nimport {inherits} from 'vega-util';\nimport {range} from 'd3-array';\n\n/**\n * Generates data tuples for a specified sequence range of numbers.\n * @constructor\n * @param {object} params - The parameters for this operator.\n * @param {number} params.start - The first number in the sequence.\n * @param {number} params.stop - The last number (exclusive) in the sequence.\n * @param {number} [params.step=1] - The step size between numbers in the sequence.\n */\nexport default function Sequence(params) {\n  Transform.call(this, null, params);\n}\n\nSequence.Definition = {\n  'type': 'Sequence',\n  'metadata': {'generates': true, 'changes': true},\n  'params': [\n    { 'name': 'start', 'type': 'number', 'required': true },\n    { 'name': 'stop', 'type': 'number', 'required': true },\n    { 'name': 'step', 'type': 'number', 'default': 1 },\n    { 'name': 'as', 'type': 'string', 'default': 'data' }\n  ]\n};\n\ninherits(Sequence, Transform, {\n  transform(_, pulse) {\n    if (this.value && !_.modified()) return;\n\n    const out = pulse.materialize().fork(pulse.MOD),\n          as = _.as || 'data';\n\n    out.rem = this.value ? pulse.rem.concat(this.value) : pulse.rem;\n\n    this.value = range(_.start, _.stop, _.step || 1).map(v => {\n      const t = {};\n      t[as] = v;\n      return ingest(t);\n    });\n\n    out.add = pulse.add.concat(this.value);\n\n    return out;\n  }\n});\n","import {Transform} from 'vega-dataflow';\nimport {inherits} from 'vega-util';\n\n/**\n * Propagates a new pulse without any tuples so long as the input\n * pulse contains some added, removed or modified tuples.\n * @param {object} params - The parameters for this operator.\n * @constructor\n */\nexport default function Sieve(params) {\n  Transform.call(this, null, params);\n  this.modified(true); // always treat as modified\n}\n\ninherits(Sieve, Transform, {\n  transform(_, pulse) {\n    this.value = pulse.source;\n    return pulse.changed()\n      ? pulse.fork(pulse.NO_SOURCE | pulse.NO_FIELDS)\n      : pulse.StopPropagation;\n  }\n});\n\n","import {Transform} from 'vega-dataflow';\nimport {\n  TIME_UNITS, timeBin, timeFloor, timeInterval, timeUnits,\n  utcFloor, utcInterval\n} from 'vega-time';\nimport {accessorFields, extent, inherits, peek} from 'vega-util';\n\n/**\n * Discretize dates to specific time units.\n * @constructor\n * @param {object} params - The parameters for this operator.\n * @param {function(object): *} params.field - The data field containing date/time values.\n */\nexport default function TimeUnit(params) {\n  Transform.call(this, null, params);\n}\n\nconst OUTPUT = ['unit0', 'unit1'];\n\nTimeUnit.Definition = {\n  'type': 'TimeUnit',\n  'metadata': {'modifies': true},\n  'params': [\n    { 'name': 'field', 'type': 'field', 'required': true },\n    { 'name': 'interval', 'type': 'boolean', 'default': true },\n    { 'name': 'units', 'type': 'enum', 'values': TIME_UNITS, 'array': true },\n    { 'name': 'step', 'type': 'number', 'default': 1 },\n    { 'name': 'maxbins', 'type': 'number', 'default': 40 },\n    { 'name': 'extent', 'type': 'date', 'array': true},\n    { 'name': 'timezone', 'type': 'enum', 'default': 'local', 'values': ['local', 'utc'] },\n    { 'name': 'as', 'type': 'string', 'array': true, 'length': 2, 'default': OUTPUT }\n  ]\n};\n\ninherits(TimeUnit, Transform, {\n  transform(_, pulse) {\n    const field = _.field,\n          band = _.interval !== false,\n          utc = _.timezone === 'utc',\n          floor = this._floor(_, pulse),\n          offset = (utc ? utcInterval : timeInterval)(floor.unit).offset,\n          as = _.as || OUTPUT,\n          u0 = as[0],\n          u1 = as[1],\n          step = floor.step;\n\n    let min = floor.start || Infinity,\n        max = floor.stop || -Infinity,\n        flag = pulse.ADD;\n\n    if (\n      _.modified() ||\n      pulse.changed(pulse.REM) ||\n      pulse.modified(accessorFields(field))\n    ) {\n      pulse = pulse.reflow(true);\n      flag = pulse.SOURCE;\n      min = Infinity;\n      max = -Infinity;\n    }\n\n    pulse.visit(flag, t => {\n      const v = field(t);\n      let a, b;\n      if (v == null) {\n        t[u0] = null;\n        if (band) t[u1] = null;\n      } else {\n        t[u0] = a = b = floor(v);\n        if (band) t[u1] = b = offset(a, step);\n        if (a < min) min = a;\n        if (b > max) max = b;\n      }\n    });\n\n    floor.start = min;\n    floor.stop = max;\n\n    return pulse.modifies(band ? as : u0);\n  },\n\n  _floor(_, pulse) {\n    const utc = _.timezone === 'utc';\n\n    // get parameters\n    const {units, step} = _.units\n      ? {units: _.units, step: _.step || 1}\n      : timeBin({\n        extent:  _.extent || extent(pulse.materialize(pulse.SOURCE).source, _.field),\n        maxbins: _.maxbins\n      });\n\n    // check / standardize time units\n    const tunits = timeUnits(units),\n          prev = this.value || {},\n          floor = (utc ? utcFloor : timeFloor)(tunits, step);\n\n    floor.unit = peek(tunits);\n    floor.units = tunits;\n    floor.step = step;\n    floor.start = prev.start;\n    floor.stop = prev.stop;\n    return this.value = floor;\n  }\n});\n","import {Transform} from 'vega-dataflow';\nimport {fastmap, inherits} from 'vega-util';\n\n/**\n * An index that maps from unique, string-coerced, field values to tuples.\n * Assumes that the field serves as a unique key with no duplicate values.\n * @constructor\n * @param {object} params - The parameters for this operator.\n * @param {function(object): *} params.field - The field accessor to index.\n */\nexport default function TupleIndex(params) {\n  Transform.call(this, fastmap(), params);\n}\n\ninherits(TupleIndex, Transform, {\n  transform(_, pulse) {\n    const df = pulse.dataflow,\n        field = _.field,\n        index = this.value,\n        set = t => index.set(field(t), t);\n\n    let mod = true;\n\n    if (_.modified('field') || pulse.modified(field.fields)) {\n      index.clear();\n      pulse.visit(pulse.SOURCE, set);\n    } else if (pulse.changed()) {\n      pulse.visit(pulse.REM, t => index.delete(field(t)));\n      pulse.visit(pulse.ADD, set);\n    } else {\n      mod = false;\n    }\n\n    this.modified(mod);\n    if (index.empty > df.cleanThreshold) df.runAfter(index.clean);\n    return pulse.fork();\n  }\n});\n","import {Transform, stableCompare} from 'vega-dataflow';\nimport {inherits} from 'vega-util';\n\n/**\n * Extracts an array of values. Assumes the source data has already been\n * reduced as needed (e.g., by an upstream Aggregate transform).\n * @constructor\n * @param {object} params - The parameters for this operator.\n * @param {function(object): *} params.field - The domain field to extract.\n * @param {function(*,*): number} [params.sort] - An optional\n *   comparator function for sorting the values. The comparator will be\n *   applied to backing tuples prior to value extraction.\n */\nexport default function Values(params) {\n  Transform.call(this, null, params);\n}\n\ninherits(Values, Transform, {\n  transform(_, pulse) {\n    const run = !this.value\n      || _.modified('field')\n      || _.modified('sort')\n      || pulse.changed()\n      || (_.sort && pulse.modified(_.sort.fields));\n\n    if (run) {\n      this.value = (_.sort\n        ? pulse.source.slice().sort(stableCompare(_.sort))\n        : pulse.source).map(_.field);\n    }\n  }\n});","import {error, zero} from 'vega-util';\n\nexport function WindowOp(op, field, param, as) {\n  const fn = WindowOps[op](field, param);\n  return {\n    init:   fn.init || zero,\n    update: function(w, t) { t[as] = fn.next(w); }\n  };\n}\n\nexport const WindowOps = {\n  row_number: function() {\n    return {\n      next: w => w.index + 1\n    };\n  },\n  rank: function() {\n    let rank;\n    return {\n      init: () => rank = 1,\n      next: w => {\n        const i = w.index,\n              data = w.data;\n        return (i && w.compare(data[i - 1], data[i])) ? (rank = i + 1) : rank;\n      }\n    };\n  },\n  dense_rank: function() {\n    let drank;\n    return {\n      init: () => drank = 1,\n      next: w => {\n        const i = w.index,\n              d = w.data;\n        return (i && w.compare(d[i - 1], d[i])) ? ++drank : drank;\n      }\n    };\n  },\n  percent_rank: function() {\n    const rank = WindowOps.rank(),\n          next = rank.next;\n    return {\n      init: rank.init,\n      next: w => (next(w) - 1) / (w.data.length - 1)\n    };\n  },\n  cume_dist: function() {\n    let cume;\n    return {\n      init: () => cume = 0,\n      next: w => {\n        const d = w.data,\n              c = w.compare;\n        let i = w.index;\n        if (cume < i) {\n          while (i + 1 < d.length && !c(d[i], d[i + 1])) ++i;\n          cume = i;\n        }\n        return (1 + cume) / d.length;\n      }\n    };\n  },\n  ntile: function(field, num) {\n    num = +num;\n    if (!(num > 0)) error('ntile num must be greater than zero.');\n    const cume = WindowOps.cume_dist(),\n          next = cume.next;\n    return {\n      init: cume.init,\n      next: w => Math.ceil(num * next(w))\n    };\n  },\n\n  lag: function(field, offset) {\n    offset = +offset || 1;\n    return {\n      next: w => {\n        const i = w.index - offset;\n        return i >= 0 ? field(w.data[i]) : null;\n      }\n    };\n  },\n  lead: function(field, offset) {\n    offset = +offset || 1;\n    return {\n      next: w => {\n        const i = w.index + offset,\n            d = w.data;\n        return i < d.length ? field(d[i]) : null;\n      }\n    };\n  },\n\n  first_value: function(field) {\n    return {\n      next: w => field(w.data[w.i0])\n    };\n  },\n  last_value: function(field) {\n    return {\n      next: w => field(w.data[w.i1 - 1])\n    };\n  },\n  nth_value: function(field, nth) {\n    nth = +nth;\n    if (!(nth > 0)) error('nth_value nth must be greater than zero.');\n    return {\n      next: w => {\n        const i = w.i0 + (nth - 1);\n        return i < w.i1 ? field(w.data[i]) : null;\n      }\n    };\n  },\n\n  prev_value: function(field) {\n    let prev;\n    return {\n      init: () => prev = null,\n      next: w => {\n        const v = field(w.data[w.index]);\n        return v != null ? (prev = v) : prev;\n      }\n    };\n  },\n  next_value: function(field) {\n    let v, i;\n    return {\n      init: () => (v = null, i = -1),\n      next: w => {\n        const d = w.data;\n        return w.index <= i ? v\n          : (i = find(field, d, w.index)) < 0\n            ? (i = d.length, v = null)\n            : (v = field(d[i]));\n      }\n    };\n  }\n};\n\nfunction find(field, data, index) {\n  for (let n = data.length; index < n; ++index) {\n    const v = field(data[index]);\n    if (v != null) return index;\n  }\n  return -1;\n}\n\nexport const ValidWindowOps = Object.keys(WindowOps);\n","import {compileMeasures, createMeasure, measureName} from './AggregateOps';\nimport TupleStore from './TupleStore';\nimport {WindowOp, WindowOps} from './WindowOps';\nimport {accessorFields, accessorName, array, error, hasOwnProperty} from 'vega-util';\n\nexport default function WindowState(_) {\n  const ops = array(_.ops),\n        fields = array(_.fields),\n        params = array(_.params),\n        as = array(_.as),\n        outputs = this.outputs = [],\n        windows = this.windows = [],\n        inputs = {},\n        map = {},\n        counts = [],\n        measures = [];\n\n  let countOnly = true;\n\n  function visitInputs(f) {\n    array(accessorFields(f)).forEach(_ => inputs[_] = 1);\n  }\n  visitInputs(_.sort);\n\n  ops.forEach((op, i) => {\n    const field = fields[i],\n          mname = accessorName(field),\n          name = measureName(op, mname, as[i]);\n\n    visitInputs(field);\n    outputs.push(name);\n\n    // Window operation\n    if (hasOwnProperty(WindowOps, op)) {\n      windows.push(WindowOp(op, fields[i], params[i], name));\n    }\n\n    // Aggregate operation\n    else {\n      if (field == null && op !== 'count') {\n        error('Null aggregate field specified.');\n      }\n      if (op === 'count') {\n        counts.push(name);\n        return;\n      }\n\n      countOnly = false;\n      let m = map[mname];\n      if (!m) {\n        m = (map[mname] = []);\n        m.field = field;\n        measures.push(m);\n      }\n      m.push(createMeasure(op, name));\n    }\n  });\n\n  if (counts.length || measures.length) {\n    this.cell = cell(measures, counts, countOnly);\n  }\n\n  this.inputs = Object.keys(inputs);\n}\n\nconst prototype = WindowState.prototype;\n\nprototype.init = function() {\n  this.windows.forEach(_ => _.init());\n  if (this.cell) this.cell.init();\n};\n\nprototype.update = function(w, t) {\n  const cell = this.cell,\n        wind = this.windows,\n        data = w.data,\n        m = wind && wind.length;\n  let j;\n\n  if (cell) {\n    for (j = w.p0; j < w.i0; ++j) cell.rem(data[j]);\n    for (j = w.p1; j < w.i1; ++j) cell.add(data[j]);\n    cell.set(t);\n  }\n  for (j = 0; j < m; ++j) wind[j].update(w, t);\n};\n\nfunction cell(measures, counts, countOnly) {\n  measures = measures.map(m => compileMeasures(m, m.field));\n\n  const cell = {\n    num:   0,\n    agg:   null,\n    store: false,\n    count: counts\n  };\n\n  if (!countOnly) {\n    var n = measures.length,\n        a = cell.agg = Array(n),\n        i = 0;\n    for (; i<n; ++i) a[i] = new measures[i](cell);\n  }\n\n  if (cell.store) {\n    var store = cell.data = new TupleStore();\n  }\n\n  cell.add = function(t) {\n    cell.num += 1;\n    if (countOnly) return;\n    if (store) store.add(t);\n    for (let i=0; i<n; ++i) {\n      a[i].add(a[i].get(t), t);\n    }\n  };\n\n  cell.rem = function(t) {\n    cell.num -= 1;\n    if (countOnly) return;\n    if (store) store.rem(t);\n    for (let i=0; i<n; ++i) {\n      a[i].rem(a[i].get(t), t);\n    }\n  };\n\n  cell.set = function(t) {\n    let i, n;\n\n    // consolidate stored values\n    if (store) store.values();\n\n    // update tuple properties\n    for (i=0, n=counts.length; i<n; ++i) t[counts[i]] = cell.num;\n    if (!countOnly) for (i=0, n=a.length; i<n; ++i) a[i].set(t);\n  };\n\n  cell.init = function() {\n    cell.num = 0;\n    if (store) store.reset();\n    for (let i=0; i<n; ++i) a[i].init();\n  };\n\n  return cell;\n}\n","import {groupkey} from './util/AggregateKeys';\nimport {ValidAggregateOps} from './util/AggregateOps';\nimport SortedList from './util/SortedList';\nimport {ValidWindowOps} from './util/WindowOps';\nimport WindowState from './util/WindowState';\nimport {Transform, stableCompare, tupleid} from 'vega-dataflow';\nimport {constant, inherits} from 'vega-util';\nimport {bisector} from 'd3-array';\n\n/**\n * Perform window calculations and write results to the input stream.\n * @constructor\n * @param {object} params - The parameters for this operator.\n * @param {function(*,*): number} [params.sort] - A comparator function for sorting tuples within a window.\n * @param {Array<function(object): *>} [params.groupby] - An array of accessors by which to partition tuples into separate windows.\n * @param {Array<string>} params.ops - An array of strings indicating window operations to perform.\n * @param {Array<function(object): *>} [params.fields] - An array of accessors\n *   for data fields to use as inputs to window operations.\n * @param {Array<*>} [params.params] - An array of parameter values for window operations.\n * @param {Array<string>} [params.as] - An array of output field names for window operations.\n * @param {Array<number>} [params.frame] - Window frame definition as two-element array.\n * @param {boolean} [params.ignorePeers=false] - If true, base window frame boundaries on row\n *   number alone, ignoring peers with identical sort values. If false (default),\n *   the window boundaries will be adjusted to include peer values.\n */\nexport default function Window(params) {\n  Transform.call(this, {}, params);\n  this._mlen = 0;\n  this._mods = [];\n}\n\nWindow.Definition = {\n  'type': 'Window',\n  'metadata': {'modifies': true},\n  'params': [\n    { 'name': 'sort', 'type': 'compare' },\n    { 'name': 'groupby', 'type': 'field', 'array': true },\n    { 'name': 'ops', 'type': 'enum', 'array': true, 'values': ValidWindowOps.concat(ValidAggregateOps) },\n    { 'name': 'params', 'type': 'number', 'null': true, 'array': true },\n    { 'name': 'fields', 'type': 'field', 'null': true, 'array': true },\n    { 'name': 'as', 'type': 'string', 'null': true, 'array': true },\n    { 'name': 'frame', 'type': 'number', 'null': true, 'array': true, 'length': 2, 'default': [null, 0] },\n    { 'name': 'ignorePeers', 'type': 'boolean', 'default': false }\n  ]\n};\n\ninherits(Window, Transform, {\n  transform(_, pulse) {\n    this.stamp = pulse.stamp;\n\n    const mod = _.modified(),\n          cmp = stableCompare(_.sort),\n          key = groupkey(_.groupby),\n          group = t => this.group(key(t));\n\n    // initialize window state\n    let state = this.state;\n    if (!state || mod) {\n      state = this.state = new WindowState(_);\n    }\n\n    // partition input tuples\n    if (mod || pulse.modified(state.inputs)) {\n      this.value = {};\n      pulse.visit(pulse.SOURCE, t => group(t).add(t));\n    } else {\n      pulse.visit(pulse.REM, t => group(t).remove(t));\n      pulse.visit(pulse.ADD, t => group(t).add(t));\n    }\n\n    // perform window calculations for each modified partition\n    for (let i=0, n=this._mlen; i<n; ++i) {\n      processPartition(this._mods[i], state, cmp, _);\n    }\n    this._mlen = 0;\n    this._mods = [];\n\n    // TODO don't reflow everything?\n    return pulse.reflow(mod).modifies(state.outputs);\n  },\n\n  group(key) {\n    let group = this.value[key];\n\n    if (!group) {\n      group = this.value[key] = SortedList(tupleid);\n      group.stamp = -1;\n    }\n\n    if (group.stamp < this.stamp) {\n      group.stamp = this.stamp;\n      this._mods[this._mlen++] = group;\n    }\n\n    return group;\n  }\n});\n\nfunction processPartition(list, state, cmp, _) {\n  const sort = _.sort,\n        range = sort && !_.ignorePeers,\n        frame = _.frame || [null, 0],\n        data = list.data(cmp), // use cmp for stable sort\n        n = data.length,\n        b = range ? bisector(sort) : null,\n        w = {\n          i0: 0, i1: 0, p0: 0, p1: 0, index: 0,\n          data: data, compare: sort || constant(-1)\n        };\n\n  state.init();\n  for (let i=0; i<n; ++i) {\n    setWindow(w, frame, i, n);\n    if (range) adjustRange(w, b);\n    state.update(w, data[i]);\n  }\n}\n\nfunction setWindow(w, f, i, n) {\n  w.p0 = w.i0;\n  w.p1 = w.i1;\n  w.i0 = f[0] == null ? 0 : Math.max(0, i - Math.abs(f[0]));\n  w.i1 = f[1] == null ? n : Math.min(n, i + Math.abs(f[1]) + 1);\n  w.index = i;\n}\n\n// if frame type is 'range', adjust window for peer values\nfunction adjustRange(w, bisect) {\n  const r0 = w.i0,\n        r1 = w.i1 - 1,\n        c = w.compare,\n        d = w.data,\n        n = d.length - 1;\n\n  if (r0 > 0 && !c(d[r0], d[r0-1])) w.i0 = bisect.left(d, d[r0]);\n  if (r1 < n && !c(d[r1], d[r1+1])) w.i1 = bisect.right(d, d[r1]);\n}\n"],"names":["groupkey","fields","length","f","x","n","i","k","String","measureName","op","field","as","noop","base_op","init","add","rem","idx","AggregateOps","values","m","cell","store","value","data","count","num","__count__","missing","valid","sum","v","product","undefined","mean","mean_d","average","req","variance","dev","variancep","stdev","Math","sqrt","stdevp","stderr","distinct","get","ci0","ci1","median","q2","q1","q3","min","Number","isNaN","NaN","max","argmin","t","argmax","ValidAggregateOps","Object","keys","filter","d","createMeasure","name","compareIndex","a","b","this","_ops","forEach","set","_out","out","compileMeasures","agg","identity","ops","map","getreqs","key","sort","resolve","slice","ctr","prototype","TupleStore","_key","tupleid","reset","extend","measure","Aggregate","params","Transform","call","_adds","_mods","_alen","_mlen","_drop","_cross","_dims","_dnames","_measures","_countOnly","_counts","_prev","_inputs","_outputs","prototype$1","_add","_rem","_ext","_get","_q","push","r","Array","j","s","hasOwnProperty","extent","extentIndex","quartile","quartiles","ci","_ci","bootstrapCI","Definition","type","metadata","generates","changes","array","null","default","inherits","transform","_","pulse","aggr","fork","NO_SOURCE","NO_FIELDS","mod","modified","stamp","visit","SOURCE","REM","ADD","modifies","drop","cross","clean","runAfter","curr","dims","vals","collect","cells","tuple","generate","base","index","inputs","outputs","inputMap","inputVisit","accessorFields","groupby","dname","accessorName","cellkey","mname","outname","error","newcell","newtuple","measures","p","names","replace","ingest","celltuple","counts","adds","mods","prev","Bin","SortedList","idFunc","source","input","$","cnt","remove","size","compare","resort","merge","concat","Collect","Compare","Operator","update","orders","CountPattern","Cross","required","band","interval","bins","_bins","start","step","b0","b1","flag","reflow","ADD_MOD","bin","stop","ceil","anchor","floor","toNumber","Infinity","accessor","ALL","list","materialize","changed","stableCompare","root","process","tokens","text","tcase","match","toUpperCase","toLowerCase","tokenize","case","test","_parameterCheck","_match","_stop","_finish","RegExp","stopwords","pattern","tuples","_tuples","w","c","ADD_REM","left","truthy","Distributions","kde","randomKDE","mixture","randomMixture","normal","randomNormal","lognormal","randomLogNormal","uniform","randomUniform","DISTRIBUTIONS","FUNCTION","FIELD","parse","def","func","from","Density","distributions","function","fieldNames","partition","groups","g","dist","parseDist","distribution","minsteps","steps","maxsteps","method","domain","sampleCurve","DotBin","Expression","expr","datum","Extent","Subflow","parent","Facet","_keys","fastmap","_targets","active","Field","isArray","Filter","Flatten","Fold","Formula","Generate","ascending","descending","zero","ascendingDefined","valueof","quickselect","arguments","right","TypeError","compareDefined","z","log","exp","sd","swap","range","smooth","autostep","span","dotbin","isFinite","dataflow","warn","connect","target","detachSubflow","targets","evaluate","activate","flow","subflow","flows","df","sf","_group","detached","detach","initTargets","act","cache","rekey","group","id","delete","MOD","k0","k1","REFLOW","empty","cleanThreshold","output","isMod","revisit","has","arrays","maxlen","reduce","l","derive","fnames","initonly","gen","generator","Methods","Float64Array","numbers","i0","value0","subarray","quantile","Empty","Impute","JoinAggregate","KDE","Key","flat","Load","_pending","Lookup","MultiExtent","ext","extents","e","MultiValues","Params","Pivot","PreFacet","Project","Proxy","Quantile","gVals","kVal","impute","getValue","getField","fName","kName","gNames","keyvals","gKey","kMap","gMap","_impute","bandwidth","cumulative","density","scale","local","StopPropagation","format","async","request","url","then","res","touch","defaultValue","some","_transform","limit","pivotKeys","bind","aggregateParams","project","rederive","lut","addAll","dt","Relay","Sample","Sequence","Sieve","TimeUnit","probs","q","quantiles","cap","random","OUTPUT","TupleIndex","Values","TIME_UNITS","utc","timezone","_floor","offset","utcInterval","timeInterval","unit","u0","u1","units","timeBin","maxbins","tunits","timeUnits","utcFloor","timeFloor","peek","clear","WindowOps","row_number","next","rank","dense_rank","drank","percent_rank","cume_dist","cume","ntile","lag","lead","first_value","last_value","i1","nth_value","nth","prev_value","next_value","find","ValidWindowOps","WindowState","windows","countOnly","visitInputs","param","fn","WindowOp","Window","processPartition","state","cmp","ignorePeers","frame","compare1","compare2","delta","lo","hi","mid","center","bisector","p0","p1","constant","setWindow","adjustRange","abs","bisect","r0","r1","wind"],"mappings":"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"}